From 7348e4e2b16a8a348fa660f95c0a4e2c9a49e04d Mon Sep 17 00:00:00 2001 From: mikejiang Date: Thu, 21 Jan 2021 13:59:35 -0800 Subject: [PATCH] mv gs pb files back to here due to RGLab/cytolib#45 --- R/build.R | 24 +- R/hooks.R | 18 +- cleanup | 3 +- inst/NEWS | 10 + inst/include/GatingSet.proto | 258 + inst/include/cytolib/GatingSet.pb.h | 13932 +++++++++++++++++++++++++ inst/include/generate_pb_code.sh | 6 + src/GatingSet_pb_lib/GatingSet.pb.cc | 12657 ++++++++++++++++++++++ src/Makevars.in | 11 +- src/Makevars.win | 11 +- 10 files changed, 26920 insertions(+), 10 deletions(-) create mode 100644 inst/NEWS create mode 100644 inst/include/GatingSet.proto create mode 100644 inst/include/cytolib/GatingSet.pb.h create mode 100644 inst/include/generate_pb_code.sh create mode 100644 src/GatingSet_pb_lib/GatingSet.pb.cc diff --git a/R/build.R b/R/build.R index 0548ab5..4635e3f 100644 --- a/R/build.R +++ b/R/build.R @@ -36,12 +36,13 @@ pbCxxFlags <- function() { # Return the linker flags requried for pb on this platform pbLdFlags <- function() { lite = FALSE -# gslibs <- system.file(file.path("lib", "GatingSet.pb.o"), package = "RProtoBufLib") # on Windows and Solaris we need to explicitly link against pb.dll if ((Sys.info()['sysname'] %in% c("Windows", "SunOS")) && !isSparc()) { suffix <- ifelse(lite, "-lite", "") pb <- pbLibPath(suffix) - res <- asBuildPath(pb) + gs <- gsLibPath() +# res <- asBuildPath(pb) + res <- paste("-L", asBuildPath(dirname(pb)), asBuildPath(dirname(gs)), " -lprotobuf -lGatingSet.pb", sep = "") } else { res <- "" } @@ -71,6 +72,25 @@ pbLibPath <- function(suffix = "") { } } +gsLibPath <- function(suffix = "") { + sysname <- Sys.info()['sysname'] + pbSupported <- list( + "Darwin" = paste("libGatingSet.pb", suffix, ".dylib", sep = ""), + "Linux" = paste("libGatingSet.pb", suffix, ".so", sep = ""), + "Windows" = paste("libGatingSet.pb", suffix, ".dll", sep = ""), + "SunOS" = paste("libGatingSet.pb", suffix, ".so", sep = "") + ) + # browser() + if ((sysname %in% names(pbSupported)) && !isSparc()) { + libDir <- "lib/" + if (sysname == "Windows") + libDir <- paste(libDir, .Platform$r_arch, "/", sep="") + system.file(paste(libDir, pbSupported[[sysname]], sep = ""), + package = "RProtoBufLib") + } else { + NULL + } +} isSparc <- function() { Sys.info()['sysname'] == "SunOS" && Sys.info()[["machine"]] != "i86pc" diff --git a/R/hooks.R b/R/hooks.R index 0658a49..025d49c 100644 --- a/R/hooks.R +++ b/R/hooks.R @@ -13,9 +13,15 @@ dllInfo <- NULL } } - # load the package library - # library.dynam("RProtoBufLib", pkgname, libname) - + gs <- gsLibPath() + if (!is.null(gs)) { + if (!file.exists(gs)) { + warning(paste("libGatingSet.pb library", gs, "not found.")) + } else { + dllInfo <<- c(dllInfo, dyn.load(gs, local = FALSE, now = TRUE)) + } + } + } .onUnload <- function(libpath) { @@ -24,6 +30,8 @@ dllInfo <- NULL # library.dynam.unload("RProtoBufLib", libpath) # unload dll if we loaded it - if (!is.null(dllInfo)) - dyn.unload(dllInfo[["path"]]) + for(dll in dllInfo) + if (!is.null(dll)) + dyn.unload(dll[["path"]]) + } diff --git a/cleanup b/cleanup index 1a20229..41aaad8 100755 --- a/cleanup +++ b/cleanup @@ -2,7 +2,8 @@ rm -f config.* rm -rf src/pb_build -rm -rf src/protobuf-3.10.0 +rm -rf src/protobuf-3.13.0 +rm -f src/GatingSet_pb_lib/*.o rm -f src/Makevars rm -f src/*.o rm -f src/*.so diff --git a/inst/NEWS b/inst/NEWS new file mode 100644 index 0000000..de45bd9 --- /dev/null +++ b/inst/NEWS @@ -0,0 +1,10 @@ +2.1.4 +------------------------- +1. build shared protobuf library instead of static +2. load libprotobuf globally on .onLoad + +First release +------------------------- + +bundle the protobuf c++ library and expose its headers and static libraries + diff --git a/inst/include/GatingSet.proto b/inst/include/GatingSet.proto new file mode 100644 index 0000000..6ca8853 --- /dev/null +++ b/inst/include/GatingSet.proto @@ -0,0 +1,258 @@ +syntax = "proto2"; +package pb; +message paramRange{ + required string name = 1; + required float min = 2; + required float max = 3; +} +message rangeGate{ + required paramRange param = 1; +} +message paramPoly{ + repeated string params = 1;//params.at(0) is x, params.at(1) is y axis + repeated coordinate vertices = 2; +} +message polygonGate{ + required paramPoly param = 1; + optional quadGate qg = 2; + +} +message coordinate{ + required float x = 1; + required float y = 2; + +} +message ellipseGate{ + required coordinate mu = 1;// center point + repeated coordinate cov = 2;//covariance matrix + repeated coordinate antipodal_vertices = 3; + optional float dist = 4; +} +message BOOL_GATE_OP{ + repeated string path = 1; + required uint32 op = 2; + required bool isNot =3; +} + +message boolGate{ + repeated BOOL_GATE_OP boolOpSpec = 1;//the gatePaths with the their logical operators +} + +message clusterGate{ + required string cluster_method = 1; +} +enum QUADRANT{ + Q1 = 1;//-+ + Q2 = 2;//++ + Q3 = 3;//+- + Q4 = 4;//-- + +}; +message quadGate{ + required string uid = 1; + required QUADRANT quadrant = 3; +} +enum GATE_TYPE{ + POLYGON_GATE = 1; + RANGE_GATE = 2; + BOOL_GATE = 3; + ELLIPSE_GATE = 4; + RECT_GATE = 5; + LOGICAL_GATE = 6; + ELLIPSOID_GATE = 7; + CLUSTER_GATE = 8; + QUAD_GATE = 9; + } +message gate{ + required bool neg =1; + required bool isTransformed =2; + required bool isGained = 3; + required GATE_TYPE type = 4; + + optional rangeGate rg = 5; + optional polygonGate pg = 6; + optional ellipseGate eg = 7; + optional boolGate bg = 8; + optional clusterGate cg = 9; + +} + + +message POPSTATS{ + required string statType = 1; + required float statVal = 2; +} +enum ind_type { + BOOL = 0; + INT = 1; + ROOT = 2 ; + } +message calibrationTable{ + repeated float x = 1 [packed = true]; + repeated float y = 2 [packed = true]; + repeated float b = 3 [packed = true]; + repeated float c = 4 [packed = true]; + repeated float d = 5 [packed = true]; + optional uint32 spline_method = 6; + optional string caltype = 7; + optional bool flag = 8; +} +enum TRANS_TYPE { + PB_CALTBL = 0; + PB_LOG = 1 ; + PB_LIN = 2; + PB_FLIN = 3; + PB_FASIGNH = 4; + PB_BIEXP = 5; + PB_LOGICLE = 6; + PB_LOGGML2 = 7; + PB_SCALE = 8; + } +message biexpTrans{ + optional uint32 channelRange = 1; + optional float pos = 2; + optional float neg = 3; + optional float widthBasis = 4; + optional float maxValue = 5; +} +message fasinhTrans{ + optional float length = 1; + optional float maxRange= 2; + optional float T = 3; + optional float A = 4; + optional float M = 5;; +} +message scaleTrans{ + optional float scale_factor = 1; + optional float t_scale = 2; + optional float r_scale = 3; +} +message flinTrans{ + optional float min = 1; + optional float max = 2; +} +message logTrans{ + optional float offset = 1; + optional float decade = 2; + optional float T = 3; + optional float scale = 4; + } +message logGML2Trans{ + optional float T = 1; + optional float M = 2; +} +message logicleTrans{ + optional float T = 1; + optional float W= 2; + optional float M = 3; + optional float A = 4; + optional float bins = 5; + optional bool isGml2 = 6; + optional bool isInverse = 7; + +} +message transformation{ + optional calibrationTable calTbl = 1; + optional bool isGateOnly = 2; + optional string name = 4; + optional string channel = 5; + optional bool isComputed = 6; + optional uint32 type = 12; + optional TRANS_TYPE trans_type = 3; //used to handle polymorphism + optional biexpTrans bt = 7; + optional logTrans lt = 8; + optional flinTrans flt = 9; + optional scaleTrans st = 10; + optional fasinhTrans ft = 11; + optional logicleTrans lgt = 13; + optional logGML2Trans lgml2t = 14; +} + +message trans_pair{ + required string name = 1; + optional uint64 trans_address = 2;//legacy + optional transformation trans = 3; +} + +message trans_local{ + repeated trans_pair tp = 1; + optional string groupName = 2; + repeated uint32 sampleIDs = 3 [packed = true]; +} + +message POPINDICES{ + required uint32 nEvents = 1; + required ind_type indtype = 2; + repeated uint32 iInd = 3 [packed = true]; + optional bytes bInd = 4;//bits packaged into bytes +} + +message nodeProperties{ + required string thisName = 1; + repeated POPSTATS fjStats = 2; + repeated POPSTATS fcStats = 3; + required bool hidden = 4; + optional POPINDICES indices = 5; + optional gate thisGate = 6; + +} + +message treeNodes { + required nodeProperties node = 1; + optional uint32 parent = 2; +} + +message populationTree{ + repeated treeNodes node = 1; + +} +message COMP{ + optional string cid = 1; + optional string prefix = 2; + optional string suffix = 3; + optional string name = 4; + optional string comment = 5; + repeated string marker = 6; + repeated float spillOver = 7; +} +message PARAM{ + optional string param = 1; + optional bool log = 2; + optional uint32 range = 3; + optional uint32 highValue = 4; + optional uint32 calibrationIndex = 5; + //optional float timestep = 6; +} +message GatingHierarchy { + required populationTree tree = 2; + + optional COMP comp = 1; + optional bool isLoaded = 3; + + repeated PARAM transFlag = 4; + optional trans_local trans = 5; + optional CytoFrame frame = 6; +} +message CytoFrame { + required bool is_h5 = 1; +} + +//legacy +message TRANS_TBL{ + optional uint64 trans_address = 1; + optional transformation trans = 2; +} + +message GatingSet { + repeated TRANS_TBL trans_tbl = 2;//legacy + repeated string sampleName = 1; //a view of ghs + optional uint64 globalBiExpTrans = 3;//address of globalBiExpTrans, the actual object stored in trans_tbl + optional uint64 globalLinTrans = 4;//address of globalLinTrans, the actual object stored in trans_tbl + repeated trans_local gTrans = 5; + optional string guid = 6; + optional string cytolib_verion = 7; + optional string pb_verion = 8; + optional string h5_verion = 9; +// repeated gh_tbl ghs = 7;//gh is separately stored due to the size limit of pb message +} + diff --git a/inst/include/cytolib/GatingSet.pb.h b/inst/include/cytolib/GatingSet.pb.h new file mode 100644 index 0000000..e6c2d1d --- /dev/null +++ b/inst/include/cytolib/GatingSet.pb.h @@ -0,0 +1,13932 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: GatingSet.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_GatingSet_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_GatingSet_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3013000 +#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 3013000 < 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 +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_GatingSet_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[33] + 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_GatingSet_2eproto; +namespace pb { +class BOOL_GATE_OP; +class BOOL_GATE_OPDefaultTypeInternal; +extern BOOL_GATE_OPDefaultTypeInternal _BOOL_GATE_OP_default_instance_; +class COMP; +class COMPDefaultTypeInternal; +extern COMPDefaultTypeInternal _COMP_default_instance_; +class CytoFrame; +class CytoFrameDefaultTypeInternal; +extern CytoFrameDefaultTypeInternal _CytoFrame_default_instance_; +class GatingHierarchy; +class GatingHierarchyDefaultTypeInternal; +extern GatingHierarchyDefaultTypeInternal _GatingHierarchy_default_instance_; +class GatingSet; +class GatingSetDefaultTypeInternal; +extern GatingSetDefaultTypeInternal _GatingSet_default_instance_; +class PARAM; +class PARAMDefaultTypeInternal; +extern PARAMDefaultTypeInternal _PARAM_default_instance_; +class POPINDICES; +class POPINDICESDefaultTypeInternal; +extern POPINDICESDefaultTypeInternal _POPINDICES_default_instance_; +class POPSTATS; +class POPSTATSDefaultTypeInternal; +extern POPSTATSDefaultTypeInternal _POPSTATS_default_instance_; +class TRANS_TBL; +class TRANS_TBLDefaultTypeInternal; +extern TRANS_TBLDefaultTypeInternal _TRANS_TBL_default_instance_; +class biexpTrans; +class biexpTransDefaultTypeInternal; +extern biexpTransDefaultTypeInternal _biexpTrans_default_instance_; +class boolGate; +class boolGateDefaultTypeInternal; +extern boolGateDefaultTypeInternal _boolGate_default_instance_; +class calibrationTable; +class calibrationTableDefaultTypeInternal; +extern calibrationTableDefaultTypeInternal _calibrationTable_default_instance_; +class clusterGate; +class clusterGateDefaultTypeInternal; +extern clusterGateDefaultTypeInternal _clusterGate_default_instance_; +class coordinate; +class coordinateDefaultTypeInternal; +extern coordinateDefaultTypeInternal _coordinate_default_instance_; +class ellipseGate; +class ellipseGateDefaultTypeInternal; +extern ellipseGateDefaultTypeInternal _ellipseGate_default_instance_; +class fasinhTrans; +class fasinhTransDefaultTypeInternal; +extern fasinhTransDefaultTypeInternal _fasinhTrans_default_instance_; +class flinTrans; +class flinTransDefaultTypeInternal; +extern flinTransDefaultTypeInternal _flinTrans_default_instance_; +class gate; +class gateDefaultTypeInternal; +extern gateDefaultTypeInternal _gate_default_instance_; +class logGML2Trans; +class logGML2TransDefaultTypeInternal; +extern logGML2TransDefaultTypeInternal _logGML2Trans_default_instance_; +class logTrans; +class logTransDefaultTypeInternal; +extern logTransDefaultTypeInternal _logTrans_default_instance_; +class logicleTrans; +class logicleTransDefaultTypeInternal; +extern logicleTransDefaultTypeInternal _logicleTrans_default_instance_; +class nodeProperties; +class nodePropertiesDefaultTypeInternal; +extern nodePropertiesDefaultTypeInternal _nodeProperties_default_instance_; +class paramPoly; +class paramPolyDefaultTypeInternal; +extern paramPolyDefaultTypeInternal _paramPoly_default_instance_; +class paramRange; +class paramRangeDefaultTypeInternal; +extern paramRangeDefaultTypeInternal _paramRange_default_instance_; +class polygonGate; +class polygonGateDefaultTypeInternal; +extern polygonGateDefaultTypeInternal _polygonGate_default_instance_; +class populationTree; +class populationTreeDefaultTypeInternal; +extern populationTreeDefaultTypeInternal _populationTree_default_instance_; +class quadGate; +class quadGateDefaultTypeInternal; +extern quadGateDefaultTypeInternal _quadGate_default_instance_; +class rangeGate; +class rangeGateDefaultTypeInternal; +extern rangeGateDefaultTypeInternal _rangeGate_default_instance_; +class scaleTrans; +class scaleTransDefaultTypeInternal; +extern scaleTransDefaultTypeInternal _scaleTrans_default_instance_; +class trans_local; +class trans_localDefaultTypeInternal; +extern trans_localDefaultTypeInternal _trans_local_default_instance_; +class trans_pair; +class trans_pairDefaultTypeInternal; +extern trans_pairDefaultTypeInternal _trans_pair_default_instance_; +class transformation; +class transformationDefaultTypeInternal; +extern transformationDefaultTypeInternal _transformation_default_instance_; +class treeNodes; +class treeNodesDefaultTypeInternal; +extern treeNodesDefaultTypeInternal _treeNodes_default_instance_; +} // namespace pb +PROTOBUF_NAMESPACE_OPEN +template<> ::pb::BOOL_GATE_OP* Arena::CreateMaybeMessage<::pb::BOOL_GATE_OP>(Arena*); +template<> ::pb::COMP* Arena::CreateMaybeMessage<::pb::COMP>(Arena*); +template<> ::pb::CytoFrame* Arena::CreateMaybeMessage<::pb::CytoFrame>(Arena*); +template<> ::pb::GatingHierarchy* Arena::CreateMaybeMessage<::pb::GatingHierarchy>(Arena*); +template<> ::pb::GatingSet* Arena::CreateMaybeMessage<::pb::GatingSet>(Arena*); +template<> ::pb::PARAM* Arena::CreateMaybeMessage<::pb::PARAM>(Arena*); +template<> ::pb::POPINDICES* Arena::CreateMaybeMessage<::pb::POPINDICES>(Arena*); +template<> ::pb::POPSTATS* Arena::CreateMaybeMessage<::pb::POPSTATS>(Arena*); +template<> ::pb::TRANS_TBL* Arena::CreateMaybeMessage<::pb::TRANS_TBL>(Arena*); +template<> ::pb::biexpTrans* Arena::CreateMaybeMessage<::pb::biexpTrans>(Arena*); +template<> ::pb::boolGate* Arena::CreateMaybeMessage<::pb::boolGate>(Arena*); +template<> ::pb::calibrationTable* Arena::CreateMaybeMessage<::pb::calibrationTable>(Arena*); +template<> ::pb::clusterGate* Arena::CreateMaybeMessage<::pb::clusterGate>(Arena*); +template<> ::pb::coordinate* Arena::CreateMaybeMessage<::pb::coordinate>(Arena*); +template<> ::pb::ellipseGate* Arena::CreateMaybeMessage<::pb::ellipseGate>(Arena*); +template<> ::pb::fasinhTrans* Arena::CreateMaybeMessage<::pb::fasinhTrans>(Arena*); +template<> ::pb::flinTrans* Arena::CreateMaybeMessage<::pb::flinTrans>(Arena*); +template<> ::pb::gate* Arena::CreateMaybeMessage<::pb::gate>(Arena*); +template<> ::pb::logGML2Trans* Arena::CreateMaybeMessage<::pb::logGML2Trans>(Arena*); +template<> ::pb::logTrans* Arena::CreateMaybeMessage<::pb::logTrans>(Arena*); +template<> ::pb::logicleTrans* Arena::CreateMaybeMessage<::pb::logicleTrans>(Arena*); +template<> ::pb::nodeProperties* Arena::CreateMaybeMessage<::pb::nodeProperties>(Arena*); +template<> ::pb::paramPoly* Arena::CreateMaybeMessage<::pb::paramPoly>(Arena*); +template<> ::pb::paramRange* Arena::CreateMaybeMessage<::pb::paramRange>(Arena*); +template<> ::pb::polygonGate* Arena::CreateMaybeMessage<::pb::polygonGate>(Arena*); +template<> ::pb::populationTree* Arena::CreateMaybeMessage<::pb::populationTree>(Arena*); +template<> ::pb::quadGate* Arena::CreateMaybeMessage<::pb::quadGate>(Arena*); +template<> ::pb::rangeGate* Arena::CreateMaybeMessage<::pb::rangeGate>(Arena*); +template<> ::pb::scaleTrans* Arena::CreateMaybeMessage<::pb::scaleTrans>(Arena*); +template<> ::pb::trans_local* Arena::CreateMaybeMessage<::pb::trans_local>(Arena*); +template<> ::pb::trans_pair* Arena::CreateMaybeMessage<::pb::trans_pair>(Arena*); +template<> ::pb::transformation* Arena::CreateMaybeMessage<::pb::transformation>(Arena*); +template<> ::pb::treeNodes* Arena::CreateMaybeMessage<::pb::treeNodes>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace pb { + +enum QUADRANT : int { + Q1 = 1, + Q2 = 2, + Q3 = 3, + Q4 = 4 +}; +bool QUADRANT_IsValid(int value); +constexpr QUADRANT QUADRANT_MIN = Q1; +constexpr QUADRANT QUADRANT_MAX = Q4; +constexpr int QUADRANT_ARRAYSIZE = QUADRANT_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QUADRANT_descriptor(); +template +inline const std::string& QUADRANT_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function QUADRANT_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + QUADRANT_descriptor(), enum_t_value); +} +inline bool QUADRANT_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, QUADRANT* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + QUADRANT_descriptor(), name, value); +} +enum GATE_TYPE : int { + POLYGON_GATE = 1, + RANGE_GATE = 2, + BOOL_GATE = 3, + ELLIPSE_GATE = 4, + RECT_GATE = 5, + LOGICAL_GATE = 6, + ELLIPSOID_GATE = 7, + CLUSTER_GATE = 8, + QUAD_GATE = 9 +}; +bool GATE_TYPE_IsValid(int value); +constexpr GATE_TYPE GATE_TYPE_MIN = POLYGON_GATE; +constexpr GATE_TYPE GATE_TYPE_MAX = QUAD_GATE; +constexpr int GATE_TYPE_ARRAYSIZE = GATE_TYPE_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GATE_TYPE_descriptor(); +template +inline const std::string& GATE_TYPE_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function GATE_TYPE_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + GATE_TYPE_descriptor(), enum_t_value); +} +inline bool GATE_TYPE_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GATE_TYPE* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + GATE_TYPE_descriptor(), name, value); +} +enum ind_type : int { + BOOL = 0, + INT = 1, + ROOT = 2 +}; +bool ind_type_IsValid(int value); +constexpr ind_type ind_type_MIN = BOOL; +constexpr ind_type ind_type_MAX = ROOT; +constexpr int ind_type_ARRAYSIZE = ind_type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ind_type_descriptor(); +template +inline const std::string& ind_type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ind_type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ind_type_descriptor(), enum_t_value); +} +inline bool ind_type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ind_type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ind_type_descriptor(), name, value); +} +enum TRANS_TYPE : int { + PB_CALTBL = 0, + PB_LOG = 1, + PB_LIN = 2, + PB_FLIN = 3, + PB_FASIGNH = 4, + PB_BIEXP = 5, + PB_LOGICLE = 6, + PB_LOGGML2 = 7, + PB_SCALE = 8 +}; +bool TRANS_TYPE_IsValid(int value); +constexpr TRANS_TYPE TRANS_TYPE_MIN = PB_CALTBL; +constexpr TRANS_TYPE TRANS_TYPE_MAX = PB_SCALE; +constexpr int TRANS_TYPE_ARRAYSIZE = TRANS_TYPE_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TRANS_TYPE_descriptor(); +template +inline const std::string& TRANS_TYPE_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function TRANS_TYPE_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + TRANS_TYPE_descriptor(), enum_t_value); +} +inline bool TRANS_TYPE_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TRANS_TYPE* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + TRANS_TYPE_descriptor(), name, value); +} +// =================================================================== + +class paramRange PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.paramRange) */ { + public: + inline paramRange() : paramRange(nullptr) {} + virtual ~paramRange(); + + paramRange(const paramRange& from); + paramRange(paramRange&& from) noexcept + : paramRange() { + *this = ::std::move(from); + } + + inline paramRange& operator=(const paramRange& from) { + CopyFrom(from); + return *this; + } + inline paramRange& operator=(paramRange&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const paramRange& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const paramRange* internal_default_instance() { + return reinterpret_cast( + &_paramRange_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(paramRange& a, paramRange& b) { + a.Swap(&b); + } + inline void Swap(paramRange* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(paramRange* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline paramRange* New() const final { + return CreateMaybeMessage(nullptr); + } + + paramRange* 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 paramRange& from); + void MergeFrom(const paramRange& 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(paramRange* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.paramRange"; + } + protected: + explicit paramRange(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kMinFieldNumber = 2, + kMaxFieldNumber = 3, + }; + // required string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // required float min = 2; + bool has_min() const; + private: + bool _internal_has_min() const; + public: + void clear_min(); + float min() const; + void set_min(float value); + private: + float _internal_min() const; + void _internal_set_min(float value); + public: + + // required float max = 3; + bool has_max() const; + private: + bool _internal_has_max() const; + public: + void clear_max(); + float max() const; + void set_max(float value); + private: + float _internal_max() const; + void _internal_set_max(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.paramRange) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + float min_; + float max_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class rangeGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.rangeGate) */ { + public: + inline rangeGate() : rangeGate(nullptr) {} + virtual ~rangeGate(); + + rangeGate(const rangeGate& from); + rangeGate(rangeGate&& from) noexcept + : rangeGate() { + *this = ::std::move(from); + } + + inline rangeGate& operator=(const rangeGate& from) { + CopyFrom(from); + return *this; + } + inline rangeGate& operator=(rangeGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const rangeGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const rangeGate* internal_default_instance() { + return reinterpret_cast( + &_rangeGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(rangeGate& a, rangeGate& b) { + a.Swap(&b); + } + inline void Swap(rangeGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(rangeGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline rangeGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + rangeGate* 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 rangeGate& from); + void MergeFrom(const rangeGate& 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(rangeGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.rangeGate"; + } + protected: + explicit rangeGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamFieldNumber = 1, + }; + // required .pb.paramRange param = 1; + bool has_param() const; + private: + bool _internal_has_param() const; + public: + void clear_param(); + const ::pb::paramRange& param() const; + ::pb::paramRange* release_param(); + ::pb::paramRange* mutable_param(); + void set_allocated_param(::pb::paramRange* param); + private: + const ::pb::paramRange& _internal_param() const; + ::pb::paramRange* _internal_mutable_param(); + public: + void unsafe_arena_set_allocated_param( + ::pb::paramRange* param); + ::pb::paramRange* unsafe_arena_release_param(); + + // @@protoc_insertion_point(class_scope:pb.rangeGate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::pb::paramRange* param_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class paramPoly PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.paramPoly) */ { + public: + inline paramPoly() : paramPoly(nullptr) {} + virtual ~paramPoly(); + + paramPoly(const paramPoly& from); + paramPoly(paramPoly&& from) noexcept + : paramPoly() { + *this = ::std::move(from); + } + + inline paramPoly& operator=(const paramPoly& from) { + CopyFrom(from); + return *this; + } + inline paramPoly& operator=(paramPoly&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const paramPoly& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const paramPoly* internal_default_instance() { + return reinterpret_cast( + &_paramPoly_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(paramPoly& a, paramPoly& b) { + a.Swap(&b); + } + inline void Swap(paramPoly* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(paramPoly* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline paramPoly* New() const final { + return CreateMaybeMessage(nullptr); + } + + paramPoly* 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 paramPoly& from); + void MergeFrom(const paramPoly& 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(paramPoly* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.paramPoly"; + } + protected: + explicit paramPoly(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamsFieldNumber = 1, + kVerticesFieldNumber = 2, + }; + // repeated string params = 1; + int params_size() const; + private: + int _internal_params_size() const; + public: + void clear_params(); + const std::string& params(int index) const; + std::string* mutable_params(int index); + void set_params(int index, const std::string& value); + void set_params(int index, std::string&& value); + void set_params(int index, const char* value); + void set_params(int index, const char* value, size_t size); + std::string* add_params(); + void add_params(const std::string& value); + void add_params(std::string&& value); + void add_params(const char* value); + void add_params(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& params() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_params(); + private: + const std::string& _internal_params(int index) const; + std::string* _internal_add_params(); + public: + + // repeated .pb.coordinate vertices = 2; + int vertices_size() const; + private: + int _internal_vertices_size() const; + public: + void clear_vertices(); + ::pb::coordinate* mutable_vertices(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* + mutable_vertices(); + private: + const ::pb::coordinate& _internal_vertices(int index) const; + ::pb::coordinate* _internal_add_vertices(); + public: + const ::pb::coordinate& vertices(int index) const; + ::pb::coordinate* add_vertices(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& + vertices() const; + + // @@protoc_insertion_point(class_scope:pb.paramPoly) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField params_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > vertices_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class polygonGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.polygonGate) */ { + public: + inline polygonGate() : polygonGate(nullptr) {} + virtual ~polygonGate(); + + polygonGate(const polygonGate& from); + polygonGate(polygonGate&& from) noexcept + : polygonGate() { + *this = ::std::move(from); + } + + inline polygonGate& operator=(const polygonGate& from) { + CopyFrom(from); + return *this; + } + inline polygonGate& operator=(polygonGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const polygonGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const polygonGate* internal_default_instance() { + return reinterpret_cast( + &_polygonGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(polygonGate& a, polygonGate& b) { + a.Swap(&b); + } + inline void Swap(polygonGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(polygonGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline polygonGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + polygonGate* 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 polygonGate& from); + void MergeFrom(const polygonGate& 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(polygonGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.polygonGate"; + } + protected: + explicit polygonGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamFieldNumber = 1, + kQgFieldNumber = 2, + }; + // required .pb.paramPoly param = 1; + bool has_param() const; + private: + bool _internal_has_param() const; + public: + void clear_param(); + const ::pb::paramPoly& param() const; + ::pb::paramPoly* release_param(); + ::pb::paramPoly* mutable_param(); + void set_allocated_param(::pb::paramPoly* param); + private: + const ::pb::paramPoly& _internal_param() const; + ::pb::paramPoly* _internal_mutable_param(); + public: + void unsafe_arena_set_allocated_param( + ::pb::paramPoly* param); + ::pb::paramPoly* unsafe_arena_release_param(); + + // optional .pb.quadGate qg = 2; + bool has_qg() const; + private: + bool _internal_has_qg() const; + public: + void clear_qg(); + const ::pb::quadGate& qg() const; + ::pb::quadGate* release_qg(); + ::pb::quadGate* mutable_qg(); + void set_allocated_qg(::pb::quadGate* qg); + private: + const ::pb::quadGate& _internal_qg() const; + ::pb::quadGate* _internal_mutable_qg(); + public: + void unsafe_arena_set_allocated_qg( + ::pb::quadGate* qg); + ::pb::quadGate* unsafe_arena_release_qg(); + + // @@protoc_insertion_point(class_scope:pb.polygonGate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::pb::paramPoly* param_; + ::pb::quadGate* qg_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class coordinate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.coordinate) */ { + public: + inline coordinate() : coordinate(nullptr) {} + virtual ~coordinate(); + + coordinate(const coordinate& from); + coordinate(coordinate&& from) noexcept + : coordinate() { + *this = ::std::move(from); + } + + inline coordinate& operator=(const coordinate& from) { + CopyFrom(from); + return *this; + } + inline coordinate& operator=(coordinate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const coordinate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const coordinate* internal_default_instance() { + return reinterpret_cast( + &_coordinate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(coordinate& a, coordinate& b) { + a.Swap(&b); + } + inline void Swap(coordinate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(coordinate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline coordinate* New() const final { + return CreateMaybeMessage(nullptr); + } + + coordinate* 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 coordinate& from); + void MergeFrom(const coordinate& 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(coordinate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.coordinate"; + } + protected: + explicit coordinate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + // required float x = 1; + bool has_x() const; + private: + bool _internal_has_x() const; + public: + void clear_x(); + float x() const; + void set_x(float value); + private: + float _internal_x() const; + void _internal_set_x(float value); + public: + + // required float y = 2; + bool has_y() const; + private: + bool _internal_has_y() const; + public: + void clear_y(); + float y() const; + void set_y(float value); + private: + float _internal_y() const; + void _internal_set_y(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.coordinate) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float x_; + float y_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class ellipseGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.ellipseGate) */ { + public: + inline ellipseGate() : ellipseGate(nullptr) {} + virtual ~ellipseGate(); + + ellipseGate(const ellipseGate& from); + ellipseGate(ellipseGate&& from) noexcept + : ellipseGate() { + *this = ::std::move(from); + } + + inline ellipseGate& operator=(const ellipseGate& from) { + CopyFrom(from); + return *this; + } + inline ellipseGate& operator=(ellipseGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ellipseGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ellipseGate* internal_default_instance() { + return reinterpret_cast( + &_ellipseGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(ellipseGate& a, ellipseGate& b) { + a.Swap(&b); + } + inline void Swap(ellipseGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ellipseGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ellipseGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + ellipseGate* 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 ellipseGate& from); + void MergeFrom(const ellipseGate& 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(ellipseGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.ellipseGate"; + } + protected: + explicit ellipseGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCovFieldNumber = 2, + kAntipodalVerticesFieldNumber = 3, + kMuFieldNumber = 1, + kDistFieldNumber = 4, + }; + // repeated .pb.coordinate cov = 2; + int cov_size() const; + private: + int _internal_cov_size() const; + public: + void clear_cov(); + ::pb::coordinate* mutable_cov(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* + mutable_cov(); + private: + const ::pb::coordinate& _internal_cov(int index) const; + ::pb::coordinate* _internal_add_cov(); + public: + const ::pb::coordinate& cov(int index) const; + ::pb::coordinate* add_cov(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& + cov() const; + + // repeated .pb.coordinate antipodal_vertices = 3; + int antipodal_vertices_size() const; + private: + int _internal_antipodal_vertices_size() const; + public: + void clear_antipodal_vertices(); + ::pb::coordinate* mutable_antipodal_vertices(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* + mutable_antipodal_vertices(); + private: + const ::pb::coordinate& _internal_antipodal_vertices(int index) const; + ::pb::coordinate* _internal_add_antipodal_vertices(); + public: + const ::pb::coordinate& antipodal_vertices(int index) const; + ::pb::coordinate* add_antipodal_vertices(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& + antipodal_vertices() const; + + // required .pb.coordinate mu = 1; + bool has_mu() const; + private: + bool _internal_has_mu() const; + public: + void clear_mu(); + const ::pb::coordinate& mu() const; + ::pb::coordinate* release_mu(); + ::pb::coordinate* mutable_mu(); + void set_allocated_mu(::pb::coordinate* mu); + private: + const ::pb::coordinate& _internal_mu() const; + ::pb::coordinate* _internal_mutable_mu(); + public: + void unsafe_arena_set_allocated_mu( + ::pb::coordinate* mu); + ::pb::coordinate* unsafe_arena_release_mu(); + + // optional float dist = 4; + bool has_dist() const; + private: + bool _internal_has_dist() const; + public: + void clear_dist(); + float dist() const; + void set_dist(float value); + private: + float _internal_dist() const; + void _internal_set_dist(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.ellipseGate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > cov_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate > antipodal_vertices_; + ::pb::coordinate* mu_; + float dist_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class BOOL_GATE_OP PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.BOOL_GATE_OP) */ { + public: + inline BOOL_GATE_OP() : BOOL_GATE_OP(nullptr) {} + virtual ~BOOL_GATE_OP(); + + BOOL_GATE_OP(const BOOL_GATE_OP& from); + BOOL_GATE_OP(BOOL_GATE_OP&& from) noexcept + : BOOL_GATE_OP() { + *this = ::std::move(from); + } + + inline BOOL_GATE_OP& operator=(const BOOL_GATE_OP& from) { + CopyFrom(from); + return *this; + } + inline BOOL_GATE_OP& operator=(BOOL_GATE_OP&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const BOOL_GATE_OP& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BOOL_GATE_OP* internal_default_instance() { + return reinterpret_cast( + &_BOOL_GATE_OP_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(BOOL_GATE_OP& a, BOOL_GATE_OP& b) { + a.Swap(&b); + } + inline void Swap(BOOL_GATE_OP* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BOOL_GATE_OP* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BOOL_GATE_OP* New() const final { + return CreateMaybeMessage(nullptr); + } + + BOOL_GATE_OP* 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 BOOL_GATE_OP& from); + void MergeFrom(const BOOL_GATE_OP& 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(BOOL_GATE_OP* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.BOOL_GATE_OP"; + } + protected: + explicit BOOL_GATE_OP(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPathFieldNumber = 1, + kOpFieldNumber = 2, + kIsNotFieldNumber = 3, + }; + // repeated string path = 1; + int path_size() const; + private: + int _internal_path_size() const; + public: + void clear_path(); + const std::string& path(int index) const; + std::string* mutable_path(int index); + void set_path(int index, const std::string& value); + void set_path(int index, std::string&& value); + void set_path(int index, const char* value); + void set_path(int index, const char* value, size_t size); + std::string* add_path(); + void add_path(const std::string& value); + void add_path(std::string&& value); + void add_path(const char* value); + void add_path(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& path() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_path(); + private: + const std::string& _internal_path(int index) const; + std::string* _internal_add_path(); + public: + + // required uint32 op = 2; + bool has_op() const; + private: + bool _internal_has_op() const; + public: + void clear_op(); + ::PROTOBUF_NAMESPACE_ID::uint32 op() const; + void set_op(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_op() const; + void _internal_set_op(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // required bool isNot = 3; + bool has_isnot() const; + private: + bool _internal_has_isnot() const; + public: + void clear_isnot(); + bool isnot() const; + void set_isnot(bool value); + private: + bool _internal_isnot() const; + void _internal_set_isnot(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.BOOL_GATE_OP) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField path_; + ::PROTOBUF_NAMESPACE_ID::uint32 op_; + bool isnot_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class boolGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.boolGate) */ { + public: + inline boolGate() : boolGate(nullptr) {} + virtual ~boolGate(); + + boolGate(const boolGate& from); + boolGate(boolGate&& from) noexcept + : boolGate() { + *this = ::std::move(from); + } + + inline boolGate& operator=(const boolGate& from) { + CopyFrom(from); + return *this; + } + inline boolGate& operator=(boolGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const boolGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const boolGate* internal_default_instance() { + return reinterpret_cast( + &_boolGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(boolGate& a, boolGate& b) { + a.Swap(&b); + } + inline void Swap(boolGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(boolGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline boolGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + boolGate* 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 boolGate& from); + void MergeFrom(const boolGate& 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(boolGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.boolGate"; + } + protected: + explicit boolGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBoolOpSpecFieldNumber = 1, + }; + // repeated .pb.BOOL_GATE_OP boolOpSpec = 1; + int boolopspec_size() const; + private: + int _internal_boolopspec_size() const; + public: + void clear_boolopspec(); + ::pb::BOOL_GATE_OP* mutable_boolopspec(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >* + mutable_boolopspec(); + private: + const ::pb::BOOL_GATE_OP& _internal_boolopspec(int index) const; + ::pb::BOOL_GATE_OP* _internal_add_boolopspec(); + public: + const ::pb::BOOL_GATE_OP& boolopspec(int index) const; + ::pb::BOOL_GATE_OP* add_boolopspec(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >& + boolopspec() const; + + // @@protoc_insertion_point(class_scope:pb.boolGate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP > boolopspec_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class clusterGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.clusterGate) */ { + public: + inline clusterGate() : clusterGate(nullptr) {} + virtual ~clusterGate(); + + clusterGate(const clusterGate& from); + clusterGate(clusterGate&& from) noexcept + : clusterGate() { + *this = ::std::move(from); + } + + inline clusterGate& operator=(const clusterGate& from) { + CopyFrom(from); + return *this; + } + inline clusterGate& operator=(clusterGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const clusterGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const clusterGate* internal_default_instance() { + return reinterpret_cast( + &_clusterGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(clusterGate& a, clusterGate& b) { + a.Swap(&b); + } + inline void Swap(clusterGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(clusterGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline clusterGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + clusterGate* 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 clusterGate& from); + void MergeFrom(const clusterGate& 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(clusterGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.clusterGate"; + } + protected: + explicit clusterGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kClusterMethodFieldNumber = 1, + }; + // required string cluster_method = 1; + bool has_cluster_method() const; + private: + bool _internal_has_cluster_method() const; + public: + void clear_cluster_method(); + const std::string& cluster_method() const; + void set_cluster_method(const std::string& value); + void set_cluster_method(std::string&& value); + void set_cluster_method(const char* value); + void set_cluster_method(const char* value, size_t size); + std::string* mutable_cluster_method(); + std::string* release_cluster_method(); + void set_allocated_cluster_method(std::string* cluster_method); + private: + const std::string& _internal_cluster_method() const; + void _internal_set_cluster_method(const std::string& value); + std::string* _internal_mutable_cluster_method(); + public: + + // @@protoc_insertion_point(class_scope:pb.clusterGate) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cluster_method_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class quadGate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.quadGate) */ { + public: + inline quadGate() : quadGate(nullptr) {} + virtual ~quadGate(); + + quadGate(const quadGate& from); + quadGate(quadGate&& from) noexcept + : quadGate() { + *this = ::std::move(from); + } + + inline quadGate& operator=(const quadGate& from) { + CopyFrom(from); + return *this; + } + inline quadGate& operator=(quadGate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const quadGate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const quadGate* internal_default_instance() { + return reinterpret_cast( + &_quadGate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(quadGate& a, quadGate& b) { + a.Swap(&b); + } + inline void Swap(quadGate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(quadGate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline quadGate* New() const final { + return CreateMaybeMessage(nullptr); + } + + quadGate* 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 quadGate& from); + void MergeFrom(const quadGate& 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(quadGate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.quadGate"; + } + protected: + explicit quadGate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUidFieldNumber = 1, + kQuadrantFieldNumber = 3, + }; + // required string uid = 1; + bool has_uid() const; + private: + bool _internal_has_uid() const; + public: + void clear_uid(); + const std::string& uid() const; + void set_uid(const std::string& value); + void set_uid(std::string&& value); + void set_uid(const char* value); + void set_uid(const char* value, size_t size); + std::string* mutable_uid(); + std::string* release_uid(); + void set_allocated_uid(std::string* uid); + private: + const std::string& _internal_uid() const; + void _internal_set_uid(const std::string& value); + std::string* _internal_mutable_uid(); + public: + + // required .pb.QUADRANT quadrant = 3; + bool has_quadrant() const; + private: + bool _internal_has_quadrant() const; + public: + void clear_quadrant(); + ::pb::QUADRANT quadrant() const; + void set_quadrant(::pb::QUADRANT value); + private: + ::pb::QUADRANT _internal_quadrant() const; + void _internal_set_quadrant(::pb::QUADRANT value); + public: + + // @@protoc_insertion_point(class_scope:pb.quadGate) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uid_; + int quadrant_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class gate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.gate) */ { + public: + inline gate() : gate(nullptr) {} + virtual ~gate(); + + gate(const gate& from); + gate(gate&& from) noexcept + : gate() { + *this = ::std::move(from); + } + + inline gate& operator=(const gate& from) { + CopyFrom(from); + return *this; + } + inline gate& operator=(gate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const gate& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const gate* internal_default_instance() { + return reinterpret_cast( + &_gate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(gate& a, gate& b) { + a.Swap(&b); + } + inline void Swap(gate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(gate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline gate* New() const final { + return CreateMaybeMessage(nullptr); + } + + gate* 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 gate& from); + void MergeFrom(const gate& 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(gate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.gate"; + } + protected: + explicit gate(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRgFieldNumber = 5, + kPgFieldNumber = 6, + kEgFieldNumber = 7, + kBgFieldNumber = 8, + kCgFieldNumber = 9, + kNegFieldNumber = 1, + kIsTransformedFieldNumber = 2, + kIsGainedFieldNumber = 3, + kTypeFieldNumber = 4, + }; + // optional .pb.rangeGate rg = 5; + bool has_rg() const; + private: + bool _internal_has_rg() const; + public: + void clear_rg(); + const ::pb::rangeGate& rg() const; + ::pb::rangeGate* release_rg(); + ::pb::rangeGate* mutable_rg(); + void set_allocated_rg(::pb::rangeGate* rg); + private: + const ::pb::rangeGate& _internal_rg() const; + ::pb::rangeGate* _internal_mutable_rg(); + public: + void unsafe_arena_set_allocated_rg( + ::pb::rangeGate* rg); + ::pb::rangeGate* unsafe_arena_release_rg(); + + // optional .pb.polygonGate pg = 6; + bool has_pg() const; + private: + bool _internal_has_pg() const; + public: + void clear_pg(); + const ::pb::polygonGate& pg() const; + ::pb::polygonGate* release_pg(); + ::pb::polygonGate* mutable_pg(); + void set_allocated_pg(::pb::polygonGate* pg); + private: + const ::pb::polygonGate& _internal_pg() const; + ::pb::polygonGate* _internal_mutable_pg(); + public: + void unsafe_arena_set_allocated_pg( + ::pb::polygonGate* pg); + ::pb::polygonGate* unsafe_arena_release_pg(); + + // optional .pb.ellipseGate eg = 7; + bool has_eg() const; + private: + bool _internal_has_eg() const; + public: + void clear_eg(); + const ::pb::ellipseGate& eg() const; + ::pb::ellipseGate* release_eg(); + ::pb::ellipseGate* mutable_eg(); + void set_allocated_eg(::pb::ellipseGate* eg); + private: + const ::pb::ellipseGate& _internal_eg() const; + ::pb::ellipseGate* _internal_mutable_eg(); + public: + void unsafe_arena_set_allocated_eg( + ::pb::ellipseGate* eg); + ::pb::ellipseGate* unsafe_arena_release_eg(); + + // optional .pb.boolGate bg = 8; + bool has_bg() const; + private: + bool _internal_has_bg() const; + public: + void clear_bg(); + const ::pb::boolGate& bg() const; + ::pb::boolGate* release_bg(); + ::pb::boolGate* mutable_bg(); + void set_allocated_bg(::pb::boolGate* bg); + private: + const ::pb::boolGate& _internal_bg() const; + ::pb::boolGate* _internal_mutable_bg(); + public: + void unsafe_arena_set_allocated_bg( + ::pb::boolGate* bg); + ::pb::boolGate* unsafe_arena_release_bg(); + + // optional .pb.clusterGate cg = 9; + bool has_cg() const; + private: + bool _internal_has_cg() const; + public: + void clear_cg(); + const ::pb::clusterGate& cg() const; + ::pb::clusterGate* release_cg(); + ::pb::clusterGate* mutable_cg(); + void set_allocated_cg(::pb::clusterGate* cg); + private: + const ::pb::clusterGate& _internal_cg() const; + ::pb::clusterGate* _internal_mutable_cg(); + public: + void unsafe_arena_set_allocated_cg( + ::pb::clusterGate* cg); + ::pb::clusterGate* unsafe_arena_release_cg(); + + // required bool neg = 1; + bool has_neg() const; + private: + bool _internal_has_neg() const; + public: + void clear_neg(); + bool neg() const; + void set_neg(bool value); + private: + bool _internal_neg() const; + void _internal_set_neg(bool value); + public: + + // required bool isTransformed = 2; + bool has_istransformed() const; + private: + bool _internal_has_istransformed() const; + public: + void clear_istransformed(); + bool istransformed() const; + void set_istransformed(bool value); + private: + bool _internal_istransformed() const; + void _internal_set_istransformed(bool value); + public: + + // required bool isGained = 3; + bool has_isgained() const; + private: + bool _internal_has_isgained() const; + public: + void clear_isgained(); + bool isgained() const; + void set_isgained(bool value); + private: + bool _internal_isgained() const; + void _internal_set_isgained(bool value); + public: + + // required .pb.GATE_TYPE type = 4; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::pb::GATE_TYPE type() const; + void set_type(::pb::GATE_TYPE value); + private: + ::pb::GATE_TYPE _internal_type() const; + void _internal_set_type(::pb::GATE_TYPE value); + public: + + // @@protoc_insertion_point(class_scope:pb.gate) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::pb::rangeGate* rg_; + ::pb::polygonGate* pg_; + ::pb::ellipseGate* eg_; + ::pb::boolGate* bg_; + ::pb::clusterGate* cg_; + bool neg_; + bool istransformed_; + bool isgained_; + int type_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class POPSTATS PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.POPSTATS) */ { + public: + inline POPSTATS() : POPSTATS(nullptr) {} + virtual ~POPSTATS(); + + POPSTATS(const POPSTATS& from); + POPSTATS(POPSTATS&& from) noexcept + : POPSTATS() { + *this = ::std::move(from); + } + + inline POPSTATS& operator=(const POPSTATS& from) { + CopyFrom(from); + return *this; + } + inline POPSTATS& operator=(POPSTATS&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const POPSTATS& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const POPSTATS* internal_default_instance() { + return reinterpret_cast( + &_POPSTATS_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(POPSTATS& a, POPSTATS& b) { + a.Swap(&b); + } + inline void Swap(POPSTATS* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(POPSTATS* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline POPSTATS* New() const final { + return CreateMaybeMessage(nullptr); + } + + POPSTATS* 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 POPSTATS& from); + void MergeFrom(const POPSTATS& 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(POPSTATS* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.POPSTATS"; + } + protected: + explicit POPSTATS(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStatTypeFieldNumber = 1, + kStatValFieldNumber = 2, + }; + // required string statType = 1; + bool has_stattype() const; + private: + bool _internal_has_stattype() const; + public: + void clear_stattype(); + const std::string& stattype() const; + void set_stattype(const std::string& value); + void set_stattype(std::string&& value); + void set_stattype(const char* value); + void set_stattype(const char* value, size_t size); + std::string* mutable_stattype(); + std::string* release_stattype(); + void set_allocated_stattype(std::string* stattype); + private: + const std::string& _internal_stattype() const; + void _internal_set_stattype(const std::string& value); + std::string* _internal_mutable_stattype(); + public: + + // required float statVal = 2; + bool has_statval() const; + private: + bool _internal_has_statval() const; + public: + void clear_statval(); + float statval() const; + void set_statval(float value); + private: + float _internal_statval() const; + void _internal_set_statval(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.POPSTATS) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stattype_; + float statval_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class calibrationTable PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.calibrationTable) */ { + public: + inline calibrationTable() : calibrationTable(nullptr) {} + virtual ~calibrationTable(); + + calibrationTable(const calibrationTable& from); + calibrationTable(calibrationTable&& from) noexcept + : calibrationTable() { + *this = ::std::move(from); + } + + inline calibrationTable& operator=(const calibrationTable& from) { + CopyFrom(from); + return *this; + } + inline calibrationTable& operator=(calibrationTable&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const calibrationTable& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const calibrationTable* internal_default_instance() { + return reinterpret_cast( + &_calibrationTable_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(calibrationTable& a, calibrationTable& b) { + a.Swap(&b); + } + inline void Swap(calibrationTable* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(calibrationTable* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline calibrationTable* New() const final { + return CreateMaybeMessage(nullptr); + } + + calibrationTable* 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 calibrationTable& from); + void MergeFrom(const calibrationTable& 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(calibrationTable* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.calibrationTable"; + } + protected: + explicit calibrationTable(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + kBFieldNumber = 3, + kCFieldNumber = 4, + kDFieldNumber = 5, + kCaltypeFieldNumber = 7, + kSplineMethodFieldNumber = 6, + kFlagFieldNumber = 8, + }; + // repeated float x = 1 [packed = true]; + int x_size() const; + private: + int _internal_x_size() const; + public: + void clear_x(); + private: + float _internal_x(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_x() const; + void _internal_add_x(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_x(); + public: + float x(int index) const; + void set_x(int index, float value); + void add_x(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + x() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_x(); + + // repeated float y = 2 [packed = true]; + int y_size() const; + private: + int _internal_y_size() const; + public: + void clear_y(); + private: + float _internal_y(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_y() const; + void _internal_add_y(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_y(); + public: + float y(int index) const; + void set_y(int index, float value); + void add_y(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + y() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_y(); + + // repeated float b = 3 [packed = true]; + int b_size() const; + private: + int _internal_b_size() const; + public: + void clear_b(); + private: + float _internal_b(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_b() const; + void _internal_add_b(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_b(); + public: + float b(int index) const; + void set_b(int index, float value); + void add_b(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + b() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_b(); + + // repeated float c = 4 [packed = true]; + int c_size() const; + private: + int _internal_c_size() const; + public: + void clear_c(); + private: + float _internal_c(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_c() const; + void _internal_add_c(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_c(); + public: + float c(int index) const; + void set_c(int index, float value); + void add_c(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + c() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_c(); + + // repeated float d = 5 [packed = true]; + int d_size() const; + private: + int _internal_d_size() const; + public: + void clear_d(); + private: + float _internal_d(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_d() const; + void _internal_add_d(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_d(); + public: + float d(int index) const; + void set_d(int index, float value); + void add_d(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + d() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_d(); + + // optional string caltype = 7; + bool has_caltype() const; + private: + bool _internal_has_caltype() const; + public: + void clear_caltype(); + const std::string& caltype() const; + void set_caltype(const std::string& value); + void set_caltype(std::string&& value); + void set_caltype(const char* value); + void set_caltype(const char* value, size_t size); + std::string* mutable_caltype(); + std::string* release_caltype(); + void set_allocated_caltype(std::string* caltype); + private: + const std::string& _internal_caltype() const; + void _internal_set_caltype(const std::string& value); + std::string* _internal_mutable_caltype(); + public: + + // optional uint32 spline_method = 6; + bool has_spline_method() const; + private: + bool _internal_has_spline_method() const; + public: + void clear_spline_method(); + ::PROTOBUF_NAMESPACE_ID::uint32 spline_method() const; + void set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_spline_method() const; + void _internal_set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional bool flag = 8; + bool has_flag() const; + private: + bool _internal_has_flag() const; + public: + void clear_flag(); + bool flag() const; + void set_flag(bool value); + private: + bool _internal_flag() const; + void _internal_set_flag(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.calibrationTable) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > x_; + mutable std::atomic _x_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > y_; + mutable std::atomic _y_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > b_; + mutable std::atomic _b_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > c_; + mutable std::atomic _c_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > d_; + mutable std::atomic _d_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caltype_; + ::PROTOBUF_NAMESPACE_ID::uint32 spline_method_; + bool flag_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class biexpTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.biexpTrans) */ { + public: + inline biexpTrans() : biexpTrans(nullptr) {} + virtual ~biexpTrans(); + + biexpTrans(const biexpTrans& from); + biexpTrans(biexpTrans&& from) noexcept + : biexpTrans() { + *this = ::std::move(from); + } + + inline biexpTrans& operator=(const biexpTrans& from) { + CopyFrom(from); + return *this; + } + inline biexpTrans& operator=(biexpTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const biexpTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const biexpTrans* internal_default_instance() { + return reinterpret_cast( + &_biexpTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(biexpTrans& a, biexpTrans& b) { + a.Swap(&b); + } + inline void Swap(biexpTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(biexpTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline biexpTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + biexpTrans* 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 biexpTrans& from); + void MergeFrom(const biexpTrans& 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(biexpTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.biexpTrans"; + } + protected: + explicit biexpTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelRangeFieldNumber = 1, + kPosFieldNumber = 2, + kNegFieldNumber = 3, + kWidthBasisFieldNumber = 4, + kMaxValueFieldNumber = 5, + }; + // optional uint32 channelRange = 1; + bool has_channelrange() const; + private: + bool _internal_has_channelrange() const; + public: + void clear_channelrange(); + ::PROTOBUF_NAMESPACE_ID::uint32 channelrange() const; + void set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_channelrange() const; + void _internal_set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional float pos = 2; + bool has_pos() const; + private: + bool _internal_has_pos() const; + public: + void clear_pos(); + float pos() const; + void set_pos(float value); + private: + float _internal_pos() const; + void _internal_set_pos(float value); + public: + + // optional float neg = 3; + bool has_neg() const; + private: + bool _internal_has_neg() const; + public: + void clear_neg(); + float neg() const; + void set_neg(float value); + private: + float _internal_neg() const; + void _internal_set_neg(float value); + public: + + // optional float widthBasis = 4; + bool has_widthbasis() const; + private: + bool _internal_has_widthbasis() const; + public: + void clear_widthbasis(); + float widthbasis() const; + void set_widthbasis(float value); + private: + float _internal_widthbasis() const; + void _internal_set_widthbasis(float value); + public: + + // optional float maxValue = 5; + bool has_maxvalue() const; + private: + bool _internal_has_maxvalue() const; + public: + void clear_maxvalue(); + float maxvalue() const; + void set_maxvalue(float value); + private: + float _internal_maxvalue() const; + void _internal_set_maxvalue(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.biexpTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 channelrange_; + float pos_; + float neg_; + float widthbasis_; + float maxvalue_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class fasinhTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.fasinhTrans) */ { + public: + inline fasinhTrans() : fasinhTrans(nullptr) {} + virtual ~fasinhTrans(); + + fasinhTrans(const fasinhTrans& from); + fasinhTrans(fasinhTrans&& from) noexcept + : fasinhTrans() { + *this = ::std::move(from); + } + + inline fasinhTrans& operator=(const fasinhTrans& from) { + CopyFrom(from); + return *this; + } + inline fasinhTrans& operator=(fasinhTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const fasinhTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const fasinhTrans* internal_default_instance() { + return reinterpret_cast( + &_fasinhTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(fasinhTrans& a, fasinhTrans& b) { + a.Swap(&b); + } + inline void Swap(fasinhTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(fasinhTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline fasinhTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + fasinhTrans* 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 fasinhTrans& from); + void MergeFrom(const fasinhTrans& 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(fasinhTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.fasinhTrans"; + } + protected: + explicit fasinhTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kMaxRangeFieldNumber = 2, + kTFieldNumber = 3, + kAFieldNumber = 4, + kMFieldNumber = 5, + }; + // optional float length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + float length() const; + void set_length(float value); + private: + float _internal_length() const; + void _internal_set_length(float value); + public: + + // optional float maxRange = 2; + bool has_maxrange() const; + private: + bool _internal_has_maxrange() const; + public: + void clear_maxrange(); + float maxrange() const; + void set_maxrange(float value); + private: + float _internal_maxrange() const; + void _internal_set_maxrange(float value); + public: + + // optional float T = 3; + bool has_t() const; + private: + bool _internal_has_t() const; + public: + void clear_t(); + float t() const; + void set_t(float value); + private: + float _internal_t() const; + void _internal_set_t(float value); + public: + + // optional float A = 4; + bool has_a() const; + private: + bool _internal_has_a() const; + public: + void clear_a(); + float a() const; + void set_a(float value); + private: + float _internal_a() const; + void _internal_set_a(float value); + public: + + // optional float M = 5; + bool has_m() const; + private: + bool _internal_has_m() const; + public: + void clear_m(); + float m() const; + void set_m(float value); + private: + float _internal_m() const; + void _internal_set_m(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.fasinhTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float length_; + float maxrange_; + float t_; + float a_; + float m_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class scaleTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.scaleTrans) */ { + public: + inline scaleTrans() : scaleTrans(nullptr) {} + virtual ~scaleTrans(); + + scaleTrans(const scaleTrans& from); + scaleTrans(scaleTrans&& from) noexcept + : scaleTrans() { + *this = ::std::move(from); + } + + inline scaleTrans& operator=(const scaleTrans& from) { + CopyFrom(from); + return *this; + } + inline scaleTrans& operator=(scaleTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const scaleTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const scaleTrans* internal_default_instance() { + return reinterpret_cast( + &_scaleTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(scaleTrans& a, scaleTrans& b) { + a.Swap(&b); + } + inline void Swap(scaleTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(scaleTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline scaleTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + scaleTrans* 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 scaleTrans& from); + void MergeFrom(const scaleTrans& 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(scaleTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.scaleTrans"; + } + protected: + explicit scaleTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kScaleFactorFieldNumber = 1, + kTScaleFieldNumber = 2, + kRScaleFieldNumber = 3, + }; + // optional float scale_factor = 1; + bool has_scale_factor() const; + private: + bool _internal_has_scale_factor() const; + public: + void clear_scale_factor(); + float scale_factor() const; + void set_scale_factor(float value); + private: + float _internal_scale_factor() const; + void _internal_set_scale_factor(float value); + public: + + // optional float t_scale = 2; + bool has_t_scale() const; + private: + bool _internal_has_t_scale() const; + public: + void clear_t_scale(); + float t_scale() const; + void set_t_scale(float value); + private: + float _internal_t_scale() const; + void _internal_set_t_scale(float value); + public: + + // optional float r_scale = 3; + bool has_r_scale() const; + private: + bool _internal_has_r_scale() const; + public: + void clear_r_scale(); + float r_scale() const; + void set_r_scale(float value); + private: + float _internal_r_scale() const; + void _internal_set_r_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.scaleTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float scale_factor_; + float t_scale_; + float r_scale_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class flinTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.flinTrans) */ { + public: + inline flinTrans() : flinTrans(nullptr) {} + virtual ~flinTrans(); + + flinTrans(const flinTrans& from); + flinTrans(flinTrans&& from) noexcept + : flinTrans() { + *this = ::std::move(from); + } + + inline flinTrans& operator=(const flinTrans& from) { + CopyFrom(from); + return *this; + } + inline flinTrans& operator=(flinTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const flinTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const flinTrans* internal_default_instance() { + return reinterpret_cast( + &_flinTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(flinTrans& a, flinTrans& b) { + a.Swap(&b); + } + inline void Swap(flinTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(flinTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline flinTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + flinTrans* 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 flinTrans& from); + void MergeFrom(const flinTrans& 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(flinTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.flinTrans"; + } + protected: + explicit flinTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMinFieldNumber = 1, + kMaxFieldNumber = 2, + }; + // optional float min = 1; + bool has_min() const; + private: + bool _internal_has_min() const; + public: + void clear_min(); + float min() const; + void set_min(float value); + private: + float _internal_min() const; + void _internal_set_min(float value); + public: + + // optional float max = 2; + bool has_max() const; + private: + bool _internal_has_max() const; + public: + void clear_max(); + float max() const; + void set_max(float value); + private: + float _internal_max() const; + void _internal_set_max(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.flinTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float min_; + float max_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class logTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logTrans) */ { + public: + inline logTrans() : logTrans(nullptr) {} + virtual ~logTrans(); + + logTrans(const logTrans& from); + logTrans(logTrans&& from) noexcept + : logTrans() { + *this = ::std::move(from); + } + + inline logTrans& operator=(const logTrans& from) { + CopyFrom(from); + return *this; + } + inline logTrans& operator=(logTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const logTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const logTrans* internal_default_instance() { + return reinterpret_cast( + &_logTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(logTrans& a, logTrans& b) { + a.Swap(&b); + } + inline void Swap(logTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(logTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline logTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + logTrans* 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 logTrans& from); + void MergeFrom(const logTrans& 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(logTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.logTrans"; + } + protected: + explicit logTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOffsetFieldNumber = 1, + kDecadeFieldNumber = 2, + kTFieldNumber = 3, + kScaleFieldNumber = 4, + }; + // optional float offset = 1; + bool has_offset() const; + private: + bool _internal_has_offset() const; + public: + void clear_offset(); + float offset() const; + void set_offset(float value); + private: + float _internal_offset() const; + void _internal_set_offset(float value); + public: + + // optional float decade = 2; + bool has_decade() const; + private: + bool _internal_has_decade() const; + public: + void clear_decade(); + float decade() const; + void set_decade(float value); + private: + float _internal_decade() const; + void _internal_set_decade(float value); + public: + + // optional float T = 3; + bool has_t() const; + private: + bool _internal_has_t() const; + public: + void clear_t(); + float t() const; + void set_t(float value); + private: + float _internal_t() const; + void _internal_set_t(float value); + public: + + // optional float scale = 4; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + float scale() const; + void set_scale(float value); + private: + float _internal_scale() const; + void _internal_set_scale(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.logTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float offset_; + float decade_; + float t_; + float scale_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class logGML2Trans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logGML2Trans) */ { + public: + inline logGML2Trans() : logGML2Trans(nullptr) {} + virtual ~logGML2Trans(); + + logGML2Trans(const logGML2Trans& from); + logGML2Trans(logGML2Trans&& from) noexcept + : logGML2Trans() { + *this = ::std::move(from); + } + + inline logGML2Trans& operator=(const logGML2Trans& from) { + CopyFrom(from); + return *this; + } + inline logGML2Trans& operator=(logGML2Trans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const logGML2Trans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const logGML2Trans* internal_default_instance() { + return reinterpret_cast( + &_logGML2Trans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(logGML2Trans& a, logGML2Trans& b) { + a.Swap(&b); + } + inline void Swap(logGML2Trans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(logGML2Trans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline logGML2Trans* New() const final { + return CreateMaybeMessage(nullptr); + } + + logGML2Trans* 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 logGML2Trans& from); + void MergeFrom(const logGML2Trans& 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(logGML2Trans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.logGML2Trans"; + } + protected: + explicit logGML2Trans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTFieldNumber = 1, + kMFieldNumber = 2, + }; + // optional float T = 1; + bool has_t() const; + private: + bool _internal_has_t() const; + public: + void clear_t(); + float t() const; + void set_t(float value); + private: + float _internal_t() const; + void _internal_set_t(float value); + public: + + // optional float M = 2; + bool has_m() const; + private: + bool _internal_has_m() const; + public: + void clear_m(); + float m() const; + void set_m(float value); + private: + float _internal_m() const; + void _internal_set_m(float value); + public: + + // @@protoc_insertion_point(class_scope:pb.logGML2Trans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float t_; + float m_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class logicleTrans PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.logicleTrans) */ { + public: + inline logicleTrans() : logicleTrans(nullptr) {} + virtual ~logicleTrans(); + + logicleTrans(const logicleTrans& from); + logicleTrans(logicleTrans&& from) noexcept + : logicleTrans() { + *this = ::std::move(from); + } + + inline logicleTrans& operator=(const logicleTrans& from) { + CopyFrom(from); + return *this; + } + inline logicleTrans& operator=(logicleTrans&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const logicleTrans& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const logicleTrans* internal_default_instance() { + return reinterpret_cast( + &_logicleTrans_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(logicleTrans& a, logicleTrans& b) { + a.Swap(&b); + } + inline void Swap(logicleTrans* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(logicleTrans* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline logicleTrans* New() const final { + return CreateMaybeMessage(nullptr); + } + + logicleTrans* 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 logicleTrans& from); + void MergeFrom(const logicleTrans& 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(logicleTrans* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.logicleTrans"; + } + protected: + explicit logicleTrans(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTFieldNumber = 1, + kWFieldNumber = 2, + kMFieldNumber = 3, + kAFieldNumber = 4, + kBinsFieldNumber = 5, + kIsGml2FieldNumber = 6, + kIsInverseFieldNumber = 7, + }; + // optional float T = 1; + bool has_t() const; + private: + bool _internal_has_t() const; + public: + void clear_t(); + float t() const; + void set_t(float value); + private: + float _internal_t() const; + void _internal_set_t(float value); + public: + + // optional float W = 2; + bool has_w() const; + private: + bool _internal_has_w() const; + public: + void clear_w(); + float w() const; + void set_w(float value); + private: + float _internal_w() const; + void _internal_set_w(float value); + public: + + // optional float M = 3; + bool has_m() const; + private: + bool _internal_has_m() const; + public: + void clear_m(); + float m() const; + void set_m(float value); + private: + float _internal_m() const; + void _internal_set_m(float value); + public: + + // optional float A = 4; + bool has_a() const; + private: + bool _internal_has_a() const; + public: + void clear_a(); + float a() const; + void set_a(float value); + private: + float _internal_a() const; + void _internal_set_a(float value); + public: + + // optional float bins = 5; + bool has_bins() const; + private: + bool _internal_has_bins() const; + public: + void clear_bins(); + float bins() const; + void set_bins(float value); + private: + float _internal_bins() const; + void _internal_set_bins(float value); + public: + + // optional bool isGml2 = 6; + bool has_isgml2() const; + private: + bool _internal_has_isgml2() const; + public: + void clear_isgml2(); + bool isgml2() const; + void set_isgml2(bool value); + private: + bool _internal_isgml2() const; + void _internal_set_isgml2(bool value); + public: + + // optional bool isInverse = 7; + bool has_isinverse() const; + private: + bool _internal_has_isinverse() const; + public: + void clear_isinverse(); + bool isinverse() const; + void set_isinverse(bool value); + private: + bool _internal_isinverse() const; + void _internal_set_isinverse(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.logicleTrans) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + float t_; + float w_; + float m_; + float a_; + float bins_; + bool isgml2_; + bool isinverse_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class transformation PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.transformation) */ { + public: + inline transformation() : transformation(nullptr) {} + virtual ~transformation(); + + transformation(const transformation& from); + transformation(transformation&& from) noexcept + : transformation() { + *this = ::std::move(from); + } + + inline transformation& operator=(const transformation& from) { + CopyFrom(from); + return *this; + } + inline transformation& operator=(transformation&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const transformation& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const transformation* internal_default_instance() { + return reinterpret_cast( + &_transformation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(transformation& a, transformation& b) { + a.Swap(&b); + } + inline void Swap(transformation* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(transformation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline transformation* New() const final { + return CreateMaybeMessage(nullptr); + } + + transformation* 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 transformation& from); + void MergeFrom(const transformation& 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(transformation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.transformation"; + } + protected: + explicit transformation(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 4, + kChannelFieldNumber = 5, + kCalTblFieldNumber = 1, + kBtFieldNumber = 7, + kLtFieldNumber = 8, + kFltFieldNumber = 9, + kStFieldNumber = 10, + kFtFieldNumber = 11, + kLgtFieldNumber = 13, + kLgml2TFieldNumber = 14, + kTransTypeFieldNumber = 3, + kIsGateOnlyFieldNumber = 2, + kIsComputedFieldNumber = 6, + kTypeFieldNumber = 12, + }; + // optional string name = 4; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string channel = 5; + bool has_channel() const; + private: + bool _internal_has_channel() const; + public: + void clear_channel(); + const std::string& channel() const; + void set_channel(const std::string& value); + void set_channel(std::string&& value); + void set_channel(const char* value); + void set_channel(const char* value, size_t size); + std::string* mutable_channel(); + std::string* release_channel(); + void set_allocated_channel(std::string* channel); + private: + const std::string& _internal_channel() const; + void _internal_set_channel(const std::string& value); + std::string* _internal_mutable_channel(); + public: + + // optional .pb.calibrationTable calTbl = 1; + bool has_caltbl() const; + private: + bool _internal_has_caltbl() const; + public: + void clear_caltbl(); + const ::pb::calibrationTable& caltbl() const; + ::pb::calibrationTable* release_caltbl(); + ::pb::calibrationTable* mutable_caltbl(); + void set_allocated_caltbl(::pb::calibrationTable* caltbl); + private: + const ::pb::calibrationTable& _internal_caltbl() const; + ::pb::calibrationTable* _internal_mutable_caltbl(); + public: + void unsafe_arena_set_allocated_caltbl( + ::pb::calibrationTable* caltbl); + ::pb::calibrationTable* unsafe_arena_release_caltbl(); + + // optional .pb.biexpTrans bt = 7; + bool has_bt() const; + private: + bool _internal_has_bt() const; + public: + void clear_bt(); + const ::pb::biexpTrans& bt() const; + ::pb::biexpTrans* release_bt(); + ::pb::biexpTrans* mutable_bt(); + void set_allocated_bt(::pb::biexpTrans* bt); + private: + const ::pb::biexpTrans& _internal_bt() const; + ::pb::biexpTrans* _internal_mutable_bt(); + public: + void unsafe_arena_set_allocated_bt( + ::pb::biexpTrans* bt); + ::pb::biexpTrans* unsafe_arena_release_bt(); + + // optional .pb.logTrans lt = 8; + bool has_lt() const; + private: + bool _internal_has_lt() const; + public: + void clear_lt(); + const ::pb::logTrans& lt() const; + ::pb::logTrans* release_lt(); + ::pb::logTrans* mutable_lt(); + void set_allocated_lt(::pb::logTrans* lt); + private: + const ::pb::logTrans& _internal_lt() const; + ::pb::logTrans* _internal_mutable_lt(); + public: + void unsafe_arena_set_allocated_lt( + ::pb::logTrans* lt); + ::pb::logTrans* unsafe_arena_release_lt(); + + // optional .pb.flinTrans flt = 9; + bool has_flt() const; + private: + bool _internal_has_flt() const; + public: + void clear_flt(); + const ::pb::flinTrans& flt() const; + ::pb::flinTrans* release_flt(); + ::pb::flinTrans* mutable_flt(); + void set_allocated_flt(::pb::flinTrans* flt); + private: + const ::pb::flinTrans& _internal_flt() const; + ::pb::flinTrans* _internal_mutable_flt(); + public: + void unsafe_arena_set_allocated_flt( + ::pb::flinTrans* flt); + ::pb::flinTrans* unsafe_arena_release_flt(); + + // optional .pb.scaleTrans st = 10; + bool has_st() const; + private: + bool _internal_has_st() const; + public: + void clear_st(); + const ::pb::scaleTrans& st() const; + ::pb::scaleTrans* release_st(); + ::pb::scaleTrans* mutable_st(); + void set_allocated_st(::pb::scaleTrans* st); + private: + const ::pb::scaleTrans& _internal_st() const; + ::pb::scaleTrans* _internal_mutable_st(); + public: + void unsafe_arena_set_allocated_st( + ::pb::scaleTrans* st); + ::pb::scaleTrans* unsafe_arena_release_st(); + + // optional .pb.fasinhTrans ft = 11; + bool has_ft() const; + private: + bool _internal_has_ft() const; + public: + void clear_ft(); + const ::pb::fasinhTrans& ft() const; + ::pb::fasinhTrans* release_ft(); + ::pb::fasinhTrans* mutable_ft(); + void set_allocated_ft(::pb::fasinhTrans* ft); + private: + const ::pb::fasinhTrans& _internal_ft() const; + ::pb::fasinhTrans* _internal_mutable_ft(); + public: + void unsafe_arena_set_allocated_ft( + ::pb::fasinhTrans* ft); + ::pb::fasinhTrans* unsafe_arena_release_ft(); + + // optional .pb.logicleTrans lgt = 13; + bool has_lgt() const; + private: + bool _internal_has_lgt() const; + public: + void clear_lgt(); + const ::pb::logicleTrans& lgt() const; + ::pb::logicleTrans* release_lgt(); + ::pb::logicleTrans* mutable_lgt(); + void set_allocated_lgt(::pb::logicleTrans* lgt); + private: + const ::pb::logicleTrans& _internal_lgt() const; + ::pb::logicleTrans* _internal_mutable_lgt(); + public: + void unsafe_arena_set_allocated_lgt( + ::pb::logicleTrans* lgt); + ::pb::logicleTrans* unsafe_arena_release_lgt(); + + // optional .pb.logGML2Trans lgml2t = 14; + bool has_lgml2t() const; + private: + bool _internal_has_lgml2t() const; + public: + void clear_lgml2t(); + const ::pb::logGML2Trans& lgml2t() const; + ::pb::logGML2Trans* release_lgml2t(); + ::pb::logGML2Trans* mutable_lgml2t(); + void set_allocated_lgml2t(::pb::logGML2Trans* lgml2t); + private: + const ::pb::logGML2Trans& _internal_lgml2t() const; + ::pb::logGML2Trans* _internal_mutable_lgml2t(); + public: + void unsafe_arena_set_allocated_lgml2t( + ::pb::logGML2Trans* lgml2t); + ::pb::logGML2Trans* unsafe_arena_release_lgml2t(); + + // optional .pb.TRANS_TYPE trans_type = 3; + bool has_trans_type() const; + private: + bool _internal_has_trans_type() const; + public: + void clear_trans_type(); + ::pb::TRANS_TYPE trans_type() const; + void set_trans_type(::pb::TRANS_TYPE value); + private: + ::pb::TRANS_TYPE _internal_trans_type() const; + void _internal_set_trans_type(::pb::TRANS_TYPE value); + public: + + // optional bool isGateOnly = 2; + bool has_isgateonly() const; + private: + bool _internal_has_isgateonly() const; + public: + void clear_isgateonly(); + bool isgateonly() const; + void set_isgateonly(bool value); + private: + bool _internal_isgateonly() const; + void _internal_set_isgateonly(bool value); + public: + + // optional bool isComputed = 6; + bool has_iscomputed() const; + private: + bool _internal_has_iscomputed() const; + public: + void clear_iscomputed(); + bool iscomputed() const; + void set_iscomputed(bool value); + private: + bool _internal_iscomputed() const; + void _internal_set_iscomputed(bool value); + public: + + // optional uint32 type = 12; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::PROTOBUF_NAMESPACE_ID::uint32 type() const; + void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type() const; + void _internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:pb.transformation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr channel_; + ::pb::calibrationTable* caltbl_; + ::pb::biexpTrans* bt_; + ::pb::logTrans* lt_; + ::pb::flinTrans* flt_; + ::pb::scaleTrans* st_; + ::pb::fasinhTrans* ft_; + ::pb::logicleTrans* lgt_; + ::pb::logGML2Trans* lgml2t_; + int trans_type_; + bool isgateonly_; + bool iscomputed_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class trans_pair PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.trans_pair) */ { + public: + inline trans_pair() : trans_pair(nullptr) {} + virtual ~trans_pair(); + + trans_pair(const trans_pair& from); + trans_pair(trans_pair&& from) noexcept + : trans_pair() { + *this = ::std::move(from); + } + + inline trans_pair& operator=(const trans_pair& from) { + CopyFrom(from); + return *this; + } + inline trans_pair& operator=(trans_pair&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const trans_pair& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const trans_pair* internal_default_instance() { + return reinterpret_cast( + &_trans_pair_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(trans_pair& a, trans_pair& b) { + a.Swap(&b); + } + inline void Swap(trans_pair* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(trans_pair* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline trans_pair* New() const final { + return CreateMaybeMessage(nullptr); + } + + trans_pair* 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 trans_pair& from); + void MergeFrom(const trans_pair& 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(trans_pair* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.trans_pair"; + } + protected: + explicit trans_pair(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kTransFieldNumber = 3, + kTransAddressFieldNumber = 2, + }; + // required string name = 1; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional .pb.transformation trans = 3; + bool has_trans() const; + private: + bool _internal_has_trans() const; + public: + void clear_trans(); + const ::pb::transformation& trans() const; + ::pb::transformation* release_trans(); + ::pb::transformation* mutable_trans(); + void set_allocated_trans(::pb::transformation* trans); + private: + const ::pb::transformation& _internal_trans() const; + ::pb::transformation* _internal_mutable_trans(); + public: + void unsafe_arena_set_allocated_trans( + ::pb::transformation* trans); + ::pb::transformation* unsafe_arena_release_trans(); + + // optional uint64 trans_address = 2; + bool has_trans_address() const; + private: + bool _internal_has_trans_address() const; + public: + void clear_trans_address(); + ::PROTOBUF_NAMESPACE_ID::uint64 trans_address() const; + void set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_trans_address() const; + void _internal_set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:pb.trans_pair) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::pb::transformation* trans_; + ::PROTOBUF_NAMESPACE_ID::uint64 trans_address_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class trans_local PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.trans_local) */ { + public: + inline trans_local() : trans_local(nullptr) {} + virtual ~trans_local(); + + trans_local(const trans_local& from); + trans_local(trans_local&& from) noexcept + : trans_local() { + *this = ::std::move(from); + } + + inline trans_local& operator=(const trans_local& from) { + CopyFrom(from); + return *this; + } + inline trans_local& operator=(trans_local&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const trans_local& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const trans_local* internal_default_instance() { + return reinterpret_cast( + &_trans_local_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(trans_local& a, trans_local& b) { + a.Swap(&b); + } + inline void Swap(trans_local* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(trans_local* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline trans_local* New() const final { + return CreateMaybeMessage(nullptr); + } + + trans_local* 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 trans_local& from); + void MergeFrom(const trans_local& 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(trans_local* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.trans_local"; + } + protected: + explicit trans_local(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTpFieldNumber = 1, + kSampleIDsFieldNumber = 3, + kGroupNameFieldNumber = 2, + }; + // repeated .pb.trans_pair tp = 1; + int tp_size() const; + private: + int _internal_tp_size() const; + public: + void clear_tp(); + ::pb::trans_pair* mutable_tp(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >* + mutable_tp(); + private: + const ::pb::trans_pair& _internal_tp(int index) const; + ::pb::trans_pair* _internal_add_tp(); + public: + const ::pb::trans_pair& tp(int index) const; + ::pb::trans_pair* add_tp(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >& + tp() const; + + // repeated uint32 sampleIDs = 3 [packed = true]; + int sampleids_size() const; + private: + int _internal_sampleids_size() const; + public: + void clear_sampleids(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_sampleids(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_sampleids() const; + void _internal_add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_sampleids(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 sampleids(int index) const; + void set_sampleids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + sampleids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_sampleids(); + + // optional string groupName = 2; + bool has_groupname() const; + private: + bool _internal_has_groupname() const; + public: + void clear_groupname(); + const std::string& groupname() const; + void set_groupname(const std::string& value); + void set_groupname(std::string&& value); + void set_groupname(const char* value); + void set_groupname(const char* value, size_t size); + std::string* mutable_groupname(); + std::string* release_groupname(); + void set_allocated_groupname(std::string* groupname); + private: + const std::string& _internal_groupname() const; + void _internal_set_groupname(const std::string& value); + std::string* _internal_mutable_groupname(); + public: + + // @@protoc_insertion_point(class_scope:pb.trans_local) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair > tp_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > sampleids_; + mutable std::atomic _sampleids_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class POPINDICES PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.POPINDICES) */ { + public: + inline POPINDICES() : POPINDICES(nullptr) {} + virtual ~POPINDICES(); + + POPINDICES(const POPINDICES& from); + POPINDICES(POPINDICES&& from) noexcept + : POPINDICES() { + *this = ::std::move(from); + } + + inline POPINDICES& operator=(const POPINDICES& from) { + CopyFrom(from); + return *this; + } + inline POPINDICES& operator=(POPINDICES&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const POPINDICES& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const POPINDICES* internal_default_instance() { + return reinterpret_cast( + &_POPINDICES_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(POPINDICES& a, POPINDICES& b) { + a.Swap(&b); + } + inline void Swap(POPINDICES* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(POPINDICES* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline POPINDICES* New() const final { + return CreateMaybeMessage(nullptr); + } + + POPINDICES* 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 POPINDICES& from); + void MergeFrom(const POPINDICES& 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(POPINDICES* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.POPINDICES"; + } + protected: + explicit POPINDICES(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIIndFieldNumber = 3, + kBIndFieldNumber = 4, + kNEventsFieldNumber = 1, + kIndtypeFieldNumber = 2, + }; + // repeated uint32 iInd = 3 [packed = true]; + int iind_size() const; + private: + int _internal_iind_size() const; + public: + void clear_iind(); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_iind(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_iind() const; + void _internal_add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_iind(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 iind(int index) const; + void set_iind(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + iind() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + mutable_iind(); + + // optional bytes bInd = 4; + bool has_bind() const; + private: + bool _internal_has_bind() const; + public: + void clear_bind(); + const std::string& bind() const; + void set_bind(const std::string& value); + void set_bind(std::string&& value); + void set_bind(const char* value); + void set_bind(const void* value, size_t size); + std::string* mutable_bind(); + std::string* release_bind(); + void set_allocated_bind(std::string* bind); + private: + const std::string& _internal_bind() const; + void _internal_set_bind(const std::string& value); + std::string* _internal_mutable_bind(); + public: + + // required uint32 nEvents = 1; + bool has_nevents() const; + private: + bool _internal_has_nevents() const; + public: + void clear_nevents(); + ::PROTOBUF_NAMESPACE_ID::uint32 nevents() const; + void set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_nevents() const; + void _internal_set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // required .pb.ind_type indtype = 2; + bool has_indtype() const; + private: + bool _internal_has_indtype() const; + public: + void clear_indtype(); + ::pb::ind_type indtype() const; + void set_indtype(::pb::ind_type value); + private: + ::pb::ind_type _internal_indtype() const; + void _internal_set_indtype(::pb::ind_type value); + public: + + // @@protoc_insertion_point(class_scope:pb.POPINDICES) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > iind_; + mutable std::atomic _iind_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bind_; + ::PROTOBUF_NAMESPACE_ID::uint32 nevents_; + int indtype_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class nodeProperties PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.nodeProperties) */ { + public: + inline nodeProperties() : nodeProperties(nullptr) {} + virtual ~nodeProperties(); + + nodeProperties(const nodeProperties& from); + nodeProperties(nodeProperties&& from) noexcept + : nodeProperties() { + *this = ::std::move(from); + } + + inline nodeProperties& operator=(const nodeProperties& from) { + CopyFrom(from); + return *this; + } + inline nodeProperties& operator=(nodeProperties&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const nodeProperties& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const nodeProperties* internal_default_instance() { + return reinterpret_cast( + &_nodeProperties_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(nodeProperties& a, nodeProperties& b) { + a.Swap(&b); + } + inline void Swap(nodeProperties* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(nodeProperties* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline nodeProperties* New() const final { + return CreateMaybeMessage(nullptr); + } + + nodeProperties* 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 nodeProperties& from); + void MergeFrom(const nodeProperties& 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(nodeProperties* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.nodeProperties"; + } + protected: + explicit nodeProperties(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFjStatsFieldNumber = 2, + kFcStatsFieldNumber = 3, + kThisNameFieldNumber = 1, + kIndicesFieldNumber = 5, + kThisGateFieldNumber = 6, + kHiddenFieldNumber = 4, + }; + // repeated .pb.POPSTATS fjStats = 2; + int fjstats_size() const; + private: + int _internal_fjstats_size() const; + public: + void clear_fjstats(); + ::pb::POPSTATS* mutable_fjstats(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >* + mutable_fjstats(); + private: + const ::pb::POPSTATS& _internal_fjstats(int index) const; + ::pb::POPSTATS* _internal_add_fjstats(); + public: + const ::pb::POPSTATS& fjstats(int index) const; + ::pb::POPSTATS* add_fjstats(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >& + fjstats() const; + + // repeated .pb.POPSTATS fcStats = 3; + int fcstats_size() const; + private: + int _internal_fcstats_size() const; + public: + void clear_fcstats(); + ::pb::POPSTATS* mutable_fcstats(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >* + mutable_fcstats(); + private: + const ::pb::POPSTATS& _internal_fcstats(int index) const; + ::pb::POPSTATS* _internal_add_fcstats(); + public: + const ::pb::POPSTATS& fcstats(int index) const; + ::pb::POPSTATS* add_fcstats(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >& + fcstats() const; + + // required string thisName = 1; + bool has_thisname() const; + private: + bool _internal_has_thisname() const; + public: + void clear_thisname(); + const std::string& thisname() const; + void set_thisname(const std::string& value); + void set_thisname(std::string&& value); + void set_thisname(const char* value); + void set_thisname(const char* value, size_t size); + std::string* mutable_thisname(); + std::string* release_thisname(); + void set_allocated_thisname(std::string* thisname); + private: + const std::string& _internal_thisname() const; + void _internal_set_thisname(const std::string& value); + std::string* _internal_mutable_thisname(); + public: + + // optional .pb.POPINDICES indices = 5; + bool has_indices() const; + private: + bool _internal_has_indices() const; + public: + void clear_indices(); + const ::pb::POPINDICES& indices() const; + ::pb::POPINDICES* release_indices(); + ::pb::POPINDICES* mutable_indices(); + void set_allocated_indices(::pb::POPINDICES* indices); + private: + const ::pb::POPINDICES& _internal_indices() const; + ::pb::POPINDICES* _internal_mutable_indices(); + public: + void unsafe_arena_set_allocated_indices( + ::pb::POPINDICES* indices); + ::pb::POPINDICES* unsafe_arena_release_indices(); + + // optional .pb.gate thisGate = 6; + bool has_thisgate() const; + private: + bool _internal_has_thisgate() const; + public: + void clear_thisgate(); + const ::pb::gate& thisgate() const; + ::pb::gate* release_thisgate(); + ::pb::gate* mutable_thisgate(); + void set_allocated_thisgate(::pb::gate* thisgate); + private: + const ::pb::gate& _internal_thisgate() const; + ::pb::gate* _internal_mutable_thisgate(); + public: + void unsafe_arena_set_allocated_thisgate( + ::pb::gate* thisgate); + ::pb::gate* unsafe_arena_release_thisgate(); + + // required bool hidden = 4; + bool has_hidden() const; + private: + bool _internal_has_hidden() const; + public: + void clear_hidden(); + bool hidden() const; + void set_hidden(bool value); + private: + bool _internal_hidden() const; + void _internal_set_hidden(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.nodeProperties) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS > fjstats_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS > fcstats_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thisname_; + ::pb::POPINDICES* indices_; + ::pb::gate* thisgate_; + bool hidden_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class treeNodes PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.treeNodes) */ { + public: + inline treeNodes() : treeNodes(nullptr) {} + virtual ~treeNodes(); + + treeNodes(const treeNodes& from); + treeNodes(treeNodes&& from) noexcept + : treeNodes() { + *this = ::std::move(from); + } + + inline treeNodes& operator=(const treeNodes& from) { + CopyFrom(from); + return *this; + } + inline treeNodes& operator=(treeNodes&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const treeNodes& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const treeNodes* internal_default_instance() { + return reinterpret_cast( + &_treeNodes_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(treeNodes& a, treeNodes& b) { + a.Swap(&b); + } + inline void Swap(treeNodes* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(treeNodes* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline treeNodes* New() const final { + return CreateMaybeMessage(nullptr); + } + + treeNodes* 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 treeNodes& from); + void MergeFrom(const treeNodes& 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(treeNodes* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.treeNodes"; + } + protected: + explicit treeNodes(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNodeFieldNumber = 1, + kParentFieldNumber = 2, + }; + // required .pb.nodeProperties node = 1; + bool has_node() const; + private: + bool _internal_has_node() const; + public: + void clear_node(); + const ::pb::nodeProperties& node() const; + ::pb::nodeProperties* release_node(); + ::pb::nodeProperties* mutable_node(); + void set_allocated_node(::pb::nodeProperties* node); + private: + const ::pb::nodeProperties& _internal_node() const; + ::pb::nodeProperties* _internal_mutable_node(); + public: + void unsafe_arena_set_allocated_node( + ::pb::nodeProperties* node); + ::pb::nodeProperties* unsafe_arena_release_node(); + + // optional uint32 parent = 2; + bool has_parent() const; + private: + bool _internal_has_parent() const; + public: + void clear_parent(); + ::PROTOBUF_NAMESPACE_ID::uint32 parent() const; + void set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_parent() const; + void _internal_set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:pb.treeNodes) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::pb::nodeProperties* node_; + ::PROTOBUF_NAMESPACE_ID::uint32 parent_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class populationTree PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.populationTree) */ { + public: + inline populationTree() : populationTree(nullptr) {} + virtual ~populationTree(); + + populationTree(const populationTree& from); + populationTree(populationTree&& from) noexcept + : populationTree() { + *this = ::std::move(from); + } + + inline populationTree& operator=(const populationTree& from) { + CopyFrom(from); + return *this; + } + inline populationTree& operator=(populationTree&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const populationTree& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const populationTree* internal_default_instance() { + return reinterpret_cast( + &_populationTree_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(populationTree& a, populationTree& b) { + a.Swap(&b); + } + inline void Swap(populationTree* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(populationTree* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline populationTree* New() const final { + return CreateMaybeMessage(nullptr); + } + + populationTree* 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 populationTree& from); + void MergeFrom(const populationTree& 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(populationTree* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.populationTree"; + } + protected: + explicit populationTree(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNodeFieldNumber = 1, + }; + // repeated .pb.treeNodes node = 1; + int node_size() const; + private: + int _internal_node_size() const; + public: + void clear_node(); + ::pb::treeNodes* mutable_node(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >* + mutable_node(); + private: + const ::pb::treeNodes& _internal_node(int index) const; + ::pb::treeNodes* _internal_add_node(); + public: + const ::pb::treeNodes& node(int index) const; + ::pb::treeNodes* add_node(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >& + node() const; + + // @@protoc_insertion_point(class_scope:pb.populationTree) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes > node_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class COMP PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.COMP) */ { + public: + inline COMP() : COMP(nullptr) {} + virtual ~COMP(); + + COMP(const COMP& from); + COMP(COMP&& from) noexcept + : COMP() { + *this = ::std::move(from); + } + + inline COMP& operator=(const COMP& from) { + CopyFrom(from); + return *this; + } + inline COMP& operator=(COMP&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const COMP& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const COMP* internal_default_instance() { + return reinterpret_cast( + &_COMP_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(COMP& a, COMP& b) { + a.Swap(&b); + } + inline void Swap(COMP* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(COMP* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline COMP* New() const final { + return CreateMaybeMessage(nullptr); + } + + COMP* 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 COMP& from); + void MergeFrom(const COMP& 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(COMP* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.COMP"; + } + protected: + explicit COMP(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMarkerFieldNumber = 6, + kSpillOverFieldNumber = 7, + kCidFieldNumber = 1, + kPrefixFieldNumber = 2, + kSuffixFieldNumber = 3, + kNameFieldNumber = 4, + kCommentFieldNumber = 5, + }; + // repeated string marker = 6; + int marker_size() const; + private: + int _internal_marker_size() const; + public: + void clear_marker(); + const std::string& marker(int index) const; + std::string* mutable_marker(int index); + void set_marker(int index, const std::string& value); + void set_marker(int index, std::string&& value); + void set_marker(int index, const char* value); + void set_marker(int index, const char* value, size_t size); + std::string* add_marker(); + void add_marker(const std::string& value); + void add_marker(std::string&& value); + void add_marker(const char* value); + void add_marker(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& marker() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_marker(); + private: + const std::string& _internal_marker(int index) const; + std::string* _internal_add_marker(); + public: + + // repeated float spillOver = 7; + int spillover_size() const; + private: + int _internal_spillover_size() const; + public: + void clear_spillover(); + private: + float _internal_spillover(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + _internal_spillover() const; + void _internal_add_spillover(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + _internal_mutable_spillover(); + public: + float spillover(int index) const; + void set_spillover(int index, float value); + void add_spillover(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + spillover() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_spillover(); + + // optional string cid = 1; + bool has_cid() const; + private: + bool _internal_has_cid() const; + public: + void clear_cid(); + const std::string& cid() const; + void set_cid(const std::string& value); + void set_cid(std::string&& value); + void set_cid(const char* value); + void set_cid(const char* value, size_t size); + std::string* mutable_cid(); + std::string* release_cid(); + void set_allocated_cid(std::string* cid); + private: + const std::string& _internal_cid() const; + void _internal_set_cid(const std::string& value); + std::string* _internal_mutable_cid(); + public: + + // optional string prefix = 2; + bool has_prefix() const; + private: + bool _internal_has_prefix() const; + public: + void clear_prefix(); + const std::string& prefix() const; + void set_prefix(const std::string& value); + void set_prefix(std::string&& value); + void set_prefix(const char* value); + void set_prefix(const char* value, size_t size); + std::string* mutable_prefix(); + std::string* release_prefix(); + void set_allocated_prefix(std::string* prefix); + private: + const std::string& _internal_prefix() const; + void _internal_set_prefix(const std::string& value); + std::string* _internal_mutable_prefix(); + public: + + // optional string suffix = 3; + bool has_suffix() const; + private: + bool _internal_has_suffix() const; + public: + void clear_suffix(); + const std::string& suffix() const; + void set_suffix(const std::string& value); + void set_suffix(std::string&& value); + void set_suffix(const char* value); + void set_suffix(const char* value, size_t size); + std::string* mutable_suffix(); + std::string* release_suffix(); + void set_allocated_suffix(std::string* suffix); + private: + const std::string& _internal_suffix() const; + void _internal_set_suffix(const std::string& value); + std::string* _internal_mutable_suffix(); + public: + + // optional string name = 4; + bool has_name() const; + private: + bool _internal_has_name() const; + public: + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // optional string comment = 5; + bool has_comment() const; + private: + bool _internal_has_comment() const; + public: + void clear_comment(); + const std::string& comment() const; + void set_comment(const std::string& value); + void set_comment(std::string&& value); + void set_comment(const char* value); + void set_comment(const char* value, size_t size); + std::string* mutable_comment(); + std::string* release_comment(); + void set_allocated_comment(std::string* comment); + private: + const std::string& _internal_comment() const; + void _internal_set_comment(const std::string& value); + std::string* _internal_mutable_comment(); + public: + + // @@protoc_insertion_point(class_scope:pb.COMP) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField marker_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > spillover_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr suffix_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class PARAM PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.PARAM) */ { + public: + inline PARAM() : PARAM(nullptr) {} + virtual ~PARAM(); + + PARAM(const PARAM& from); + PARAM(PARAM&& from) noexcept + : PARAM() { + *this = ::std::move(from); + } + + inline PARAM& operator=(const PARAM& from) { + CopyFrom(from); + return *this; + } + inline PARAM& operator=(PARAM&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PARAM& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PARAM* internal_default_instance() { + return reinterpret_cast( + &_PARAM_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(PARAM& a, PARAM& b) { + a.Swap(&b); + } + inline void Swap(PARAM* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PARAM* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PARAM* New() const final { + return CreateMaybeMessage(nullptr); + } + + PARAM* 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 PARAM& from); + void MergeFrom(const PARAM& 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(PARAM* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.PARAM"; + } + protected: + explicit PARAM(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kParamFieldNumber = 1, + kLogFieldNumber = 2, + kRangeFieldNumber = 3, + kHighValueFieldNumber = 4, + kCalibrationIndexFieldNumber = 5, + }; + // optional string param = 1; + bool has_param() const; + private: + bool _internal_has_param() const; + public: + void clear_param(); + const std::string& param() const; + void set_param(const std::string& value); + void set_param(std::string&& value); + void set_param(const char* value); + void set_param(const char* value, size_t size); + std::string* mutable_param(); + std::string* release_param(); + void set_allocated_param(std::string* param); + private: + const std::string& _internal_param() const; + void _internal_set_param(const std::string& value); + std::string* _internal_mutable_param(); + public: + + // optional bool log = 2; + bool has_log() const; + private: + bool _internal_has_log() const; + public: + void clear_log(); + bool log() const; + void set_log(bool value); + private: + bool _internal_log() const; + void _internal_set_log(bool value); + public: + + // optional uint32 range = 3; + bool has_range() const; + private: + bool _internal_has_range() const; + public: + void clear_range(); + ::PROTOBUF_NAMESPACE_ID::uint32 range() const; + void set_range(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_range() const; + void _internal_set_range(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 highValue = 4; + bool has_highvalue() const; + private: + bool _internal_has_highvalue() const; + public: + void clear_highvalue(); + ::PROTOBUF_NAMESPACE_ID::uint32 highvalue() const; + void set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_highvalue() const; + void _internal_set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional uint32 calibrationIndex = 5; + bool has_calibrationindex() const; + private: + bool _internal_has_calibrationindex() const; + public: + void clear_calibrationindex(); + ::PROTOBUF_NAMESPACE_ID::uint32 calibrationindex() const; + void set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_calibrationindex() const; + void _internal_set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:pb.PARAM) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_; + bool log_; + ::PROTOBUF_NAMESPACE_ID::uint32 range_; + ::PROTOBUF_NAMESPACE_ID::uint32 highvalue_; + ::PROTOBUF_NAMESPACE_ID::uint32 calibrationindex_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class GatingHierarchy PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.GatingHierarchy) */ { + public: + inline GatingHierarchy() : GatingHierarchy(nullptr) {} + virtual ~GatingHierarchy(); + + GatingHierarchy(const GatingHierarchy& from); + GatingHierarchy(GatingHierarchy&& from) noexcept + : GatingHierarchy() { + *this = ::std::move(from); + } + + inline GatingHierarchy& operator=(const GatingHierarchy& from) { + CopyFrom(from); + return *this; + } + inline GatingHierarchy& operator=(GatingHierarchy&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const GatingHierarchy& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GatingHierarchy* internal_default_instance() { + return reinterpret_cast( + &_GatingHierarchy_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(GatingHierarchy& a, GatingHierarchy& b) { + a.Swap(&b); + } + inline void Swap(GatingHierarchy* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GatingHierarchy* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GatingHierarchy* New() const final { + return CreateMaybeMessage(nullptr); + } + + GatingHierarchy* 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 GatingHierarchy& from); + void MergeFrom(const GatingHierarchy& 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(GatingHierarchy* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.GatingHierarchy"; + } + protected: + explicit GatingHierarchy(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTransFlagFieldNumber = 4, + kCompFieldNumber = 1, + kTreeFieldNumber = 2, + kTransFieldNumber = 5, + kFrameFieldNumber = 6, + kIsLoadedFieldNumber = 3, + }; + // repeated .pb.PARAM transFlag = 4; + int transflag_size() const; + private: + int _internal_transflag_size() const; + public: + void clear_transflag(); + ::pb::PARAM* mutable_transflag(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >* + mutable_transflag(); + private: + const ::pb::PARAM& _internal_transflag(int index) const; + ::pb::PARAM* _internal_add_transflag(); + public: + const ::pb::PARAM& transflag(int index) const; + ::pb::PARAM* add_transflag(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >& + transflag() const; + + // optional .pb.COMP comp = 1; + bool has_comp() const; + private: + bool _internal_has_comp() const; + public: + void clear_comp(); + const ::pb::COMP& comp() const; + ::pb::COMP* release_comp(); + ::pb::COMP* mutable_comp(); + void set_allocated_comp(::pb::COMP* comp); + private: + const ::pb::COMP& _internal_comp() const; + ::pb::COMP* _internal_mutable_comp(); + public: + void unsafe_arena_set_allocated_comp( + ::pb::COMP* comp); + ::pb::COMP* unsafe_arena_release_comp(); + + // required .pb.populationTree tree = 2; + bool has_tree() const; + private: + bool _internal_has_tree() const; + public: + void clear_tree(); + const ::pb::populationTree& tree() const; + ::pb::populationTree* release_tree(); + ::pb::populationTree* mutable_tree(); + void set_allocated_tree(::pb::populationTree* tree); + private: + const ::pb::populationTree& _internal_tree() const; + ::pb::populationTree* _internal_mutable_tree(); + public: + void unsafe_arena_set_allocated_tree( + ::pb::populationTree* tree); + ::pb::populationTree* unsafe_arena_release_tree(); + + // optional .pb.trans_local trans = 5; + bool has_trans() const; + private: + bool _internal_has_trans() const; + public: + void clear_trans(); + const ::pb::trans_local& trans() const; + ::pb::trans_local* release_trans(); + ::pb::trans_local* mutable_trans(); + void set_allocated_trans(::pb::trans_local* trans); + private: + const ::pb::trans_local& _internal_trans() const; + ::pb::trans_local* _internal_mutable_trans(); + public: + void unsafe_arena_set_allocated_trans( + ::pb::trans_local* trans); + ::pb::trans_local* unsafe_arena_release_trans(); + + // optional .pb.CytoFrame frame = 6; + bool has_frame() const; + private: + bool _internal_has_frame() const; + public: + void clear_frame(); + const ::pb::CytoFrame& frame() const; + ::pb::CytoFrame* release_frame(); + ::pb::CytoFrame* mutable_frame(); + void set_allocated_frame(::pb::CytoFrame* frame); + private: + const ::pb::CytoFrame& _internal_frame() const; + ::pb::CytoFrame* _internal_mutable_frame(); + public: + void unsafe_arena_set_allocated_frame( + ::pb::CytoFrame* frame); + ::pb::CytoFrame* unsafe_arena_release_frame(); + + // optional bool isLoaded = 3; + bool has_isloaded() const; + private: + bool _internal_has_isloaded() const; + public: + void clear_isloaded(); + bool isloaded() const; + void set_isloaded(bool value); + private: + bool _internal_isloaded() const; + void _internal_set_isloaded(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.GatingHierarchy) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM > transflag_; + ::pb::COMP* comp_; + ::pb::populationTree* tree_; + ::pb::trans_local* trans_; + ::pb::CytoFrame* frame_; + bool isloaded_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class CytoFrame PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.CytoFrame) */ { + public: + inline CytoFrame() : CytoFrame(nullptr) {} + virtual ~CytoFrame(); + + CytoFrame(const CytoFrame& from); + CytoFrame(CytoFrame&& from) noexcept + : CytoFrame() { + *this = ::std::move(from); + } + + inline CytoFrame& operator=(const CytoFrame& from) { + CopyFrom(from); + return *this; + } + inline CytoFrame& operator=(CytoFrame&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const CytoFrame& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CytoFrame* internal_default_instance() { + return reinterpret_cast( + &_CytoFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(CytoFrame& a, CytoFrame& b) { + a.Swap(&b); + } + inline void Swap(CytoFrame* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CytoFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CytoFrame* New() const final { + return CreateMaybeMessage(nullptr); + } + + CytoFrame* 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 CytoFrame& from); + void MergeFrom(const CytoFrame& 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(CytoFrame* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.CytoFrame"; + } + protected: + explicit CytoFrame(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIsH5FieldNumber = 1, + }; + // required bool is_h5 = 1; + bool has_is_h5() const; + private: + bool _internal_has_is_h5() const; + public: + void clear_is_h5(); + bool is_h5() const; + void set_is_h5(bool value); + private: + bool _internal_is_h5() const; + void _internal_set_is_h5(bool value); + public: + + // @@protoc_insertion_point(class_scope:pb.CytoFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool is_h5_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class TRANS_TBL PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.TRANS_TBL) */ { + public: + inline TRANS_TBL() : TRANS_TBL(nullptr) {} + virtual ~TRANS_TBL(); + + TRANS_TBL(const TRANS_TBL& from); + TRANS_TBL(TRANS_TBL&& from) noexcept + : TRANS_TBL() { + *this = ::std::move(from); + } + + inline TRANS_TBL& operator=(const TRANS_TBL& from) { + CopyFrom(from); + return *this; + } + inline TRANS_TBL& operator=(TRANS_TBL&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const TRANS_TBL& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TRANS_TBL* internal_default_instance() { + return reinterpret_cast( + &_TRANS_TBL_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(TRANS_TBL& a, TRANS_TBL& b) { + a.Swap(&b); + } + inline void Swap(TRANS_TBL* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TRANS_TBL* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TRANS_TBL* New() const final { + return CreateMaybeMessage(nullptr); + } + + TRANS_TBL* 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 TRANS_TBL& from); + void MergeFrom(const TRANS_TBL& 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(TRANS_TBL* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.TRANS_TBL"; + } + protected: + explicit TRANS_TBL(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTransFieldNumber = 2, + kTransAddressFieldNumber = 1, + }; + // optional .pb.transformation trans = 2; + bool has_trans() const; + private: + bool _internal_has_trans() const; + public: + void clear_trans(); + const ::pb::transformation& trans() const; + ::pb::transformation* release_trans(); + ::pb::transformation* mutable_trans(); + void set_allocated_trans(::pb::transformation* trans); + private: + const ::pb::transformation& _internal_trans() const; + ::pb::transformation* _internal_mutable_trans(); + public: + void unsafe_arena_set_allocated_trans( + ::pb::transformation* trans); + ::pb::transformation* unsafe_arena_release_trans(); + + // optional uint64 trans_address = 1; + bool has_trans_address() const; + private: + bool _internal_has_trans_address() const; + public: + void clear_trans_address(); + ::PROTOBUF_NAMESPACE_ID::uint64 trans_address() const; + void set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_trans_address() const; + void _internal_set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:pb.TRANS_TBL) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::pb::transformation* trans_; + ::PROTOBUF_NAMESPACE_ID::uint64 trans_address_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// ------------------------------------------------------------------- + +class GatingSet PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.GatingSet) */ { + public: + inline GatingSet() : GatingSet(nullptr) {} + virtual ~GatingSet(); + + GatingSet(const GatingSet& from); + GatingSet(GatingSet&& from) noexcept + : GatingSet() { + *this = ::std::move(from); + } + + inline GatingSet& operator=(const GatingSet& from) { + CopyFrom(from); + return *this; + } + inline GatingSet& operator=(GatingSet&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { + return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); + } + inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const GatingSet& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GatingSet* internal_default_instance() { + return reinterpret_cast( + &_GatingSet_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(GatingSet& a, GatingSet& b) { + a.Swap(&b); + } + inline void Swap(GatingSet* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GatingSet* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GatingSet* New() const final { + return CreateMaybeMessage(nullptr); + } + + GatingSet* 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 GatingSet& from); + void MergeFrom(const GatingSet& 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(GatingSet* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "pb.GatingSet"; + } + protected: + explicit GatingSet(::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; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_GatingSet_2eproto); + return ::descriptor_table_GatingSet_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSampleNameFieldNumber = 1, + kTransTblFieldNumber = 2, + kGTransFieldNumber = 5, + kGuidFieldNumber = 6, + kCytolibVerionFieldNumber = 7, + kPbVerionFieldNumber = 8, + kH5VerionFieldNumber = 9, + kGlobalBiExpTransFieldNumber = 3, + kGlobalLinTransFieldNumber = 4, + }; + // repeated string sampleName = 1; + int samplename_size() const; + private: + int _internal_samplename_size() const; + public: + void clear_samplename(); + const std::string& samplename(int index) const; + std::string* mutable_samplename(int index); + void set_samplename(int index, const std::string& value); + void set_samplename(int index, std::string&& value); + void set_samplename(int index, const char* value); + void set_samplename(int index, const char* value, size_t size); + std::string* add_samplename(); + void add_samplename(const std::string& value); + void add_samplename(std::string&& value); + void add_samplename(const char* value); + void add_samplename(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& samplename() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_samplename(); + private: + const std::string& _internal_samplename(int index) const; + std::string* _internal_add_samplename(); + public: + + // repeated .pb.TRANS_TBL trans_tbl = 2; + int trans_tbl_size() const; + private: + int _internal_trans_tbl_size() const; + public: + void clear_trans_tbl(); + ::pb::TRANS_TBL* mutable_trans_tbl(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >* + mutable_trans_tbl(); + private: + const ::pb::TRANS_TBL& _internal_trans_tbl(int index) const; + ::pb::TRANS_TBL* _internal_add_trans_tbl(); + public: + const ::pb::TRANS_TBL& trans_tbl(int index) const; + ::pb::TRANS_TBL* add_trans_tbl(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >& + trans_tbl() const; + + // repeated .pb.trans_local gTrans = 5; + int gtrans_size() const; + private: + int _internal_gtrans_size() const; + public: + void clear_gtrans(); + ::pb::trans_local* mutable_gtrans(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >* + mutable_gtrans(); + private: + const ::pb::trans_local& _internal_gtrans(int index) const; + ::pb::trans_local* _internal_add_gtrans(); + public: + const ::pb::trans_local& gtrans(int index) const; + ::pb::trans_local* add_gtrans(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >& + gtrans() const; + + // optional string guid = 6; + bool has_guid() const; + private: + bool _internal_has_guid() const; + public: + void clear_guid(); + const std::string& guid() const; + void set_guid(const std::string& value); + void set_guid(std::string&& value); + void set_guid(const char* value); + void set_guid(const char* value, size_t size); + std::string* mutable_guid(); + std::string* release_guid(); + void set_allocated_guid(std::string* guid); + private: + const std::string& _internal_guid() const; + void _internal_set_guid(const std::string& value); + std::string* _internal_mutable_guid(); + public: + + // optional string cytolib_verion = 7; + bool has_cytolib_verion() const; + private: + bool _internal_has_cytolib_verion() const; + public: + void clear_cytolib_verion(); + const std::string& cytolib_verion() const; + void set_cytolib_verion(const std::string& value); + void set_cytolib_verion(std::string&& value); + void set_cytolib_verion(const char* value); + void set_cytolib_verion(const char* value, size_t size); + std::string* mutable_cytolib_verion(); + std::string* release_cytolib_verion(); + void set_allocated_cytolib_verion(std::string* cytolib_verion); + private: + const std::string& _internal_cytolib_verion() const; + void _internal_set_cytolib_verion(const std::string& value); + std::string* _internal_mutable_cytolib_verion(); + public: + + // optional string pb_verion = 8; + bool has_pb_verion() const; + private: + bool _internal_has_pb_verion() const; + public: + void clear_pb_verion(); + const std::string& pb_verion() const; + void set_pb_verion(const std::string& value); + void set_pb_verion(std::string&& value); + void set_pb_verion(const char* value); + void set_pb_verion(const char* value, size_t size); + std::string* mutable_pb_verion(); + std::string* release_pb_verion(); + void set_allocated_pb_verion(std::string* pb_verion); + private: + const std::string& _internal_pb_verion() const; + void _internal_set_pb_verion(const std::string& value); + std::string* _internal_mutable_pb_verion(); + public: + + // optional string h5_verion = 9; + bool has_h5_verion() const; + private: + bool _internal_has_h5_verion() const; + public: + void clear_h5_verion(); + const std::string& h5_verion() const; + void set_h5_verion(const std::string& value); + void set_h5_verion(std::string&& value); + void set_h5_verion(const char* value); + void set_h5_verion(const char* value, size_t size); + std::string* mutable_h5_verion(); + std::string* release_h5_verion(); + void set_allocated_h5_verion(std::string* h5_verion); + private: + const std::string& _internal_h5_verion() const; + void _internal_set_h5_verion(const std::string& value); + std::string* _internal_mutable_h5_verion(); + public: + + // optional uint64 globalBiExpTrans = 3; + bool has_globalbiexptrans() const; + private: + bool _internal_has_globalbiexptrans() const; + public: + void clear_globalbiexptrans(); + ::PROTOBUF_NAMESPACE_ID::uint64 globalbiexptrans() const; + void set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_globalbiexptrans() const; + void _internal_set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // optional uint64 globalLinTrans = 4; + bool has_globallintrans() const; + private: + bool _internal_has_globallintrans() const; + public: + void clear_globallintrans(); + ::PROTOBUF_NAMESPACE_ID::uint64 globallintrans() const; + void set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_globallintrans() const; + void _internal_set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:pb.GatingSet) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField samplename_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL > trans_tbl_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local > gtrans_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr guid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cytolib_verion_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pb_verion_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr h5_verion_; + ::PROTOBUF_NAMESPACE_ID::uint64 globalbiexptrans_; + ::PROTOBUF_NAMESPACE_ID::uint64 globallintrans_; + friend struct ::TableStruct_GatingSet_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// paramRange + +// required string name = 1; +inline bool paramRange::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool paramRange::has_name() const { + return _internal_has_name(); +} +inline void paramRange::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& paramRange::name() const { + // @@protoc_insertion_point(field_get:pb.paramRange.name) + return _internal_name(); +} +inline void paramRange::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:pb.paramRange.name) +} +inline std::string* paramRange::mutable_name() { + // @@protoc_insertion_point(field_mutable:pb.paramRange.name) + return _internal_mutable_name(); +} +inline const std::string& paramRange::_internal_name() const { + return name_.Get(); +} +inline void paramRange::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void paramRange::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.paramRange.name) +} +inline void paramRange::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.paramRange.name) +} +inline void paramRange::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.paramRange.name) +} +inline std::string* paramRange::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* paramRange::release_name() { + // @@protoc_insertion_point(field_release:pb.paramRange.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void paramRange::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.paramRange.name) +} + +// required float min = 2; +inline bool paramRange::_internal_has_min() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool paramRange::has_min() const { + return _internal_has_min(); +} +inline void paramRange::clear_min() { + min_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float paramRange::_internal_min() const { + return min_; +} +inline float paramRange::min() const { + // @@protoc_insertion_point(field_get:pb.paramRange.min) + return _internal_min(); +} +inline void paramRange::_internal_set_min(float value) { + _has_bits_[0] |= 0x00000002u; + min_ = value; +} +inline void paramRange::set_min(float value) { + _internal_set_min(value); + // @@protoc_insertion_point(field_set:pb.paramRange.min) +} + +// required float max = 3; +inline bool paramRange::_internal_has_max() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool paramRange::has_max() const { + return _internal_has_max(); +} +inline void paramRange::clear_max() { + max_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float paramRange::_internal_max() const { + return max_; +} +inline float paramRange::max() const { + // @@protoc_insertion_point(field_get:pb.paramRange.max) + return _internal_max(); +} +inline void paramRange::_internal_set_max(float value) { + _has_bits_[0] |= 0x00000004u; + max_ = value; +} +inline void paramRange::set_max(float value) { + _internal_set_max(value); + // @@protoc_insertion_point(field_set:pb.paramRange.max) +} + +// ------------------------------------------------------------------- + +// rangeGate + +// required .pb.paramRange param = 1; +inline bool rangeGate::_internal_has_param() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || param_ != nullptr); + return value; +} +inline bool rangeGate::has_param() const { + return _internal_has_param(); +} +inline void rangeGate::clear_param() { + if (param_ != nullptr) param_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::paramRange& rangeGate::_internal_param() const { + const ::pb::paramRange* p = param_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_paramRange_default_instance_); +} +inline const ::pb::paramRange& rangeGate::param() const { + // @@protoc_insertion_point(field_get:pb.rangeGate.param) + return _internal_param(); +} +inline void rangeGate::unsafe_arena_set_allocated_param( + ::pb::paramRange* param) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(param_); + } + param_ = param; + if (param) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.rangeGate.param) +} +inline ::pb::paramRange* rangeGate::release_param() { + _has_bits_[0] &= ~0x00000001u; + ::pb::paramRange* temp = param_; + param_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::paramRange* rangeGate::unsafe_arena_release_param() { + // @@protoc_insertion_point(field_release:pb.rangeGate.param) + _has_bits_[0] &= ~0x00000001u; + ::pb::paramRange* temp = param_; + param_ = nullptr; + return temp; +} +inline ::pb::paramRange* rangeGate::_internal_mutable_param() { + _has_bits_[0] |= 0x00000001u; + if (param_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::paramRange>(GetArena()); + param_ = p; + } + return param_; +} +inline ::pb::paramRange* rangeGate::mutable_param() { + // @@protoc_insertion_point(field_mutable:pb.rangeGate.param) + return _internal_mutable_param(); +} +inline void rangeGate::set_allocated_param(::pb::paramRange* param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete param_; + } + if (param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(param); + if (message_arena != submessage_arena) { + param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, param, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + param_ = param; + // @@protoc_insertion_point(field_set_allocated:pb.rangeGate.param) +} + +// ------------------------------------------------------------------- + +// paramPoly + +// repeated string params = 1; +inline int paramPoly::_internal_params_size() const { + return params_.size(); +} +inline int paramPoly::params_size() const { + return _internal_params_size(); +} +inline void paramPoly::clear_params() { + params_.Clear(); +} +inline std::string* paramPoly::add_params() { + // @@protoc_insertion_point(field_add_mutable:pb.paramPoly.params) + return _internal_add_params(); +} +inline const std::string& paramPoly::_internal_params(int index) const { + return params_.Get(index); +} +inline const std::string& paramPoly::params(int index) const { + // @@protoc_insertion_point(field_get:pb.paramPoly.params) + return _internal_params(index); +} +inline std::string* paramPoly::mutable_params(int index) { + // @@protoc_insertion_point(field_mutable:pb.paramPoly.params) + return params_.Mutable(index); +} +inline void paramPoly::set_params(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:pb.paramPoly.params) + params_.Mutable(index)->assign(value); +} +inline void paramPoly::set_params(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:pb.paramPoly.params) + params_.Mutable(index)->assign(std::move(value)); +} +inline void paramPoly::set_params(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + params_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:pb.paramPoly.params) +} +inline void paramPoly::set_params(int index, const char* value, size_t size) { + params_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:pb.paramPoly.params) +} +inline std::string* paramPoly::_internal_add_params() { + return params_.Add(); +} +inline void paramPoly::add_params(const std::string& value) { + params_.Add()->assign(value); + // @@protoc_insertion_point(field_add:pb.paramPoly.params) +} +inline void paramPoly::add_params(std::string&& value) { + params_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:pb.paramPoly.params) +} +inline void paramPoly::add_params(const char* value) { + GOOGLE_DCHECK(value != nullptr); + params_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:pb.paramPoly.params) +} +inline void paramPoly::add_params(const char* value, size_t size) { + params_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:pb.paramPoly.params) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +paramPoly::params() const { + // @@protoc_insertion_point(field_list:pb.paramPoly.params) + return params_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +paramPoly::mutable_params() { + // @@protoc_insertion_point(field_mutable_list:pb.paramPoly.params) + return ¶ms_; +} + +// repeated .pb.coordinate vertices = 2; +inline int paramPoly::_internal_vertices_size() const { + return vertices_.size(); +} +inline int paramPoly::vertices_size() const { + return _internal_vertices_size(); +} +inline void paramPoly::clear_vertices() { + vertices_.Clear(); +} +inline ::pb::coordinate* paramPoly::mutable_vertices(int index) { + // @@protoc_insertion_point(field_mutable:pb.paramPoly.vertices) + return vertices_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* +paramPoly::mutable_vertices() { + // @@protoc_insertion_point(field_mutable_list:pb.paramPoly.vertices) + return &vertices_; +} +inline const ::pb::coordinate& paramPoly::_internal_vertices(int index) const { + return vertices_.Get(index); +} +inline const ::pb::coordinate& paramPoly::vertices(int index) const { + // @@protoc_insertion_point(field_get:pb.paramPoly.vertices) + return _internal_vertices(index); +} +inline ::pb::coordinate* paramPoly::_internal_add_vertices() { + return vertices_.Add(); +} +inline ::pb::coordinate* paramPoly::add_vertices() { + // @@protoc_insertion_point(field_add:pb.paramPoly.vertices) + return _internal_add_vertices(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& +paramPoly::vertices() const { + // @@protoc_insertion_point(field_list:pb.paramPoly.vertices) + return vertices_; +} + +// ------------------------------------------------------------------- + +// polygonGate + +// required .pb.paramPoly param = 1; +inline bool polygonGate::_internal_has_param() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || param_ != nullptr); + return value; +} +inline bool polygonGate::has_param() const { + return _internal_has_param(); +} +inline void polygonGate::clear_param() { + if (param_ != nullptr) param_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::paramPoly& polygonGate::_internal_param() const { + const ::pb::paramPoly* p = param_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_paramPoly_default_instance_); +} +inline const ::pb::paramPoly& polygonGate::param() const { + // @@protoc_insertion_point(field_get:pb.polygonGate.param) + return _internal_param(); +} +inline void polygonGate::unsafe_arena_set_allocated_param( + ::pb::paramPoly* param) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(param_); + } + param_ = param; + if (param) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.polygonGate.param) +} +inline ::pb::paramPoly* polygonGate::release_param() { + _has_bits_[0] &= ~0x00000001u; + ::pb::paramPoly* temp = param_; + param_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::paramPoly* polygonGate::unsafe_arena_release_param() { + // @@protoc_insertion_point(field_release:pb.polygonGate.param) + _has_bits_[0] &= ~0x00000001u; + ::pb::paramPoly* temp = param_; + param_ = nullptr; + return temp; +} +inline ::pb::paramPoly* polygonGate::_internal_mutable_param() { + _has_bits_[0] |= 0x00000001u; + if (param_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::paramPoly>(GetArena()); + param_ = p; + } + return param_; +} +inline ::pb::paramPoly* polygonGate::mutable_param() { + // @@protoc_insertion_point(field_mutable:pb.polygonGate.param) + return _internal_mutable_param(); +} +inline void polygonGate::set_allocated_param(::pb::paramPoly* param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete param_; + } + if (param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(param); + if (message_arena != submessage_arena) { + param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, param, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + param_ = param; + // @@protoc_insertion_point(field_set_allocated:pb.polygonGate.param) +} + +// optional .pb.quadGate qg = 2; +inline bool polygonGate::_internal_has_qg() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || qg_ != nullptr); + return value; +} +inline bool polygonGate::has_qg() const { + return _internal_has_qg(); +} +inline void polygonGate::clear_qg() { + if (qg_ != nullptr) qg_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::pb::quadGate& polygonGate::_internal_qg() const { + const ::pb::quadGate* p = qg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_quadGate_default_instance_); +} +inline const ::pb::quadGate& polygonGate::qg() const { + // @@protoc_insertion_point(field_get:pb.polygonGate.qg) + return _internal_qg(); +} +inline void polygonGate::unsafe_arena_set_allocated_qg( + ::pb::quadGate* qg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qg_); + } + qg_ = qg; + if (qg) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.polygonGate.qg) +} +inline ::pb::quadGate* polygonGate::release_qg() { + _has_bits_[0] &= ~0x00000002u; + ::pb::quadGate* temp = qg_; + qg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::quadGate* polygonGate::unsafe_arena_release_qg() { + // @@protoc_insertion_point(field_release:pb.polygonGate.qg) + _has_bits_[0] &= ~0x00000002u; + ::pb::quadGate* temp = qg_; + qg_ = nullptr; + return temp; +} +inline ::pb::quadGate* polygonGate::_internal_mutable_qg() { + _has_bits_[0] |= 0x00000002u; + if (qg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::quadGate>(GetArena()); + qg_ = p; + } + return qg_; +} +inline ::pb::quadGate* polygonGate::mutable_qg() { + // @@protoc_insertion_point(field_mutable:pb.polygonGate.qg) + return _internal_mutable_qg(); +} +inline void polygonGate::set_allocated_qg(::pb::quadGate* qg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete qg_; + } + if (qg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qg); + if (message_arena != submessage_arena) { + qg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, qg, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + qg_ = qg; + // @@protoc_insertion_point(field_set_allocated:pb.polygonGate.qg) +} + +// ------------------------------------------------------------------- + +// coordinate + +// required float x = 1; +inline bool coordinate::_internal_has_x() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool coordinate::has_x() const { + return _internal_has_x(); +} +inline void coordinate::clear_x() { + x_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float coordinate::_internal_x() const { + return x_; +} +inline float coordinate::x() const { + // @@protoc_insertion_point(field_get:pb.coordinate.x) + return _internal_x(); +} +inline void coordinate::_internal_set_x(float value) { + _has_bits_[0] |= 0x00000001u; + x_ = value; +} +inline void coordinate::set_x(float value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:pb.coordinate.x) +} + +// required float y = 2; +inline bool coordinate::_internal_has_y() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool coordinate::has_y() const { + return _internal_has_y(); +} +inline void coordinate::clear_y() { + y_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float coordinate::_internal_y() const { + return y_; +} +inline float coordinate::y() const { + // @@protoc_insertion_point(field_get:pb.coordinate.y) + return _internal_y(); +} +inline void coordinate::_internal_set_y(float value) { + _has_bits_[0] |= 0x00000002u; + y_ = value; +} +inline void coordinate::set_y(float value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:pb.coordinate.y) +} + +// ------------------------------------------------------------------- + +// ellipseGate + +// required .pb.coordinate mu = 1; +inline bool ellipseGate::_internal_has_mu() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || mu_ != nullptr); + return value; +} +inline bool ellipseGate::has_mu() const { + return _internal_has_mu(); +} +inline void ellipseGate::clear_mu() { + if (mu_ != nullptr) mu_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::coordinate& ellipseGate::_internal_mu() const { + const ::pb::coordinate* p = mu_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_coordinate_default_instance_); +} +inline const ::pb::coordinate& ellipseGate::mu() const { + // @@protoc_insertion_point(field_get:pb.ellipseGate.mu) + return _internal_mu(); +} +inline void ellipseGate::unsafe_arena_set_allocated_mu( + ::pb::coordinate* mu) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mu_); + } + mu_ = mu; + if (mu) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ellipseGate.mu) +} +inline ::pb::coordinate* ellipseGate::release_mu() { + _has_bits_[0] &= ~0x00000001u; + ::pb::coordinate* temp = mu_; + mu_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::coordinate* ellipseGate::unsafe_arena_release_mu() { + // @@protoc_insertion_point(field_release:pb.ellipseGate.mu) + _has_bits_[0] &= ~0x00000001u; + ::pb::coordinate* temp = mu_; + mu_ = nullptr; + return temp; +} +inline ::pb::coordinate* ellipseGate::_internal_mutable_mu() { + _has_bits_[0] |= 0x00000001u; + if (mu_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::coordinate>(GetArena()); + mu_ = p; + } + return mu_; +} +inline ::pb::coordinate* ellipseGate::mutable_mu() { + // @@protoc_insertion_point(field_mutable:pb.ellipseGate.mu) + return _internal_mutable_mu(); +} +inline void ellipseGate::set_allocated_mu(::pb::coordinate* mu) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete mu_; + } + if (mu) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(mu); + if (message_arena != submessage_arena) { + mu = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, mu, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + mu_ = mu; + // @@protoc_insertion_point(field_set_allocated:pb.ellipseGate.mu) +} + +// repeated .pb.coordinate cov = 2; +inline int ellipseGate::_internal_cov_size() const { + return cov_.size(); +} +inline int ellipseGate::cov_size() const { + return _internal_cov_size(); +} +inline void ellipseGate::clear_cov() { + cov_.Clear(); +} +inline ::pb::coordinate* ellipseGate::mutable_cov(int index) { + // @@protoc_insertion_point(field_mutable:pb.ellipseGate.cov) + return cov_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* +ellipseGate::mutable_cov() { + // @@protoc_insertion_point(field_mutable_list:pb.ellipseGate.cov) + return &cov_; +} +inline const ::pb::coordinate& ellipseGate::_internal_cov(int index) const { + return cov_.Get(index); +} +inline const ::pb::coordinate& ellipseGate::cov(int index) const { + // @@protoc_insertion_point(field_get:pb.ellipseGate.cov) + return _internal_cov(index); +} +inline ::pb::coordinate* ellipseGate::_internal_add_cov() { + return cov_.Add(); +} +inline ::pb::coordinate* ellipseGate::add_cov() { + // @@protoc_insertion_point(field_add:pb.ellipseGate.cov) + return _internal_add_cov(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& +ellipseGate::cov() const { + // @@protoc_insertion_point(field_list:pb.ellipseGate.cov) + return cov_; +} + +// repeated .pb.coordinate antipodal_vertices = 3; +inline int ellipseGate::_internal_antipodal_vertices_size() const { + return antipodal_vertices_.size(); +} +inline int ellipseGate::antipodal_vertices_size() const { + return _internal_antipodal_vertices_size(); +} +inline void ellipseGate::clear_antipodal_vertices() { + antipodal_vertices_.Clear(); +} +inline ::pb::coordinate* ellipseGate::mutable_antipodal_vertices(int index) { + // @@protoc_insertion_point(field_mutable:pb.ellipseGate.antipodal_vertices) + return antipodal_vertices_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >* +ellipseGate::mutable_antipodal_vertices() { + // @@protoc_insertion_point(field_mutable_list:pb.ellipseGate.antipodal_vertices) + return &antipodal_vertices_; +} +inline const ::pb::coordinate& ellipseGate::_internal_antipodal_vertices(int index) const { + return antipodal_vertices_.Get(index); +} +inline const ::pb::coordinate& ellipseGate::antipodal_vertices(int index) const { + // @@protoc_insertion_point(field_get:pb.ellipseGate.antipodal_vertices) + return _internal_antipodal_vertices(index); +} +inline ::pb::coordinate* ellipseGate::_internal_add_antipodal_vertices() { + return antipodal_vertices_.Add(); +} +inline ::pb::coordinate* ellipseGate::add_antipodal_vertices() { + // @@protoc_insertion_point(field_add:pb.ellipseGate.antipodal_vertices) + return _internal_add_antipodal_vertices(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::coordinate >& +ellipseGate::antipodal_vertices() const { + // @@protoc_insertion_point(field_list:pb.ellipseGate.antipodal_vertices) + return antipodal_vertices_; +} + +// optional float dist = 4; +inline bool ellipseGate::_internal_has_dist() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ellipseGate::has_dist() const { + return _internal_has_dist(); +} +inline void ellipseGate::clear_dist() { + dist_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float ellipseGate::_internal_dist() const { + return dist_; +} +inline float ellipseGate::dist() const { + // @@protoc_insertion_point(field_get:pb.ellipseGate.dist) + return _internal_dist(); +} +inline void ellipseGate::_internal_set_dist(float value) { + _has_bits_[0] |= 0x00000002u; + dist_ = value; +} +inline void ellipseGate::set_dist(float value) { + _internal_set_dist(value); + // @@protoc_insertion_point(field_set:pb.ellipseGate.dist) +} + +// ------------------------------------------------------------------- + +// BOOL_GATE_OP + +// repeated string path = 1; +inline int BOOL_GATE_OP::_internal_path_size() const { + return path_.size(); +} +inline int BOOL_GATE_OP::path_size() const { + return _internal_path_size(); +} +inline void BOOL_GATE_OP::clear_path() { + path_.Clear(); +} +inline std::string* BOOL_GATE_OP::add_path() { + // @@protoc_insertion_point(field_add_mutable:pb.BOOL_GATE_OP.path) + return _internal_add_path(); +} +inline const std::string& BOOL_GATE_OP::_internal_path(int index) const { + return path_.Get(index); +} +inline const std::string& BOOL_GATE_OP::path(int index) const { + // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.path) + return _internal_path(index); +} +inline std::string* BOOL_GATE_OP::mutable_path(int index) { + // @@protoc_insertion_point(field_mutable:pb.BOOL_GATE_OP.path) + return path_.Mutable(index); +} +inline void BOOL_GATE_OP::set_path(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.path) + path_.Mutable(index)->assign(value); +} +inline void BOOL_GATE_OP::set_path(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.path) + path_.Mutable(index)->assign(std::move(value)); +} +inline void BOOL_GATE_OP::set_path(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + path_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:pb.BOOL_GATE_OP.path) +} +inline void BOOL_GATE_OP::set_path(int index, const char* value, size_t size) { + path_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:pb.BOOL_GATE_OP.path) +} +inline std::string* BOOL_GATE_OP::_internal_add_path() { + return path_.Add(); +} +inline void BOOL_GATE_OP::add_path(const std::string& value) { + path_.Add()->assign(value); + // @@protoc_insertion_point(field_add:pb.BOOL_GATE_OP.path) +} +inline void BOOL_GATE_OP::add_path(std::string&& value) { + path_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:pb.BOOL_GATE_OP.path) +} +inline void BOOL_GATE_OP::add_path(const char* value) { + GOOGLE_DCHECK(value != nullptr); + path_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:pb.BOOL_GATE_OP.path) +} +inline void BOOL_GATE_OP::add_path(const char* value, size_t size) { + path_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:pb.BOOL_GATE_OP.path) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +BOOL_GATE_OP::path() const { + // @@protoc_insertion_point(field_list:pb.BOOL_GATE_OP.path) + return path_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +BOOL_GATE_OP::mutable_path() { + // @@protoc_insertion_point(field_mutable_list:pb.BOOL_GATE_OP.path) + return &path_; +} + +// required uint32 op = 2; +inline bool BOOL_GATE_OP::_internal_has_op() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BOOL_GATE_OP::has_op() const { + return _internal_has_op(); +} +inline void BOOL_GATE_OP::clear_op() { + op_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BOOL_GATE_OP::_internal_op() const { + return op_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 BOOL_GATE_OP::op() const { + // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.op) + return _internal_op(); +} +inline void BOOL_GATE_OP::_internal_set_op(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + op_ = value; +} +inline void BOOL_GATE_OP::set_op(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_op(value); + // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.op) +} + +// required bool isNot = 3; +inline bool BOOL_GATE_OP::_internal_has_isnot() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BOOL_GATE_OP::has_isnot() const { + return _internal_has_isnot(); +} +inline void BOOL_GATE_OP::clear_isnot() { + isnot_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool BOOL_GATE_OP::_internal_isnot() const { + return isnot_; +} +inline bool BOOL_GATE_OP::isnot() const { + // @@protoc_insertion_point(field_get:pb.BOOL_GATE_OP.isNot) + return _internal_isnot(); +} +inline void BOOL_GATE_OP::_internal_set_isnot(bool value) { + _has_bits_[0] |= 0x00000002u; + isnot_ = value; +} +inline void BOOL_GATE_OP::set_isnot(bool value) { + _internal_set_isnot(value); + // @@protoc_insertion_point(field_set:pb.BOOL_GATE_OP.isNot) +} + +// ------------------------------------------------------------------- + +// boolGate + +// repeated .pb.BOOL_GATE_OP boolOpSpec = 1; +inline int boolGate::_internal_boolopspec_size() const { + return boolopspec_.size(); +} +inline int boolGate::boolopspec_size() const { + return _internal_boolopspec_size(); +} +inline void boolGate::clear_boolopspec() { + boolopspec_.Clear(); +} +inline ::pb::BOOL_GATE_OP* boolGate::mutable_boolopspec(int index) { + // @@protoc_insertion_point(field_mutable:pb.boolGate.boolOpSpec) + return boolopspec_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >* +boolGate::mutable_boolopspec() { + // @@protoc_insertion_point(field_mutable_list:pb.boolGate.boolOpSpec) + return &boolopspec_; +} +inline const ::pb::BOOL_GATE_OP& boolGate::_internal_boolopspec(int index) const { + return boolopspec_.Get(index); +} +inline const ::pb::BOOL_GATE_OP& boolGate::boolopspec(int index) const { + // @@protoc_insertion_point(field_get:pb.boolGate.boolOpSpec) + return _internal_boolopspec(index); +} +inline ::pb::BOOL_GATE_OP* boolGate::_internal_add_boolopspec() { + return boolopspec_.Add(); +} +inline ::pb::BOOL_GATE_OP* boolGate::add_boolopspec() { + // @@protoc_insertion_point(field_add:pb.boolGate.boolOpSpec) + return _internal_add_boolopspec(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::BOOL_GATE_OP >& +boolGate::boolopspec() const { + // @@protoc_insertion_point(field_list:pb.boolGate.boolOpSpec) + return boolopspec_; +} + +// ------------------------------------------------------------------- + +// clusterGate + +// required string cluster_method = 1; +inline bool clusterGate::_internal_has_cluster_method() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool clusterGate::has_cluster_method() const { + return _internal_has_cluster_method(); +} +inline void clusterGate::clear_cluster_method() { + cluster_method_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& clusterGate::cluster_method() const { + // @@protoc_insertion_point(field_get:pb.clusterGate.cluster_method) + return _internal_cluster_method(); +} +inline void clusterGate::set_cluster_method(const std::string& value) { + _internal_set_cluster_method(value); + // @@protoc_insertion_point(field_set:pb.clusterGate.cluster_method) +} +inline std::string* clusterGate::mutable_cluster_method() { + // @@protoc_insertion_point(field_mutable:pb.clusterGate.cluster_method) + return _internal_mutable_cluster_method(); +} +inline const std::string& clusterGate::_internal_cluster_method() const { + return cluster_method_.Get(); +} +inline void clusterGate::_internal_set_cluster_method(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + cluster_method_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void clusterGate::set_cluster_method(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + cluster_method_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.clusterGate.cluster_method) +} +inline void clusterGate::set_cluster_method(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + cluster_method_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.clusterGate.cluster_method) +} +inline void clusterGate::set_cluster_method(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + cluster_method_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.clusterGate.cluster_method) +} +inline std::string* clusterGate::_internal_mutable_cluster_method() { + _has_bits_[0] |= 0x00000001u; + return cluster_method_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* clusterGate::release_cluster_method() { + // @@protoc_insertion_point(field_release:pb.clusterGate.cluster_method) + if (!_internal_has_cluster_method()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return cluster_method_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void clusterGate::set_allocated_cluster_method(std::string* cluster_method) { + if (cluster_method != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + cluster_method_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cluster_method, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.clusterGate.cluster_method) +} + +// ------------------------------------------------------------------- + +// quadGate + +// required string uid = 1; +inline bool quadGate::_internal_has_uid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool quadGate::has_uid() const { + return _internal_has_uid(); +} +inline void quadGate::clear_uid() { + uid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& quadGate::uid() const { + // @@protoc_insertion_point(field_get:pb.quadGate.uid) + return _internal_uid(); +} +inline void quadGate::set_uid(const std::string& value) { + _internal_set_uid(value); + // @@protoc_insertion_point(field_set:pb.quadGate.uid) +} +inline std::string* quadGate::mutable_uid() { + // @@protoc_insertion_point(field_mutable:pb.quadGate.uid) + return _internal_mutable_uid(); +} +inline const std::string& quadGate::_internal_uid() const { + return uid_.Get(); +} +inline void quadGate::_internal_set_uid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + uid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void quadGate::set_uid(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + uid_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.quadGate.uid) +} +inline void quadGate::set_uid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + uid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.quadGate.uid) +} +inline void quadGate::set_uid(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + uid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.quadGate.uid) +} +inline std::string* quadGate::_internal_mutable_uid() { + _has_bits_[0] |= 0x00000001u; + return uid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* quadGate::release_uid() { + // @@protoc_insertion_point(field_release:pb.quadGate.uid) + if (!_internal_has_uid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return uid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void quadGate::set_allocated_uid(std::string* uid) { + if (uid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + uid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.quadGate.uid) +} + +// required .pb.QUADRANT quadrant = 3; +inline bool quadGate::_internal_has_quadrant() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool quadGate::has_quadrant() const { + return _internal_has_quadrant(); +} +inline void quadGate::clear_quadrant() { + quadrant_ = 1; + _has_bits_[0] &= ~0x00000002u; +} +inline ::pb::QUADRANT quadGate::_internal_quadrant() const { + return static_cast< ::pb::QUADRANT >(quadrant_); +} +inline ::pb::QUADRANT quadGate::quadrant() const { + // @@protoc_insertion_point(field_get:pb.quadGate.quadrant) + return _internal_quadrant(); +} +inline void quadGate::_internal_set_quadrant(::pb::QUADRANT value) { + assert(::pb::QUADRANT_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + quadrant_ = value; +} +inline void quadGate::set_quadrant(::pb::QUADRANT value) { + _internal_set_quadrant(value); + // @@protoc_insertion_point(field_set:pb.quadGate.quadrant) +} + +// ------------------------------------------------------------------- + +// gate + +// required bool neg = 1; +inline bool gate::_internal_has_neg() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool gate::has_neg() const { + return _internal_has_neg(); +} +inline void gate::clear_neg() { + neg_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool gate::_internal_neg() const { + return neg_; +} +inline bool gate::neg() const { + // @@protoc_insertion_point(field_get:pb.gate.neg) + return _internal_neg(); +} +inline void gate::_internal_set_neg(bool value) { + _has_bits_[0] |= 0x00000020u; + neg_ = value; +} +inline void gate::set_neg(bool value) { + _internal_set_neg(value); + // @@protoc_insertion_point(field_set:pb.gate.neg) +} + +// required bool isTransformed = 2; +inline bool gate::_internal_has_istransformed() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool gate::has_istransformed() const { + return _internal_has_istransformed(); +} +inline void gate::clear_istransformed() { + istransformed_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool gate::_internal_istransformed() const { + return istransformed_; +} +inline bool gate::istransformed() const { + // @@protoc_insertion_point(field_get:pb.gate.isTransformed) + return _internal_istransformed(); +} +inline void gate::_internal_set_istransformed(bool value) { + _has_bits_[0] |= 0x00000040u; + istransformed_ = value; +} +inline void gate::set_istransformed(bool value) { + _internal_set_istransformed(value); + // @@protoc_insertion_point(field_set:pb.gate.isTransformed) +} + +// required bool isGained = 3; +inline bool gate::_internal_has_isgained() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool gate::has_isgained() const { + return _internal_has_isgained(); +} +inline void gate::clear_isgained() { + isgained_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool gate::_internal_isgained() const { + return isgained_; +} +inline bool gate::isgained() const { + // @@protoc_insertion_point(field_get:pb.gate.isGained) + return _internal_isgained(); +} +inline void gate::_internal_set_isgained(bool value) { + _has_bits_[0] |= 0x00000080u; + isgained_ = value; +} +inline void gate::set_isgained(bool value) { + _internal_set_isgained(value); + // @@protoc_insertion_point(field_set:pb.gate.isGained) +} + +// required .pb.GATE_TYPE type = 4; +inline bool gate::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool gate::has_type() const { + return _internal_has_type(); +} +inline void gate::clear_type() { + type_ = 1; + _has_bits_[0] &= ~0x00000100u; +} +inline ::pb::GATE_TYPE gate::_internal_type() const { + return static_cast< ::pb::GATE_TYPE >(type_); +} +inline ::pb::GATE_TYPE gate::type() const { + // @@protoc_insertion_point(field_get:pb.gate.type) + return _internal_type(); +} +inline void gate::_internal_set_type(::pb::GATE_TYPE value) { + assert(::pb::GATE_TYPE_IsValid(value)); + _has_bits_[0] |= 0x00000100u; + type_ = value; +} +inline void gate::set_type(::pb::GATE_TYPE value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:pb.gate.type) +} + +// optional .pb.rangeGate rg = 5; +inline bool gate::_internal_has_rg() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || rg_ != nullptr); + return value; +} +inline bool gate::has_rg() const { + return _internal_has_rg(); +} +inline void gate::clear_rg() { + if (rg_ != nullptr) rg_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::rangeGate& gate::_internal_rg() const { + const ::pb::rangeGate* p = rg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_rangeGate_default_instance_); +} +inline const ::pb::rangeGate& gate::rg() const { + // @@protoc_insertion_point(field_get:pb.gate.rg) + return _internal_rg(); +} +inline void gate::unsafe_arena_set_allocated_rg( + ::pb::rangeGate* rg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rg_); + } + rg_ = rg; + if (rg) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.gate.rg) +} +inline ::pb::rangeGate* gate::release_rg() { + _has_bits_[0] &= ~0x00000001u; + ::pb::rangeGate* temp = rg_; + rg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::rangeGate* gate::unsafe_arena_release_rg() { + // @@protoc_insertion_point(field_release:pb.gate.rg) + _has_bits_[0] &= ~0x00000001u; + ::pb::rangeGate* temp = rg_; + rg_ = nullptr; + return temp; +} +inline ::pb::rangeGate* gate::_internal_mutable_rg() { + _has_bits_[0] |= 0x00000001u; + if (rg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::rangeGate>(GetArena()); + rg_ = p; + } + return rg_; +} +inline ::pb::rangeGate* gate::mutable_rg() { + // @@protoc_insertion_point(field_mutable:pb.gate.rg) + return _internal_mutable_rg(); +} +inline void gate::set_allocated_rg(::pb::rangeGate* rg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete rg_; + } + if (rg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(rg); + if (message_arena != submessage_arena) { + rg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rg, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + rg_ = rg; + // @@protoc_insertion_point(field_set_allocated:pb.gate.rg) +} + +// optional .pb.polygonGate pg = 6; +inline bool gate::_internal_has_pg() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || pg_ != nullptr); + return value; +} +inline bool gate::has_pg() const { + return _internal_has_pg(); +} +inline void gate::clear_pg() { + if (pg_ != nullptr) pg_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::pb::polygonGate& gate::_internal_pg() const { + const ::pb::polygonGate* p = pg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_polygonGate_default_instance_); +} +inline const ::pb::polygonGate& gate::pg() const { + // @@protoc_insertion_point(field_get:pb.gate.pg) + return _internal_pg(); +} +inline void gate::unsafe_arena_set_allocated_pg( + ::pb::polygonGate* pg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pg_); + } + pg_ = pg; + if (pg) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.gate.pg) +} +inline ::pb::polygonGate* gate::release_pg() { + _has_bits_[0] &= ~0x00000002u; + ::pb::polygonGate* temp = pg_; + pg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::polygonGate* gate::unsafe_arena_release_pg() { + // @@protoc_insertion_point(field_release:pb.gate.pg) + _has_bits_[0] &= ~0x00000002u; + ::pb::polygonGate* temp = pg_; + pg_ = nullptr; + return temp; +} +inline ::pb::polygonGate* gate::_internal_mutable_pg() { + _has_bits_[0] |= 0x00000002u; + if (pg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::polygonGate>(GetArena()); + pg_ = p; + } + return pg_; +} +inline ::pb::polygonGate* gate::mutable_pg() { + // @@protoc_insertion_point(field_mutable:pb.gate.pg) + return _internal_mutable_pg(); +} +inline void gate::set_allocated_pg(::pb::polygonGate* pg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete pg_; + } + if (pg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pg); + if (message_arena != submessage_arena) { + pg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pg, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + pg_ = pg; + // @@protoc_insertion_point(field_set_allocated:pb.gate.pg) +} + +// optional .pb.ellipseGate eg = 7; +inline bool gate::_internal_has_eg() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || eg_ != nullptr); + return value; +} +inline bool gate::has_eg() const { + return _internal_has_eg(); +} +inline void gate::clear_eg() { + if (eg_ != nullptr) eg_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::pb::ellipseGate& gate::_internal_eg() const { + const ::pb::ellipseGate* p = eg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_ellipseGate_default_instance_); +} +inline const ::pb::ellipseGate& gate::eg() const { + // @@protoc_insertion_point(field_get:pb.gate.eg) + return _internal_eg(); +} +inline void gate::unsafe_arena_set_allocated_eg( + ::pb::ellipseGate* eg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eg_); + } + eg_ = eg; + if (eg) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.gate.eg) +} +inline ::pb::ellipseGate* gate::release_eg() { + _has_bits_[0] &= ~0x00000004u; + ::pb::ellipseGate* temp = eg_; + eg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::ellipseGate* gate::unsafe_arena_release_eg() { + // @@protoc_insertion_point(field_release:pb.gate.eg) + _has_bits_[0] &= ~0x00000004u; + ::pb::ellipseGate* temp = eg_; + eg_ = nullptr; + return temp; +} +inline ::pb::ellipseGate* gate::_internal_mutable_eg() { + _has_bits_[0] |= 0x00000004u; + if (eg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::ellipseGate>(GetArena()); + eg_ = p; + } + return eg_; +} +inline ::pb::ellipseGate* gate::mutable_eg() { + // @@protoc_insertion_point(field_mutable:pb.gate.eg) + return _internal_mutable_eg(); +} +inline void gate::set_allocated_eg(::pb::ellipseGate* eg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete eg_; + } + if (eg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(eg); + if (message_arena != submessage_arena) { + eg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, eg, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + eg_ = eg; + // @@protoc_insertion_point(field_set_allocated:pb.gate.eg) +} + +// optional .pb.boolGate bg = 8; +inline bool gate::_internal_has_bg() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || bg_ != nullptr); + return value; +} +inline bool gate::has_bg() const { + return _internal_has_bg(); +} +inline void gate::clear_bg() { + if (bg_ != nullptr) bg_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::pb::boolGate& gate::_internal_bg() const { + const ::pb::boolGate* p = bg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_boolGate_default_instance_); +} +inline const ::pb::boolGate& gate::bg() const { + // @@protoc_insertion_point(field_get:pb.gate.bg) + return _internal_bg(); +} +inline void gate::unsafe_arena_set_allocated_bg( + ::pb::boolGate* bg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bg_); + } + bg_ = bg; + if (bg) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.gate.bg) +} +inline ::pb::boolGate* gate::release_bg() { + _has_bits_[0] &= ~0x00000008u; + ::pb::boolGate* temp = bg_; + bg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::boolGate* gate::unsafe_arena_release_bg() { + // @@protoc_insertion_point(field_release:pb.gate.bg) + _has_bits_[0] &= ~0x00000008u; + ::pb::boolGate* temp = bg_; + bg_ = nullptr; + return temp; +} +inline ::pb::boolGate* gate::_internal_mutable_bg() { + _has_bits_[0] |= 0x00000008u; + if (bg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::boolGate>(GetArena()); + bg_ = p; + } + return bg_; +} +inline ::pb::boolGate* gate::mutable_bg() { + // @@protoc_insertion_point(field_mutable:pb.gate.bg) + return _internal_mutable_bg(); +} +inline void gate::set_allocated_bg(::pb::boolGate* bg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete bg_; + } + if (bg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bg); + if (message_arena != submessage_arena) { + bg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bg, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + bg_ = bg; + // @@protoc_insertion_point(field_set_allocated:pb.gate.bg) +} + +// optional .pb.clusterGate cg = 9; +inline bool gate::_internal_has_cg() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || cg_ != nullptr); + return value; +} +inline bool gate::has_cg() const { + return _internal_has_cg(); +} +inline void gate::clear_cg() { + if (cg_ != nullptr) cg_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::pb::clusterGate& gate::_internal_cg() const { + const ::pb::clusterGate* p = cg_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_clusterGate_default_instance_); +} +inline const ::pb::clusterGate& gate::cg() const { + // @@protoc_insertion_point(field_get:pb.gate.cg) + return _internal_cg(); +} +inline void gate::unsafe_arena_set_allocated_cg( + ::pb::clusterGate* cg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cg_); + } + cg_ = cg; + if (cg) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.gate.cg) +} +inline ::pb::clusterGate* gate::release_cg() { + _has_bits_[0] &= ~0x00000010u; + ::pb::clusterGate* temp = cg_; + cg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::clusterGate* gate::unsafe_arena_release_cg() { + // @@protoc_insertion_point(field_release:pb.gate.cg) + _has_bits_[0] &= ~0x00000010u; + ::pb::clusterGate* temp = cg_; + cg_ = nullptr; + return temp; +} +inline ::pb::clusterGate* gate::_internal_mutable_cg() { + _has_bits_[0] |= 0x00000010u; + if (cg_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::clusterGate>(GetArena()); + cg_ = p; + } + return cg_; +} +inline ::pb::clusterGate* gate::mutable_cg() { + // @@protoc_insertion_point(field_mutable:pb.gate.cg) + return _internal_mutable_cg(); +} +inline void gate::set_allocated_cg(::pb::clusterGate* cg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete cg_; + } + if (cg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cg); + if (message_arena != submessage_arena) { + cg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cg, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + cg_ = cg; + // @@protoc_insertion_point(field_set_allocated:pb.gate.cg) +} + +// ------------------------------------------------------------------- + +// POPSTATS + +// required string statType = 1; +inline bool POPSTATS::_internal_has_stattype() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool POPSTATS::has_stattype() const { + return _internal_has_stattype(); +} +inline void POPSTATS::clear_stattype() { + stattype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& POPSTATS::stattype() const { + // @@protoc_insertion_point(field_get:pb.POPSTATS.statType) + return _internal_stattype(); +} +inline void POPSTATS::set_stattype(const std::string& value) { + _internal_set_stattype(value); + // @@protoc_insertion_point(field_set:pb.POPSTATS.statType) +} +inline std::string* POPSTATS::mutable_stattype() { + // @@protoc_insertion_point(field_mutable:pb.POPSTATS.statType) + return _internal_mutable_stattype(); +} +inline const std::string& POPSTATS::_internal_stattype() const { + return stattype_.Get(); +} +inline void POPSTATS::_internal_set_stattype(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + stattype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void POPSTATS::set_stattype(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + stattype_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.POPSTATS.statType) +} +inline void POPSTATS::set_stattype(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + stattype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.POPSTATS.statType) +} +inline void POPSTATS::set_stattype(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + stattype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.POPSTATS.statType) +} +inline std::string* POPSTATS::_internal_mutable_stattype() { + _has_bits_[0] |= 0x00000001u; + return stattype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* POPSTATS::release_stattype() { + // @@protoc_insertion_point(field_release:pb.POPSTATS.statType) + if (!_internal_has_stattype()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return stattype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void POPSTATS::set_allocated_stattype(std::string* stattype) { + if (stattype != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + stattype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stattype, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.POPSTATS.statType) +} + +// required float statVal = 2; +inline bool POPSTATS::_internal_has_statval() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool POPSTATS::has_statval() const { + return _internal_has_statval(); +} +inline void POPSTATS::clear_statval() { + statval_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float POPSTATS::_internal_statval() const { + return statval_; +} +inline float POPSTATS::statval() const { + // @@protoc_insertion_point(field_get:pb.POPSTATS.statVal) + return _internal_statval(); +} +inline void POPSTATS::_internal_set_statval(float value) { + _has_bits_[0] |= 0x00000002u; + statval_ = value; +} +inline void POPSTATS::set_statval(float value) { + _internal_set_statval(value); + // @@protoc_insertion_point(field_set:pb.POPSTATS.statVal) +} + +// ------------------------------------------------------------------- + +// calibrationTable + +// repeated float x = 1 [packed = true]; +inline int calibrationTable::_internal_x_size() const { + return x_.size(); +} +inline int calibrationTable::x_size() const { + return _internal_x_size(); +} +inline void calibrationTable::clear_x() { + x_.Clear(); +} +inline float calibrationTable::_internal_x(int index) const { + return x_.Get(index); +} +inline float calibrationTable::x(int index) const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.x) + return _internal_x(index); +} +inline void calibrationTable::set_x(int index, float value) { + x_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.x) +} +inline void calibrationTable::_internal_add_x(float value) { + x_.Add(value); +} +inline void calibrationTable::add_x(float value) { + _internal_add_x(value); + // @@protoc_insertion_point(field_add:pb.calibrationTable.x) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::_internal_x() const { + return x_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::x() const { + // @@protoc_insertion_point(field_list:pb.calibrationTable.x) + return _internal_x(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::_internal_mutable_x() { + return &x_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::mutable_x() { + // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.x) + return _internal_mutable_x(); +} + +// repeated float y = 2 [packed = true]; +inline int calibrationTable::_internal_y_size() const { + return y_.size(); +} +inline int calibrationTable::y_size() const { + return _internal_y_size(); +} +inline void calibrationTable::clear_y() { + y_.Clear(); +} +inline float calibrationTable::_internal_y(int index) const { + return y_.Get(index); +} +inline float calibrationTable::y(int index) const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.y) + return _internal_y(index); +} +inline void calibrationTable::set_y(int index, float value) { + y_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.y) +} +inline void calibrationTable::_internal_add_y(float value) { + y_.Add(value); +} +inline void calibrationTable::add_y(float value) { + _internal_add_y(value); + // @@protoc_insertion_point(field_add:pb.calibrationTable.y) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::_internal_y() const { + return y_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::y() const { + // @@protoc_insertion_point(field_list:pb.calibrationTable.y) + return _internal_y(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::_internal_mutable_y() { + return &y_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::mutable_y() { + // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.y) + return _internal_mutable_y(); +} + +// repeated float b = 3 [packed = true]; +inline int calibrationTable::_internal_b_size() const { + return b_.size(); +} +inline int calibrationTable::b_size() const { + return _internal_b_size(); +} +inline void calibrationTable::clear_b() { + b_.Clear(); +} +inline float calibrationTable::_internal_b(int index) const { + return b_.Get(index); +} +inline float calibrationTable::b(int index) const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.b) + return _internal_b(index); +} +inline void calibrationTable::set_b(int index, float value) { + b_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.b) +} +inline void calibrationTable::_internal_add_b(float value) { + b_.Add(value); +} +inline void calibrationTable::add_b(float value) { + _internal_add_b(value); + // @@protoc_insertion_point(field_add:pb.calibrationTable.b) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::_internal_b() const { + return b_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::b() const { + // @@protoc_insertion_point(field_list:pb.calibrationTable.b) + return _internal_b(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::_internal_mutable_b() { + return &b_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::mutable_b() { + // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.b) + return _internal_mutable_b(); +} + +// repeated float c = 4 [packed = true]; +inline int calibrationTable::_internal_c_size() const { + return c_.size(); +} +inline int calibrationTable::c_size() const { + return _internal_c_size(); +} +inline void calibrationTable::clear_c() { + c_.Clear(); +} +inline float calibrationTable::_internal_c(int index) const { + return c_.Get(index); +} +inline float calibrationTable::c(int index) const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.c) + return _internal_c(index); +} +inline void calibrationTable::set_c(int index, float value) { + c_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.c) +} +inline void calibrationTable::_internal_add_c(float value) { + c_.Add(value); +} +inline void calibrationTable::add_c(float value) { + _internal_add_c(value); + // @@protoc_insertion_point(field_add:pb.calibrationTable.c) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::_internal_c() const { + return c_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::c() const { + // @@protoc_insertion_point(field_list:pb.calibrationTable.c) + return _internal_c(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::_internal_mutable_c() { + return &c_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::mutable_c() { + // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.c) + return _internal_mutable_c(); +} + +// repeated float d = 5 [packed = true]; +inline int calibrationTable::_internal_d_size() const { + return d_.size(); +} +inline int calibrationTable::d_size() const { + return _internal_d_size(); +} +inline void calibrationTable::clear_d() { + d_.Clear(); +} +inline float calibrationTable::_internal_d(int index) const { + return d_.Get(index); +} +inline float calibrationTable::d(int index) const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.d) + return _internal_d(index); +} +inline void calibrationTable::set_d(int index, float value) { + d_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.d) +} +inline void calibrationTable::_internal_add_d(float value) { + d_.Add(value); +} +inline void calibrationTable::add_d(float value) { + _internal_add_d(value); + // @@protoc_insertion_point(field_add:pb.calibrationTable.d) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::_internal_d() const { + return d_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +calibrationTable::d() const { + // @@protoc_insertion_point(field_list:pb.calibrationTable.d) + return _internal_d(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::_internal_mutable_d() { + return &d_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +calibrationTable::mutable_d() { + // @@protoc_insertion_point(field_mutable_list:pb.calibrationTable.d) + return _internal_mutable_d(); +} + +// optional uint32 spline_method = 6; +inline bool calibrationTable::_internal_has_spline_method() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool calibrationTable::has_spline_method() const { + return _internal_has_spline_method(); +} +inline void calibrationTable::clear_spline_method() { + spline_method_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 calibrationTable::_internal_spline_method() const { + return spline_method_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 calibrationTable::spline_method() const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.spline_method) + return _internal_spline_method(); +} +inline void calibrationTable::_internal_set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + spline_method_ = value; +} +inline void calibrationTable::set_spline_method(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_spline_method(value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.spline_method) +} + +// optional string caltype = 7; +inline bool calibrationTable::_internal_has_caltype() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool calibrationTable::has_caltype() const { + return _internal_has_caltype(); +} +inline void calibrationTable::clear_caltype() { + caltype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& calibrationTable::caltype() const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.caltype) + return _internal_caltype(); +} +inline void calibrationTable::set_caltype(const std::string& value) { + _internal_set_caltype(value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.caltype) +} +inline std::string* calibrationTable::mutable_caltype() { + // @@protoc_insertion_point(field_mutable:pb.calibrationTable.caltype) + return _internal_mutable_caltype(); +} +inline const std::string& calibrationTable::_internal_caltype() const { + return caltype_.Get(); +} +inline void calibrationTable::_internal_set_caltype(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + caltype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void calibrationTable::set_caltype(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + caltype_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.calibrationTable.caltype) +} +inline void calibrationTable::set_caltype(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + caltype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.calibrationTable.caltype) +} +inline void calibrationTable::set_caltype(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + caltype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.calibrationTable.caltype) +} +inline std::string* calibrationTable::_internal_mutable_caltype() { + _has_bits_[0] |= 0x00000001u; + return caltype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* calibrationTable::release_caltype() { + // @@protoc_insertion_point(field_release:pb.calibrationTable.caltype) + if (!_internal_has_caltype()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return caltype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void calibrationTable::set_allocated_caltype(std::string* caltype) { + if (caltype != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + caltype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), caltype, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.calibrationTable.caltype) +} + +// optional bool flag = 8; +inline bool calibrationTable::_internal_has_flag() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool calibrationTable::has_flag() const { + return _internal_has_flag(); +} +inline void calibrationTable::clear_flag() { + flag_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool calibrationTable::_internal_flag() const { + return flag_; +} +inline bool calibrationTable::flag() const { + // @@protoc_insertion_point(field_get:pb.calibrationTable.flag) + return _internal_flag(); +} +inline void calibrationTable::_internal_set_flag(bool value) { + _has_bits_[0] |= 0x00000004u; + flag_ = value; +} +inline void calibrationTable::set_flag(bool value) { + _internal_set_flag(value); + // @@protoc_insertion_point(field_set:pb.calibrationTable.flag) +} + +// ------------------------------------------------------------------- + +// biexpTrans + +// optional uint32 channelRange = 1; +inline bool biexpTrans::_internal_has_channelrange() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool biexpTrans::has_channelrange() const { + return _internal_has_channelrange(); +} +inline void biexpTrans::clear_channelrange() { + channelrange_ = 0u; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 biexpTrans::_internal_channelrange() const { + return channelrange_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 biexpTrans::channelrange() const { + // @@protoc_insertion_point(field_get:pb.biexpTrans.channelRange) + return _internal_channelrange(); +} +inline void biexpTrans::_internal_set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000001u; + channelrange_ = value; +} +inline void biexpTrans::set_channelrange(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_channelrange(value); + // @@protoc_insertion_point(field_set:pb.biexpTrans.channelRange) +} + +// optional float pos = 2; +inline bool biexpTrans::_internal_has_pos() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool biexpTrans::has_pos() const { + return _internal_has_pos(); +} +inline void biexpTrans::clear_pos() { + pos_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float biexpTrans::_internal_pos() const { + return pos_; +} +inline float biexpTrans::pos() const { + // @@protoc_insertion_point(field_get:pb.biexpTrans.pos) + return _internal_pos(); +} +inline void biexpTrans::_internal_set_pos(float value) { + _has_bits_[0] |= 0x00000002u; + pos_ = value; +} +inline void biexpTrans::set_pos(float value) { + _internal_set_pos(value); + // @@protoc_insertion_point(field_set:pb.biexpTrans.pos) +} + +// optional float neg = 3; +inline bool biexpTrans::_internal_has_neg() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool biexpTrans::has_neg() const { + return _internal_has_neg(); +} +inline void biexpTrans::clear_neg() { + neg_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float biexpTrans::_internal_neg() const { + return neg_; +} +inline float biexpTrans::neg() const { + // @@protoc_insertion_point(field_get:pb.biexpTrans.neg) + return _internal_neg(); +} +inline void biexpTrans::_internal_set_neg(float value) { + _has_bits_[0] |= 0x00000004u; + neg_ = value; +} +inline void biexpTrans::set_neg(float value) { + _internal_set_neg(value); + // @@protoc_insertion_point(field_set:pb.biexpTrans.neg) +} + +// optional float widthBasis = 4; +inline bool biexpTrans::_internal_has_widthbasis() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool biexpTrans::has_widthbasis() const { + return _internal_has_widthbasis(); +} +inline void biexpTrans::clear_widthbasis() { + widthbasis_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float biexpTrans::_internal_widthbasis() const { + return widthbasis_; +} +inline float biexpTrans::widthbasis() const { + // @@protoc_insertion_point(field_get:pb.biexpTrans.widthBasis) + return _internal_widthbasis(); +} +inline void biexpTrans::_internal_set_widthbasis(float value) { + _has_bits_[0] |= 0x00000008u; + widthbasis_ = value; +} +inline void biexpTrans::set_widthbasis(float value) { + _internal_set_widthbasis(value); + // @@protoc_insertion_point(field_set:pb.biexpTrans.widthBasis) +} + +// optional float maxValue = 5; +inline bool biexpTrans::_internal_has_maxvalue() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool biexpTrans::has_maxvalue() const { + return _internal_has_maxvalue(); +} +inline void biexpTrans::clear_maxvalue() { + maxvalue_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline float biexpTrans::_internal_maxvalue() const { + return maxvalue_; +} +inline float biexpTrans::maxvalue() const { + // @@protoc_insertion_point(field_get:pb.biexpTrans.maxValue) + return _internal_maxvalue(); +} +inline void biexpTrans::_internal_set_maxvalue(float value) { + _has_bits_[0] |= 0x00000010u; + maxvalue_ = value; +} +inline void biexpTrans::set_maxvalue(float value) { + _internal_set_maxvalue(value); + // @@protoc_insertion_point(field_set:pb.biexpTrans.maxValue) +} + +// ------------------------------------------------------------------- + +// fasinhTrans + +// optional float length = 1; +inline bool fasinhTrans::_internal_has_length() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool fasinhTrans::has_length() const { + return _internal_has_length(); +} +inline void fasinhTrans::clear_length() { + length_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float fasinhTrans::_internal_length() const { + return length_; +} +inline float fasinhTrans::length() const { + // @@protoc_insertion_point(field_get:pb.fasinhTrans.length) + return _internal_length(); +} +inline void fasinhTrans::_internal_set_length(float value) { + _has_bits_[0] |= 0x00000001u; + length_ = value; +} +inline void fasinhTrans::set_length(float value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:pb.fasinhTrans.length) +} + +// optional float maxRange = 2; +inline bool fasinhTrans::_internal_has_maxrange() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool fasinhTrans::has_maxrange() const { + return _internal_has_maxrange(); +} +inline void fasinhTrans::clear_maxrange() { + maxrange_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float fasinhTrans::_internal_maxrange() const { + return maxrange_; +} +inline float fasinhTrans::maxrange() const { + // @@protoc_insertion_point(field_get:pb.fasinhTrans.maxRange) + return _internal_maxrange(); +} +inline void fasinhTrans::_internal_set_maxrange(float value) { + _has_bits_[0] |= 0x00000002u; + maxrange_ = value; +} +inline void fasinhTrans::set_maxrange(float value) { + _internal_set_maxrange(value); + // @@protoc_insertion_point(field_set:pb.fasinhTrans.maxRange) +} + +// optional float T = 3; +inline bool fasinhTrans::_internal_has_t() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool fasinhTrans::has_t() const { + return _internal_has_t(); +} +inline void fasinhTrans::clear_t() { + t_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float fasinhTrans::_internal_t() const { + return t_; +} +inline float fasinhTrans::t() const { + // @@protoc_insertion_point(field_get:pb.fasinhTrans.T) + return _internal_t(); +} +inline void fasinhTrans::_internal_set_t(float value) { + _has_bits_[0] |= 0x00000004u; + t_ = value; +} +inline void fasinhTrans::set_t(float value) { + _internal_set_t(value); + // @@protoc_insertion_point(field_set:pb.fasinhTrans.T) +} + +// optional float A = 4; +inline bool fasinhTrans::_internal_has_a() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool fasinhTrans::has_a() const { + return _internal_has_a(); +} +inline void fasinhTrans::clear_a() { + a_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float fasinhTrans::_internal_a() const { + return a_; +} +inline float fasinhTrans::a() const { + // @@protoc_insertion_point(field_get:pb.fasinhTrans.A) + return _internal_a(); +} +inline void fasinhTrans::_internal_set_a(float value) { + _has_bits_[0] |= 0x00000008u; + a_ = value; +} +inline void fasinhTrans::set_a(float value) { + _internal_set_a(value); + // @@protoc_insertion_point(field_set:pb.fasinhTrans.A) +} + +// optional float M = 5; +inline bool fasinhTrans::_internal_has_m() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool fasinhTrans::has_m() const { + return _internal_has_m(); +} +inline void fasinhTrans::clear_m() { + m_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline float fasinhTrans::_internal_m() const { + return m_; +} +inline float fasinhTrans::m() const { + // @@protoc_insertion_point(field_get:pb.fasinhTrans.M) + return _internal_m(); +} +inline void fasinhTrans::_internal_set_m(float value) { + _has_bits_[0] |= 0x00000010u; + m_ = value; +} +inline void fasinhTrans::set_m(float value) { + _internal_set_m(value); + // @@protoc_insertion_point(field_set:pb.fasinhTrans.M) +} + +// ------------------------------------------------------------------- + +// scaleTrans + +// optional float scale_factor = 1; +inline bool scaleTrans::_internal_has_scale_factor() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool scaleTrans::has_scale_factor() const { + return _internal_has_scale_factor(); +} +inline void scaleTrans::clear_scale_factor() { + scale_factor_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float scaleTrans::_internal_scale_factor() const { + return scale_factor_; +} +inline float scaleTrans::scale_factor() const { + // @@protoc_insertion_point(field_get:pb.scaleTrans.scale_factor) + return _internal_scale_factor(); +} +inline void scaleTrans::_internal_set_scale_factor(float value) { + _has_bits_[0] |= 0x00000001u; + scale_factor_ = value; +} +inline void scaleTrans::set_scale_factor(float value) { + _internal_set_scale_factor(value); + // @@protoc_insertion_point(field_set:pb.scaleTrans.scale_factor) +} + +// optional float t_scale = 2; +inline bool scaleTrans::_internal_has_t_scale() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool scaleTrans::has_t_scale() const { + return _internal_has_t_scale(); +} +inline void scaleTrans::clear_t_scale() { + t_scale_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float scaleTrans::_internal_t_scale() const { + return t_scale_; +} +inline float scaleTrans::t_scale() const { + // @@protoc_insertion_point(field_get:pb.scaleTrans.t_scale) + return _internal_t_scale(); +} +inline void scaleTrans::_internal_set_t_scale(float value) { + _has_bits_[0] |= 0x00000002u; + t_scale_ = value; +} +inline void scaleTrans::set_t_scale(float value) { + _internal_set_t_scale(value); + // @@protoc_insertion_point(field_set:pb.scaleTrans.t_scale) +} + +// optional float r_scale = 3; +inline bool scaleTrans::_internal_has_r_scale() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool scaleTrans::has_r_scale() const { + return _internal_has_r_scale(); +} +inline void scaleTrans::clear_r_scale() { + r_scale_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float scaleTrans::_internal_r_scale() const { + return r_scale_; +} +inline float scaleTrans::r_scale() const { + // @@protoc_insertion_point(field_get:pb.scaleTrans.r_scale) + return _internal_r_scale(); +} +inline void scaleTrans::_internal_set_r_scale(float value) { + _has_bits_[0] |= 0x00000004u; + r_scale_ = value; +} +inline void scaleTrans::set_r_scale(float value) { + _internal_set_r_scale(value); + // @@protoc_insertion_point(field_set:pb.scaleTrans.r_scale) +} + +// ------------------------------------------------------------------- + +// flinTrans + +// optional float min = 1; +inline bool flinTrans::_internal_has_min() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool flinTrans::has_min() const { + return _internal_has_min(); +} +inline void flinTrans::clear_min() { + min_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float flinTrans::_internal_min() const { + return min_; +} +inline float flinTrans::min() const { + // @@protoc_insertion_point(field_get:pb.flinTrans.min) + return _internal_min(); +} +inline void flinTrans::_internal_set_min(float value) { + _has_bits_[0] |= 0x00000001u; + min_ = value; +} +inline void flinTrans::set_min(float value) { + _internal_set_min(value); + // @@protoc_insertion_point(field_set:pb.flinTrans.min) +} + +// optional float max = 2; +inline bool flinTrans::_internal_has_max() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool flinTrans::has_max() const { + return _internal_has_max(); +} +inline void flinTrans::clear_max() { + max_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float flinTrans::_internal_max() const { + return max_; +} +inline float flinTrans::max() const { + // @@protoc_insertion_point(field_get:pb.flinTrans.max) + return _internal_max(); +} +inline void flinTrans::_internal_set_max(float value) { + _has_bits_[0] |= 0x00000002u; + max_ = value; +} +inline void flinTrans::set_max(float value) { + _internal_set_max(value); + // @@protoc_insertion_point(field_set:pb.flinTrans.max) +} + +// ------------------------------------------------------------------- + +// logTrans + +// optional float offset = 1; +inline bool logTrans::_internal_has_offset() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool logTrans::has_offset() const { + return _internal_has_offset(); +} +inline void logTrans::clear_offset() { + offset_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float logTrans::_internal_offset() const { + return offset_; +} +inline float logTrans::offset() const { + // @@protoc_insertion_point(field_get:pb.logTrans.offset) + return _internal_offset(); +} +inline void logTrans::_internal_set_offset(float value) { + _has_bits_[0] |= 0x00000001u; + offset_ = value; +} +inline void logTrans::set_offset(float value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:pb.logTrans.offset) +} + +// optional float decade = 2; +inline bool logTrans::_internal_has_decade() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool logTrans::has_decade() const { + return _internal_has_decade(); +} +inline void logTrans::clear_decade() { + decade_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float logTrans::_internal_decade() const { + return decade_; +} +inline float logTrans::decade() const { + // @@protoc_insertion_point(field_get:pb.logTrans.decade) + return _internal_decade(); +} +inline void logTrans::_internal_set_decade(float value) { + _has_bits_[0] |= 0x00000002u; + decade_ = value; +} +inline void logTrans::set_decade(float value) { + _internal_set_decade(value); + // @@protoc_insertion_point(field_set:pb.logTrans.decade) +} + +// optional float T = 3; +inline bool logTrans::_internal_has_t() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool logTrans::has_t() const { + return _internal_has_t(); +} +inline void logTrans::clear_t() { + t_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float logTrans::_internal_t() const { + return t_; +} +inline float logTrans::t() const { + // @@protoc_insertion_point(field_get:pb.logTrans.T) + return _internal_t(); +} +inline void logTrans::_internal_set_t(float value) { + _has_bits_[0] |= 0x00000004u; + t_ = value; +} +inline void logTrans::set_t(float value) { + _internal_set_t(value); + // @@protoc_insertion_point(field_set:pb.logTrans.T) +} + +// optional float scale = 4; +inline bool logTrans::_internal_has_scale() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool logTrans::has_scale() const { + return _internal_has_scale(); +} +inline void logTrans::clear_scale() { + scale_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float logTrans::_internal_scale() const { + return scale_; +} +inline float logTrans::scale() const { + // @@protoc_insertion_point(field_get:pb.logTrans.scale) + return _internal_scale(); +} +inline void logTrans::_internal_set_scale(float value) { + _has_bits_[0] |= 0x00000008u; + scale_ = value; +} +inline void logTrans::set_scale(float value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:pb.logTrans.scale) +} + +// ------------------------------------------------------------------- + +// logGML2Trans + +// optional float T = 1; +inline bool logGML2Trans::_internal_has_t() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool logGML2Trans::has_t() const { + return _internal_has_t(); +} +inline void logGML2Trans::clear_t() { + t_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float logGML2Trans::_internal_t() const { + return t_; +} +inline float logGML2Trans::t() const { + // @@protoc_insertion_point(field_get:pb.logGML2Trans.T) + return _internal_t(); +} +inline void logGML2Trans::_internal_set_t(float value) { + _has_bits_[0] |= 0x00000001u; + t_ = value; +} +inline void logGML2Trans::set_t(float value) { + _internal_set_t(value); + // @@protoc_insertion_point(field_set:pb.logGML2Trans.T) +} + +// optional float M = 2; +inline bool logGML2Trans::_internal_has_m() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool logGML2Trans::has_m() const { + return _internal_has_m(); +} +inline void logGML2Trans::clear_m() { + m_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float logGML2Trans::_internal_m() const { + return m_; +} +inline float logGML2Trans::m() const { + // @@protoc_insertion_point(field_get:pb.logGML2Trans.M) + return _internal_m(); +} +inline void logGML2Trans::_internal_set_m(float value) { + _has_bits_[0] |= 0x00000002u; + m_ = value; +} +inline void logGML2Trans::set_m(float value) { + _internal_set_m(value); + // @@protoc_insertion_point(field_set:pb.logGML2Trans.M) +} + +// ------------------------------------------------------------------- + +// logicleTrans + +// optional float T = 1; +inline bool logicleTrans::_internal_has_t() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool logicleTrans::has_t() const { + return _internal_has_t(); +} +inline void logicleTrans::clear_t() { + t_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline float logicleTrans::_internal_t() const { + return t_; +} +inline float logicleTrans::t() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.T) + return _internal_t(); +} +inline void logicleTrans::_internal_set_t(float value) { + _has_bits_[0] |= 0x00000001u; + t_ = value; +} +inline void logicleTrans::set_t(float value) { + _internal_set_t(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.T) +} + +// optional float W = 2; +inline bool logicleTrans::_internal_has_w() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool logicleTrans::has_w() const { + return _internal_has_w(); +} +inline void logicleTrans::clear_w() { + w_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline float logicleTrans::_internal_w() const { + return w_; +} +inline float logicleTrans::w() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.W) + return _internal_w(); +} +inline void logicleTrans::_internal_set_w(float value) { + _has_bits_[0] |= 0x00000002u; + w_ = value; +} +inline void logicleTrans::set_w(float value) { + _internal_set_w(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.W) +} + +// optional float M = 3; +inline bool logicleTrans::_internal_has_m() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool logicleTrans::has_m() const { + return _internal_has_m(); +} +inline void logicleTrans::clear_m() { + m_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline float logicleTrans::_internal_m() const { + return m_; +} +inline float logicleTrans::m() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.M) + return _internal_m(); +} +inline void logicleTrans::_internal_set_m(float value) { + _has_bits_[0] |= 0x00000004u; + m_ = value; +} +inline void logicleTrans::set_m(float value) { + _internal_set_m(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.M) +} + +// optional float A = 4; +inline bool logicleTrans::_internal_has_a() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool logicleTrans::has_a() const { + return _internal_has_a(); +} +inline void logicleTrans::clear_a() { + a_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline float logicleTrans::_internal_a() const { + return a_; +} +inline float logicleTrans::a() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.A) + return _internal_a(); +} +inline void logicleTrans::_internal_set_a(float value) { + _has_bits_[0] |= 0x00000008u; + a_ = value; +} +inline void logicleTrans::set_a(float value) { + _internal_set_a(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.A) +} + +// optional float bins = 5; +inline bool logicleTrans::_internal_has_bins() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool logicleTrans::has_bins() const { + return _internal_has_bins(); +} +inline void logicleTrans::clear_bins() { + bins_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline float logicleTrans::_internal_bins() const { + return bins_; +} +inline float logicleTrans::bins() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.bins) + return _internal_bins(); +} +inline void logicleTrans::_internal_set_bins(float value) { + _has_bits_[0] |= 0x00000010u; + bins_ = value; +} +inline void logicleTrans::set_bins(float value) { + _internal_set_bins(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.bins) +} + +// optional bool isGml2 = 6; +inline bool logicleTrans::_internal_has_isgml2() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool logicleTrans::has_isgml2() const { + return _internal_has_isgml2(); +} +inline void logicleTrans::clear_isgml2() { + isgml2_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool logicleTrans::_internal_isgml2() const { + return isgml2_; +} +inline bool logicleTrans::isgml2() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.isGml2) + return _internal_isgml2(); +} +inline void logicleTrans::_internal_set_isgml2(bool value) { + _has_bits_[0] |= 0x00000020u; + isgml2_ = value; +} +inline void logicleTrans::set_isgml2(bool value) { + _internal_set_isgml2(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.isGml2) +} + +// optional bool isInverse = 7; +inline bool logicleTrans::_internal_has_isinverse() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool logicleTrans::has_isinverse() const { + return _internal_has_isinverse(); +} +inline void logicleTrans::clear_isinverse() { + isinverse_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool logicleTrans::_internal_isinverse() const { + return isinverse_; +} +inline bool logicleTrans::isinverse() const { + // @@protoc_insertion_point(field_get:pb.logicleTrans.isInverse) + return _internal_isinverse(); +} +inline void logicleTrans::_internal_set_isinverse(bool value) { + _has_bits_[0] |= 0x00000040u; + isinverse_ = value; +} +inline void logicleTrans::set_isinverse(bool value) { + _internal_set_isinverse(value); + // @@protoc_insertion_point(field_set:pb.logicleTrans.isInverse) +} + +// ------------------------------------------------------------------- + +// transformation + +// optional .pb.calibrationTable calTbl = 1; +inline bool transformation::_internal_has_caltbl() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || caltbl_ != nullptr); + return value; +} +inline bool transformation::has_caltbl() const { + return _internal_has_caltbl(); +} +inline void transformation::clear_caltbl() { + if (caltbl_ != nullptr) caltbl_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::pb::calibrationTable& transformation::_internal_caltbl() const { + const ::pb::calibrationTable* p = caltbl_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_calibrationTable_default_instance_); +} +inline const ::pb::calibrationTable& transformation::caltbl() const { + // @@protoc_insertion_point(field_get:pb.transformation.calTbl) + return _internal_caltbl(); +} +inline void transformation::unsafe_arena_set_allocated_caltbl( + ::pb::calibrationTable* caltbl) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(caltbl_); + } + caltbl_ = caltbl; + if (caltbl) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.calTbl) +} +inline ::pb::calibrationTable* transformation::release_caltbl() { + _has_bits_[0] &= ~0x00000004u; + ::pb::calibrationTable* temp = caltbl_; + caltbl_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::calibrationTable* transformation::unsafe_arena_release_caltbl() { + // @@protoc_insertion_point(field_release:pb.transformation.calTbl) + _has_bits_[0] &= ~0x00000004u; + ::pb::calibrationTable* temp = caltbl_; + caltbl_ = nullptr; + return temp; +} +inline ::pb::calibrationTable* transformation::_internal_mutable_caltbl() { + _has_bits_[0] |= 0x00000004u; + if (caltbl_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::calibrationTable>(GetArena()); + caltbl_ = p; + } + return caltbl_; +} +inline ::pb::calibrationTable* transformation::mutable_caltbl() { + // @@protoc_insertion_point(field_mutable:pb.transformation.calTbl) + return _internal_mutable_caltbl(); +} +inline void transformation::set_allocated_caltbl(::pb::calibrationTable* caltbl) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete caltbl_; + } + if (caltbl) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(caltbl); + if (message_arena != submessage_arena) { + caltbl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, caltbl, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + caltbl_ = caltbl; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.calTbl) +} + +// optional bool isGateOnly = 2; +inline bool transformation::_internal_has_isgateonly() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool transformation::has_isgateonly() const { + return _internal_has_isgateonly(); +} +inline void transformation::clear_isgateonly() { + isgateonly_ = false; + _has_bits_[0] &= ~0x00000800u; +} +inline bool transformation::_internal_isgateonly() const { + return isgateonly_; +} +inline bool transformation::isgateonly() const { + // @@protoc_insertion_point(field_get:pb.transformation.isGateOnly) + return _internal_isgateonly(); +} +inline void transformation::_internal_set_isgateonly(bool value) { + _has_bits_[0] |= 0x00000800u; + isgateonly_ = value; +} +inline void transformation::set_isgateonly(bool value) { + _internal_set_isgateonly(value); + // @@protoc_insertion_point(field_set:pb.transformation.isGateOnly) +} + +// optional string name = 4; +inline bool transformation::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool transformation::has_name() const { + return _internal_has_name(); +} +inline void transformation::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& transformation::name() const { + // @@protoc_insertion_point(field_get:pb.transformation.name) + return _internal_name(); +} +inline void transformation::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:pb.transformation.name) +} +inline std::string* transformation::mutable_name() { + // @@protoc_insertion_point(field_mutable:pb.transformation.name) + return _internal_mutable_name(); +} +inline const std::string& transformation::_internal_name() const { + return name_.Get(); +} +inline void transformation::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void transformation::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.transformation.name) +} +inline void transformation::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.transformation.name) +} +inline void transformation::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.transformation.name) +} +inline std::string* transformation::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* transformation::release_name() { + // @@protoc_insertion_point(field_release:pb.transformation.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void transformation::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.transformation.name) +} + +// optional string channel = 5; +inline bool transformation::_internal_has_channel() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool transformation::has_channel() const { + return _internal_has_channel(); +} +inline void transformation::clear_channel() { + channel_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& transformation::channel() const { + // @@protoc_insertion_point(field_get:pb.transformation.channel) + return _internal_channel(); +} +inline void transformation::set_channel(const std::string& value) { + _internal_set_channel(value); + // @@protoc_insertion_point(field_set:pb.transformation.channel) +} +inline std::string* transformation::mutable_channel() { + // @@protoc_insertion_point(field_mutable:pb.transformation.channel) + return _internal_mutable_channel(); +} +inline const std::string& transformation::_internal_channel() const { + return channel_.Get(); +} +inline void transformation::_internal_set_channel(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + channel_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void transformation::set_channel(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + channel_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.transformation.channel) +} +inline void transformation::set_channel(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + channel_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.transformation.channel) +} +inline void transformation::set_channel(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + channel_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.transformation.channel) +} +inline std::string* transformation::_internal_mutable_channel() { + _has_bits_[0] |= 0x00000002u; + return channel_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* transformation::release_channel() { + // @@protoc_insertion_point(field_release:pb.transformation.channel) + if (!_internal_has_channel()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return channel_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void transformation::set_allocated_channel(std::string* channel) { + if (channel != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + channel_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), channel, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.transformation.channel) +} + +// optional bool isComputed = 6; +inline bool transformation::_internal_has_iscomputed() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool transformation::has_iscomputed() const { + return _internal_has_iscomputed(); +} +inline void transformation::clear_iscomputed() { + iscomputed_ = false; + _has_bits_[0] &= ~0x00001000u; +} +inline bool transformation::_internal_iscomputed() const { + return iscomputed_; +} +inline bool transformation::iscomputed() const { + // @@protoc_insertion_point(field_get:pb.transformation.isComputed) + return _internal_iscomputed(); +} +inline void transformation::_internal_set_iscomputed(bool value) { + _has_bits_[0] |= 0x00001000u; + iscomputed_ = value; +} +inline void transformation::set_iscomputed(bool value) { + _internal_set_iscomputed(value); + // @@protoc_insertion_point(field_set:pb.transformation.isComputed) +} + +// optional uint32 type = 12; +inline bool transformation::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool transformation::has_type() const { + return _internal_has_type(); +} +inline void transformation::clear_type() { + type_ = 0u; + _has_bits_[0] &= ~0x00002000u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 transformation::_internal_type() const { + return type_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 transformation::type() const { + // @@protoc_insertion_point(field_get:pb.transformation.type) + return _internal_type(); +} +inline void transformation::_internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00002000u; + type_ = value; +} +inline void transformation::set_type(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:pb.transformation.type) +} + +// optional .pb.TRANS_TYPE trans_type = 3; +inline bool transformation::_internal_has_trans_type() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool transformation::has_trans_type() const { + return _internal_has_trans_type(); +} +inline void transformation::clear_trans_type() { + trans_type_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline ::pb::TRANS_TYPE transformation::_internal_trans_type() const { + return static_cast< ::pb::TRANS_TYPE >(trans_type_); +} +inline ::pb::TRANS_TYPE transformation::trans_type() const { + // @@protoc_insertion_point(field_get:pb.transformation.trans_type) + return _internal_trans_type(); +} +inline void transformation::_internal_set_trans_type(::pb::TRANS_TYPE value) { + assert(::pb::TRANS_TYPE_IsValid(value)); + _has_bits_[0] |= 0x00000400u; + trans_type_ = value; +} +inline void transformation::set_trans_type(::pb::TRANS_TYPE value) { + _internal_set_trans_type(value); + // @@protoc_insertion_point(field_set:pb.transformation.trans_type) +} + +// optional .pb.biexpTrans bt = 7; +inline bool transformation::_internal_has_bt() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || bt_ != nullptr); + return value; +} +inline bool transformation::has_bt() const { + return _internal_has_bt(); +} +inline void transformation::clear_bt() { + if (bt_ != nullptr) bt_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::pb::biexpTrans& transformation::_internal_bt() const { + const ::pb::biexpTrans* p = bt_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_biexpTrans_default_instance_); +} +inline const ::pb::biexpTrans& transformation::bt() const { + // @@protoc_insertion_point(field_get:pb.transformation.bt) + return _internal_bt(); +} +inline void transformation::unsafe_arena_set_allocated_bt( + ::pb::biexpTrans* bt) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bt_); + } + bt_ = bt; + if (bt) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.bt) +} +inline ::pb::biexpTrans* transformation::release_bt() { + _has_bits_[0] &= ~0x00000008u; + ::pb::biexpTrans* temp = bt_; + bt_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::biexpTrans* transformation::unsafe_arena_release_bt() { + // @@protoc_insertion_point(field_release:pb.transformation.bt) + _has_bits_[0] &= ~0x00000008u; + ::pb::biexpTrans* temp = bt_; + bt_ = nullptr; + return temp; +} +inline ::pb::biexpTrans* transformation::_internal_mutable_bt() { + _has_bits_[0] |= 0x00000008u; + if (bt_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::biexpTrans>(GetArena()); + bt_ = p; + } + return bt_; +} +inline ::pb::biexpTrans* transformation::mutable_bt() { + // @@protoc_insertion_point(field_mutable:pb.transformation.bt) + return _internal_mutable_bt(); +} +inline void transformation::set_allocated_bt(::pb::biexpTrans* bt) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete bt_; + } + if (bt) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bt); + if (message_arena != submessage_arena) { + bt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bt, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + bt_ = bt; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.bt) +} + +// optional .pb.logTrans lt = 8; +inline bool transformation::_internal_has_lt() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || lt_ != nullptr); + return value; +} +inline bool transformation::has_lt() const { + return _internal_has_lt(); +} +inline void transformation::clear_lt() { + if (lt_ != nullptr) lt_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::pb::logTrans& transformation::_internal_lt() const { + const ::pb::logTrans* p = lt_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_logTrans_default_instance_); +} +inline const ::pb::logTrans& transformation::lt() const { + // @@protoc_insertion_point(field_get:pb.transformation.lt) + return _internal_lt(); +} +inline void transformation::unsafe_arena_set_allocated_lt( + ::pb::logTrans* lt) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lt_); + } + lt_ = lt; + if (lt) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.lt) +} +inline ::pb::logTrans* transformation::release_lt() { + _has_bits_[0] &= ~0x00000010u; + ::pb::logTrans* temp = lt_; + lt_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::logTrans* transformation::unsafe_arena_release_lt() { + // @@protoc_insertion_point(field_release:pb.transformation.lt) + _has_bits_[0] &= ~0x00000010u; + ::pb::logTrans* temp = lt_; + lt_ = nullptr; + return temp; +} +inline ::pb::logTrans* transformation::_internal_mutable_lt() { + _has_bits_[0] |= 0x00000010u; + if (lt_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::logTrans>(GetArena()); + lt_ = p; + } + return lt_; +} +inline ::pb::logTrans* transformation::mutable_lt() { + // @@protoc_insertion_point(field_mutable:pb.transformation.lt) + return _internal_mutable_lt(); +} +inline void transformation::set_allocated_lt(::pb::logTrans* lt) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete lt_; + } + if (lt) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lt); + if (message_arena != submessage_arena) { + lt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lt, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + lt_ = lt; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.lt) +} + +// optional .pb.flinTrans flt = 9; +inline bool transformation::_internal_has_flt() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || flt_ != nullptr); + return value; +} +inline bool transformation::has_flt() const { + return _internal_has_flt(); +} +inline void transformation::clear_flt() { + if (flt_ != nullptr) flt_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::pb::flinTrans& transformation::_internal_flt() const { + const ::pb::flinTrans* p = flt_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_flinTrans_default_instance_); +} +inline const ::pb::flinTrans& transformation::flt() const { + // @@protoc_insertion_point(field_get:pb.transformation.flt) + return _internal_flt(); +} +inline void transformation::unsafe_arena_set_allocated_flt( + ::pb::flinTrans* flt) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flt_); + } + flt_ = flt; + if (flt) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.flt) +} +inline ::pb::flinTrans* transformation::release_flt() { + _has_bits_[0] &= ~0x00000020u; + ::pb::flinTrans* temp = flt_; + flt_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::flinTrans* transformation::unsafe_arena_release_flt() { + // @@protoc_insertion_point(field_release:pb.transformation.flt) + _has_bits_[0] &= ~0x00000020u; + ::pb::flinTrans* temp = flt_; + flt_ = nullptr; + return temp; +} +inline ::pb::flinTrans* transformation::_internal_mutable_flt() { + _has_bits_[0] |= 0x00000020u; + if (flt_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::flinTrans>(GetArena()); + flt_ = p; + } + return flt_; +} +inline ::pb::flinTrans* transformation::mutable_flt() { + // @@protoc_insertion_point(field_mutable:pb.transformation.flt) + return _internal_mutable_flt(); +} +inline void transformation::set_allocated_flt(::pb::flinTrans* flt) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete flt_; + } + if (flt) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(flt); + if (message_arena != submessage_arena) { + flt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, flt, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + flt_ = flt; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.flt) +} + +// optional .pb.scaleTrans st = 10; +inline bool transformation::_internal_has_st() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || st_ != nullptr); + return value; +} +inline bool transformation::has_st() const { + return _internal_has_st(); +} +inline void transformation::clear_st() { + if (st_ != nullptr) st_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::pb::scaleTrans& transformation::_internal_st() const { + const ::pb::scaleTrans* p = st_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_scaleTrans_default_instance_); +} +inline const ::pb::scaleTrans& transformation::st() const { + // @@protoc_insertion_point(field_get:pb.transformation.st) + return _internal_st(); +} +inline void transformation::unsafe_arena_set_allocated_st( + ::pb::scaleTrans* st) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(st_); + } + st_ = st; + if (st) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.st) +} +inline ::pb::scaleTrans* transformation::release_st() { + _has_bits_[0] &= ~0x00000040u; + ::pb::scaleTrans* temp = st_; + st_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::scaleTrans* transformation::unsafe_arena_release_st() { + // @@protoc_insertion_point(field_release:pb.transformation.st) + _has_bits_[0] &= ~0x00000040u; + ::pb::scaleTrans* temp = st_; + st_ = nullptr; + return temp; +} +inline ::pb::scaleTrans* transformation::_internal_mutable_st() { + _has_bits_[0] |= 0x00000040u; + if (st_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::scaleTrans>(GetArena()); + st_ = p; + } + return st_; +} +inline ::pb::scaleTrans* transformation::mutable_st() { + // @@protoc_insertion_point(field_mutable:pb.transformation.st) + return _internal_mutable_st(); +} +inline void transformation::set_allocated_st(::pb::scaleTrans* st) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete st_; + } + if (st) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(st); + if (message_arena != submessage_arena) { + st = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, st, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + st_ = st; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.st) +} + +// optional .pb.fasinhTrans ft = 11; +inline bool transformation::_internal_has_ft() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || ft_ != nullptr); + return value; +} +inline bool transformation::has_ft() const { + return _internal_has_ft(); +} +inline void transformation::clear_ft() { + if (ft_ != nullptr) ft_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::pb::fasinhTrans& transformation::_internal_ft() const { + const ::pb::fasinhTrans* p = ft_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_fasinhTrans_default_instance_); +} +inline const ::pb::fasinhTrans& transformation::ft() const { + // @@protoc_insertion_point(field_get:pb.transformation.ft) + return _internal_ft(); +} +inline void transformation::unsafe_arena_set_allocated_ft( + ::pb::fasinhTrans* ft) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ft_); + } + ft_ = ft; + if (ft) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.ft) +} +inline ::pb::fasinhTrans* transformation::release_ft() { + _has_bits_[0] &= ~0x00000080u; + ::pb::fasinhTrans* temp = ft_; + ft_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::fasinhTrans* transformation::unsafe_arena_release_ft() { + // @@protoc_insertion_point(field_release:pb.transformation.ft) + _has_bits_[0] &= ~0x00000080u; + ::pb::fasinhTrans* temp = ft_; + ft_ = nullptr; + return temp; +} +inline ::pb::fasinhTrans* transformation::_internal_mutable_ft() { + _has_bits_[0] |= 0x00000080u; + if (ft_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::fasinhTrans>(GetArena()); + ft_ = p; + } + return ft_; +} +inline ::pb::fasinhTrans* transformation::mutable_ft() { + // @@protoc_insertion_point(field_mutable:pb.transformation.ft) + return _internal_mutable_ft(); +} +inline void transformation::set_allocated_ft(::pb::fasinhTrans* ft) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete ft_; + } + if (ft) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(ft); + if (message_arena != submessage_arena) { + ft = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, ft, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + ft_ = ft; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.ft) +} + +// optional .pb.logicleTrans lgt = 13; +inline bool transformation::_internal_has_lgt() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || lgt_ != nullptr); + return value; +} +inline bool transformation::has_lgt() const { + return _internal_has_lgt(); +} +inline void transformation::clear_lgt() { + if (lgt_ != nullptr) lgt_->Clear(); + _has_bits_[0] &= ~0x00000100u; +} +inline const ::pb::logicleTrans& transformation::_internal_lgt() const { + const ::pb::logicleTrans* p = lgt_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_logicleTrans_default_instance_); +} +inline const ::pb::logicleTrans& transformation::lgt() const { + // @@protoc_insertion_point(field_get:pb.transformation.lgt) + return _internal_lgt(); +} +inline void transformation::unsafe_arena_set_allocated_lgt( + ::pb::logicleTrans* lgt) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lgt_); + } + lgt_ = lgt; + if (lgt) { + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.lgt) +} +inline ::pb::logicleTrans* transformation::release_lgt() { + _has_bits_[0] &= ~0x00000100u; + ::pb::logicleTrans* temp = lgt_; + lgt_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::logicleTrans* transformation::unsafe_arena_release_lgt() { + // @@protoc_insertion_point(field_release:pb.transformation.lgt) + _has_bits_[0] &= ~0x00000100u; + ::pb::logicleTrans* temp = lgt_; + lgt_ = nullptr; + return temp; +} +inline ::pb::logicleTrans* transformation::_internal_mutable_lgt() { + _has_bits_[0] |= 0x00000100u; + if (lgt_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::logicleTrans>(GetArena()); + lgt_ = p; + } + return lgt_; +} +inline ::pb::logicleTrans* transformation::mutable_lgt() { + // @@protoc_insertion_point(field_mutable:pb.transformation.lgt) + return _internal_mutable_lgt(); +} +inline void transformation::set_allocated_lgt(::pb::logicleTrans* lgt) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete lgt_; + } + if (lgt) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lgt); + if (message_arena != submessage_arena) { + lgt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lgt, submessage_arena); + } + _has_bits_[0] |= 0x00000100u; + } else { + _has_bits_[0] &= ~0x00000100u; + } + lgt_ = lgt; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.lgt) +} + +// optional .pb.logGML2Trans lgml2t = 14; +inline bool transformation::_internal_has_lgml2t() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || lgml2t_ != nullptr); + return value; +} +inline bool transformation::has_lgml2t() const { + return _internal_has_lgml2t(); +} +inline void transformation::clear_lgml2t() { + if (lgml2t_ != nullptr) lgml2t_->Clear(); + _has_bits_[0] &= ~0x00000200u; +} +inline const ::pb::logGML2Trans& transformation::_internal_lgml2t() const { + const ::pb::logGML2Trans* p = lgml2t_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_logGML2Trans_default_instance_); +} +inline const ::pb::logGML2Trans& transformation::lgml2t() const { + // @@protoc_insertion_point(field_get:pb.transformation.lgml2t) + return _internal_lgml2t(); +} +inline void transformation::unsafe_arena_set_allocated_lgml2t( + ::pb::logGML2Trans* lgml2t) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lgml2t_); + } + lgml2t_ = lgml2t; + if (lgml2t) { + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.transformation.lgml2t) +} +inline ::pb::logGML2Trans* transformation::release_lgml2t() { + _has_bits_[0] &= ~0x00000200u; + ::pb::logGML2Trans* temp = lgml2t_; + lgml2t_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::logGML2Trans* transformation::unsafe_arena_release_lgml2t() { + // @@protoc_insertion_point(field_release:pb.transformation.lgml2t) + _has_bits_[0] &= ~0x00000200u; + ::pb::logGML2Trans* temp = lgml2t_; + lgml2t_ = nullptr; + return temp; +} +inline ::pb::logGML2Trans* transformation::_internal_mutable_lgml2t() { + _has_bits_[0] |= 0x00000200u; + if (lgml2t_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::logGML2Trans>(GetArena()); + lgml2t_ = p; + } + return lgml2t_; +} +inline ::pb::logGML2Trans* transformation::mutable_lgml2t() { + // @@protoc_insertion_point(field_mutable:pb.transformation.lgml2t) + return _internal_mutable_lgml2t(); +} +inline void transformation::set_allocated_lgml2t(::pb::logGML2Trans* lgml2t) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete lgml2t_; + } + if (lgml2t) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lgml2t); + if (message_arena != submessage_arena) { + lgml2t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lgml2t, submessage_arena); + } + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + lgml2t_ = lgml2t; + // @@protoc_insertion_point(field_set_allocated:pb.transformation.lgml2t) +} + +// ------------------------------------------------------------------- + +// trans_pair + +// required string name = 1; +inline bool trans_pair::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool trans_pair::has_name() const { + return _internal_has_name(); +} +inline void trans_pair::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& trans_pair::name() const { + // @@protoc_insertion_point(field_get:pb.trans_pair.name) + return _internal_name(); +} +inline void trans_pair::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:pb.trans_pair.name) +} +inline std::string* trans_pair::mutable_name() { + // @@protoc_insertion_point(field_mutable:pb.trans_pair.name) + return _internal_mutable_name(); +} +inline const std::string& trans_pair::_internal_name() const { + return name_.Get(); +} +inline void trans_pair::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void trans_pair::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.trans_pair.name) +} +inline void trans_pair::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.trans_pair.name) +} +inline void trans_pair::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.trans_pair.name) +} +inline std::string* trans_pair::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* trans_pair::release_name() { + // @@protoc_insertion_point(field_release:pb.trans_pair.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void trans_pair::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.trans_pair.name) +} + +// optional uint64 trans_address = 2; +inline bool trans_pair::_internal_has_trans_address() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool trans_pair::has_trans_address() const { + return _internal_has_trans_address(); +} +inline void trans_pair::clear_trans_address() { + trans_address_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 trans_pair::_internal_trans_address() const { + return trans_address_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 trans_pair::trans_address() const { + // @@protoc_insertion_point(field_get:pb.trans_pair.trans_address) + return _internal_trans_address(); +} +inline void trans_pair::_internal_set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000004u; + trans_address_ = value; +} +inline void trans_pair::set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_trans_address(value); + // @@protoc_insertion_point(field_set:pb.trans_pair.trans_address) +} + +// optional .pb.transformation trans = 3; +inline bool trans_pair::_internal_has_trans() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || trans_ != nullptr); + return value; +} +inline bool trans_pair::has_trans() const { + return _internal_has_trans(); +} +inline void trans_pair::clear_trans() { + if (trans_ != nullptr) trans_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::pb::transformation& trans_pair::_internal_trans() const { + const ::pb::transformation* p = trans_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_transformation_default_instance_); +} +inline const ::pb::transformation& trans_pair::trans() const { + // @@protoc_insertion_point(field_get:pb.trans_pair.trans) + return _internal_trans(); +} +inline void trans_pair::unsafe_arena_set_allocated_trans( + ::pb::transformation* trans) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(trans_); + } + trans_ = trans; + if (trans) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.trans_pair.trans) +} +inline ::pb::transformation* trans_pair::release_trans() { + _has_bits_[0] &= ~0x00000002u; + ::pb::transformation* temp = trans_; + trans_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::transformation* trans_pair::unsafe_arena_release_trans() { + // @@protoc_insertion_point(field_release:pb.trans_pair.trans) + _has_bits_[0] &= ~0x00000002u; + ::pb::transformation* temp = trans_; + trans_ = nullptr; + return temp; +} +inline ::pb::transformation* trans_pair::_internal_mutable_trans() { + _has_bits_[0] |= 0x00000002u; + if (trans_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::transformation>(GetArena()); + trans_ = p; + } + return trans_; +} +inline ::pb::transformation* trans_pair::mutable_trans() { + // @@protoc_insertion_point(field_mutable:pb.trans_pair.trans) + return _internal_mutable_trans(); +} +inline void trans_pair::set_allocated_trans(::pb::transformation* trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete trans_; + } + if (trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(trans); + if (message_arena != submessage_arena) { + trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, trans, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + trans_ = trans; + // @@protoc_insertion_point(field_set_allocated:pb.trans_pair.trans) +} + +// ------------------------------------------------------------------- + +// trans_local + +// repeated .pb.trans_pair tp = 1; +inline int trans_local::_internal_tp_size() const { + return tp_.size(); +} +inline int trans_local::tp_size() const { + return _internal_tp_size(); +} +inline void trans_local::clear_tp() { + tp_.Clear(); +} +inline ::pb::trans_pair* trans_local::mutable_tp(int index) { + // @@protoc_insertion_point(field_mutable:pb.trans_local.tp) + return tp_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >* +trans_local::mutable_tp() { + // @@protoc_insertion_point(field_mutable_list:pb.trans_local.tp) + return &tp_; +} +inline const ::pb::trans_pair& trans_local::_internal_tp(int index) const { + return tp_.Get(index); +} +inline const ::pb::trans_pair& trans_local::tp(int index) const { + // @@protoc_insertion_point(field_get:pb.trans_local.tp) + return _internal_tp(index); +} +inline ::pb::trans_pair* trans_local::_internal_add_tp() { + return tp_.Add(); +} +inline ::pb::trans_pair* trans_local::add_tp() { + // @@protoc_insertion_point(field_add:pb.trans_local.tp) + return _internal_add_tp(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_pair >& +trans_local::tp() const { + // @@protoc_insertion_point(field_list:pb.trans_local.tp) + return tp_; +} + +// optional string groupName = 2; +inline bool trans_local::_internal_has_groupname() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool trans_local::has_groupname() const { + return _internal_has_groupname(); +} +inline void trans_local::clear_groupname() { + groupname_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& trans_local::groupname() const { + // @@protoc_insertion_point(field_get:pb.trans_local.groupName) + return _internal_groupname(); +} +inline void trans_local::set_groupname(const std::string& value) { + _internal_set_groupname(value); + // @@protoc_insertion_point(field_set:pb.trans_local.groupName) +} +inline std::string* trans_local::mutable_groupname() { + // @@protoc_insertion_point(field_mutable:pb.trans_local.groupName) + return _internal_mutable_groupname(); +} +inline const std::string& trans_local::_internal_groupname() const { + return groupname_.Get(); +} +inline void trans_local::_internal_set_groupname(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + groupname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void trans_local::set_groupname(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + groupname_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.trans_local.groupName) +} +inline void trans_local::set_groupname(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + groupname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.trans_local.groupName) +} +inline void trans_local::set_groupname(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + groupname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.trans_local.groupName) +} +inline std::string* trans_local::_internal_mutable_groupname() { + _has_bits_[0] |= 0x00000001u; + return groupname_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* trans_local::release_groupname() { + // @@protoc_insertion_point(field_release:pb.trans_local.groupName) + if (!_internal_has_groupname()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return groupname_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void trans_local::set_allocated_groupname(std::string* groupname) { + if (groupname != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + groupname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), groupname, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.trans_local.groupName) +} + +// repeated uint32 sampleIDs = 3 [packed = true]; +inline int trans_local::_internal_sampleids_size() const { + return sampleids_.size(); +} +inline int trans_local::sampleids_size() const { + return _internal_sampleids_size(); +} +inline void trans_local::clear_sampleids() { + sampleids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 trans_local::_internal_sampleids(int index) const { + return sampleids_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 trans_local::sampleids(int index) const { + // @@protoc_insertion_point(field_get:pb.trans_local.sampleIDs) + return _internal_sampleids(index); +} +inline void trans_local::set_sampleids(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + sampleids_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.trans_local.sampleIDs) +} +inline void trans_local::_internal_add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value) { + sampleids_.Add(value); +} +inline void trans_local::add_sampleids(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_sampleids(value); + // @@protoc_insertion_point(field_add:pb.trans_local.sampleIDs) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +trans_local::_internal_sampleids() const { + return sampleids_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +trans_local::sampleids() const { + // @@protoc_insertion_point(field_list:pb.trans_local.sampleIDs) + return _internal_sampleids(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +trans_local::_internal_mutable_sampleids() { + return &sampleids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +trans_local::mutable_sampleids() { + // @@protoc_insertion_point(field_mutable_list:pb.trans_local.sampleIDs) + return _internal_mutable_sampleids(); +} + +// ------------------------------------------------------------------- + +// POPINDICES + +// required uint32 nEvents = 1; +inline bool POPINDICES::_internal_has_nevents() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool POPINDICES::has_nevents() const { + return _internal_has_nevents(); +} +inline void POPINDICES::clear_nevents() { + nevents_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::_internal_nevents() const { + return nevents_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::nevents() const { + // @@protoc_insertion_point(field_get:pb.POPINDICES.nEvents) + return _internal_nevents(); +} +inline void POPINDICES::_internal_set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + nevents_ = value; +} +inline void POPINDICES::set_nevents(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_nevents(value); + // @@protoc_insertion_point(field_set:pb.POPINDICES.nEvents) +} + +// required .pb.ind_type indtype = 2; +inline bool POPINDICES::_internal_has_indtype() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool POPINDICES::has_indtype() const { + return _internal_has_indtype(); +} +inline void POPINDICES::clear_indtype() { + indtype_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::pb::ind_type POPINDICES::_internal_indtype() const { + return static_cast< ::pb::ind_type >(indtype_); +} +inline ::pb::ind_type POPINDICES::indtype() const { + // @@protoc_insertion_point(field_get:pb.POPINDICES.indtype) + return _internal_indtype(); +} +inline void POPINDICES::_internal_set_indtype(::pb::ind_type value) { + assert(::pb::ind_type_IsValid(value)); + _has_bits_[0] |= 0x00000004u; + indtype_ = value; +} +inline void POPINDICES::set_indtype(::pb::ind_type value) { + _internal_set_indtype(value); + // @@protoc_insertion_point(field_set:pb.POPINDICES.indtype) +} + +// repeated uint32 iInd = 3 [packed = true]; +inline int POPINDICES::_internal_iind_size() const { + return iind_.size(); +} +inline int POPINDICES::iind_size() const { + return _internal_iind_size(); +} +inline void POPINDICES::clear_iind() { + iind_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::_internal_iind(int index) const { + return iind_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 POPINDICES::iind(int index) const { + // @@protoc_insertion_point(field_get:pb.POPINDICES.iInd) + return _internal_iind(index); +} +inline void POPINDICES::set_iind(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + iind_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.POPINDICES.iInd) +} +inline void POPINDICES::_internal_add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value) { + iind_.Add(value); +} +inline void POPINDICES::add_iind(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_iind(value); + // @@protoc_insertion_point(field_add:pb.POPINDICES.iInd) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +POPINDICES::_internal_iind() const { + return iind_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +POPINDICES::iind() const { + // @@protoc_insertion_point(field_list:pb.POPINDICES.iInd) + return _internal_iind(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +POPINDICES::_internal_mutable_iind() { + return &iind_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +POPINDICES::mutable_iind() { + // @@protoc_insertion_point(field_mutable_list:pb.POPINDICES.iInd) + return _internal_mutable_iind(); +} + +// optional bytes bInd = 4; +inline bool POPINDICES::_internal_has_bind() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool POPINDICES::has_bind() const { + return _internal_has_bind(); +} +inline void POPINDICES::clear_bind() { + bind_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& POPINDICES::bind() const { + // @@protoc_insertion_point(field_get:pb.POPINDICES.bInd) + return _internal_bind(); +} +inline void POPINDICES::set_bind(const std::string& value) { + _internal_set_bind(value); + // @@protoc_insertion_point(field_set:pb.POPINDICES.bInd) +} +inline std::string* POPINDICES::mutable_bind() { + // @@protoc_insertion_point(field_mutable:pb.POPINDICES.bInd) + return _internal_mutable_bind(); +} +inline const std::string& POPINDICES::_internal_bind() const { + return bind_.Get(); +} +inline void POPINDICES::_internal_set_bind(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + bind_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void POPINDICES::set_bind(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + bind_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.POPINDICES.bInd) +} +inline void POPINDICES::set_bind(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + bind_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.POPINDICES.bInd) +} +inline void POPINDICES::set_bind(const void* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + bind_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.POPINDICES.bInd) +} +inline std::string* POPINDICES::_internal_mutable_bind() { + _has_bits_[0] |= 0x00000001u; + return bind_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* POPINDICES::release_bind() { + // @@protoc_insertion_point(field_release:pb.POPINDICES.bInd) + if (!_internal_has_bind()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return bind_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void POPINDICES::set_allocated_bind(std::string* bind) { + if (bind != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + bind_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bind, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.POPINDICES.bInd) +} + +// ------------------------------------------------------------------- + +// nodeProperties + +// required string thisName = 1; +inline bool nodeProperties::_internal_has_thisname() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool nodeProperties::has_thisname() const { + return _internal_has_thisname(); +} +inline void nodeProperties::clear_thisname() { + thisname_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& nodeProperties::thisname() const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.thisName) + return _internal_thisname(); +} +inline void nodeProperties::set_thisname(const std::string& value) { + _internal_set_thisname(value); + // @@protoc_insertion_point(field_set:pb.nodeProperties.thisName) +} +inline std::string* nodeProperties::mutable_thisname() { + // @@protoc_insertion_point(field_mutable:pb.nodeProperties.thisName) + return _internal_mutable_thisname(); +} +inline const std::string& nodeProperties::_internal_thisname() const { + return thisname_.Get(); +} +inline void nodeProperties::_internal_set_thisname(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + thisname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void nodeProperties::set_thisname(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + thisname_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.nodeProperties.thisName) +} +inline void nodeProperties::set_thisname(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + thisname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.nodeProperties.thisName) +} +inline void nodeProperties::set_thisname(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + thisname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.nodeProperties.thisName) +} +inline std::string* nodeProperties::_internal_mutable_thisname() { + _has_bits_[0] |= 0x00000001u; + return thisname_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* nodeProperties::release_thisname() { + // @@protoc_insertion_point(field_release:pb.nodeProperties.thisName) + if (!_internal_has_thisname()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return thisname_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void nodeProperties::set_allocated_thisname(std::string* thisname) { + if (thisname != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + thisname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), thisname, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.thisName) +} + +// repeated .pb.POPSTATS fjStats = 2; +inline int nodeProperties::_internal_fjstats_size() const { + return fjstats_.size(); +} +inline int nodeProperties::fjstats_size() const { + return _internal_fjstats_size(); +} +inline void nodeProperties::clear_fjstats() { + fjstats_.Clear(); +} +inline ::pb::POPSTATS* nodeProperties::mutable_fjstats(int index) { + // @@protoc_insertion_point(field_mutable:pb.nodeProperties.fjStats) + return fjstats_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >* +nodeProperties::mutable_fjstats() { + // @@protoc_insertion_point(field_mutable_list:pb.nodeProperties.fjStats) + return &fjstats_; +} +inline const ::pb::POPSTATS& nodeProperties::_internal_fjstats(int index) const { + return fjstats_.Get(index); +} +inline const ::pb::POPSTATS& nodeProperties::fjstats(int index) const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.fjStats) + return _internal_fjstats(index); +} +inline ::pb::POPSTATS* nodeProperties::_internal_add_fjstats() { + return fjstats_.Add(); +} +inline ::pb::POPSTATS* nodeProperties::add_fjstats() { + // @@protoc_insertion_point(field_add:pb.nodeProperties.fjStats) + return _internal_add_fjstats(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >& +nodeProperties::fjstats() const { + // @@protoc_insertion_point(field_list:pb.nodeProperties.fjStats) + return fjstats_; +} + +// repeated .pb.POPSTATS fcStats = 3; +inline int nodeProperties::_internal_fcstats_size() const { + return fcstats_.size(); +} +inline int nodeProperties::fcstats_size() const { + return _internal_fcstats_size(); +} +inline void nodeProperties::clear_fcstats() { + fcstats_.Clear(); +} +inline ::pb::POPSTATS* nodeProperties::mutable_fcstats(int index) { + // @@protoc_insertion_point(field_mutable:pb.nodeProperties.fcStats) + return fcstats_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >* +nodeProperties::mutable_fcstats() { + // @@protoc_insertion_point(field_mutable_list:pb.nodeProperties.fcStats) + return &fcstats_; +} +inline const ::pb::POPSTATS& nodeProperties::_internal_fcstats(int index) const { + return fcstats_.Get(index); +} +inline const ::pb::POPSTATS& nodeProperties::fcstats(int index) const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.fcStats) + return _internal_fcstats(index); +} +inline ::pb::POPSTATS* nodeProperties::_internal_add_fcstats() { + return fcstats_.Add(); +} +inline ::pb::POPSTATS* nodeProperties::add_fcstats() { + // @@protoc_insertion_point(field_add:pb.nodeProperties.fcStats) + return _internal_add_fcstats(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::POPSTATS >& +nodeProperties::fcstats() const { + // @@protoc_insertion_point(field_list:pb.nodeProperties.fcStats) + return fcstats_; +} + +// required bool hidden = 4; +inline bool nodeProperties::_internal_has_hidden() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool nodeProperties::has_hidden() const { + return _internal_has_hidden(); +} +inline void nodeProperties::clear_hidden() { + hidden_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool nodeProperties::_internal_hidden() const { + return hidden_; +} +inline bool nodeProperties::hidden() const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.hidden) + return _internal_hidden(); +} +inline void nodeProperties::_internal_set_hidden(bool value) { + _has_bits_[0] |= 0x00000008u; + hidden_ = value; +} +inline void nodeProperties::set_hidden(bool value) { + _internal_set_hidden(value); + // @@protoc_insertion_point(field_set:pb.nodeProperties.hidden) +} + +// optional .pb.POPINDICES indices = 5; +inline bool nodeProperties::_internal_has_indices() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || indices_ != nullptr); + return value; +} +inline bool nodeProperties::has_indices() const { + return _internal_has_indices(); +} +inline void nodeProperties::clear_indices() { + if (indices_ != nullptr) indices_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::pb::POPINDICES& nodeProperties::_internal_indices() const { + const ::pb::POPINDICES* p = indices_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_POPINDICES_default_instance_); +} +inline const ::pb::POPINDICES& nodeProperties::indices() const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.indices) + return _internal_indices(); +} +inline void nodeProperties::unsafe_arena_set_allocated_indices( + ::pb::POPINDICES* indices) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(indices_); + } + indices_ = indices; + if (indices) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.nodeProperties.indices) +} +inline ::pb::POPINDICES* nodeProperties::release_indices() { + _has_bits_[0] &= ~0x00000002u; + ::pb::POPINDICES* temp = indices_; + indices_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::POPINDICES* nodeProperties::unsafe_arena_release_indices() { + // @@protoc_insertion_point(field_release:pb.nodeProperties.indices) + _has_bits_[0] &= ~0x00000002u; + ::pb::POPINDICES* temp = indices_; + indices_ = nullptr; + return temp; +} +inline ::pb::POPINDICES* nodeProperties::_internal_mutable_indices() { + _has_bits_[0] |= 0x00000002u; + if (indices_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::POPINDICES>(GetArena()); + indices_ = p; + } + return indices_; +} +inline ::pb::POPINDICES* nodeProperties::mutable_indices() { + // @@protoc_insertion_point(field_mutable:pb.nodeProperties.indices) + return _internal_mutable_indices(); +} +inline void nodeProperties::set_allocated_indices(::pb::POPINDICES* indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete indices_; + } + if (indices) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(indices); + if (message_arena != submessage_arena) { + indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, indices, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + indices_ = indices; + // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.indices) +} + +// optional .pb.gate thisGate = 6; +inline bool nodeProperties::_internal_has_thisgate() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || thisgate_ != nullptr); + return value; +} +inline bool nodeProperties::has_thisgate() const { + return _internal_has_thisgate(); +} +inline void nodeProperties::clear_thisgate() { + if (thisgate_ != nullptr) thisgate_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::pb::gate& nodeProperties::_internal_thisgate() const { + const ::pb::gate* p = thisgate_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_gate_default_instance_); +} +inline const ::pb::gate& nodeProperties::thisgate() const { + // @@protoc_insertion_point(field_get:pb.nodeProperties.thisGate) + return _internal_thisgate(); +} +inline void nodeProperties::unsafe_arena_set_allocated_thisgate( + ::pb::gate* thisgate) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(thisgate_); + } + thisgate_ = thisgate; + if (thisgate) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.nodeProperties.thisGate) +} +inline ::pb::gate* nodeProperties::release_thisgate() { + _has_bits_[0] &= ~0x00000004u; + ::pb::gate* temp = thisgate_; + thisgate_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::gate* nodeProperties::unsafe_arena_release_thisgate() { + // @@protoc_insertion_point(field_release:pb.nodeProperties.thisGate) + _has_bits_[0] &= ~0x00000004u; + ::pb::gate* temp = thisgate_; + thisgate_ = nullptr; + return temp; +} +inline ::pb::gate* nodeProperties::_internal_mutable_thisgate() { + _has_bits_[0] |= 0x00000004u; + if (thisgate_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::gate>(GetArena()); + thisgate_ = p; + } + return thisgate_; +} +inline ::pb::gate* nodeProperties::mutable_thisgate() { + // @@protoc_insertion_point(field_mutable:pb.nodeProperties.thisGate) + return _internal_mutable_thisgate(); +} +inline void nodeProperties::set_allocated_thisgate(::pb::gate* thisgate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete thisgate_; + } + if (thisgate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(thisgate); + if (message_arena != submessage_arena) { + thisgate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, thisgate, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + thisgate_ = thisgate; + // @@protoc_insertion_point(field_set_allocated:pb.nodeProperties.thisGate) +} + +// ------------------------------------------------------------------- + +// treeNodes + +// required .pb.nodeProperties node = 1; +inline bool treeNodes::_internal_has_node() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || node_ != nullptr); + return value; +} +inline bool treeNodes::has_node() const { + return _internal_has_node(); +} +inline void treeNodes::clear_node() { + if (node_ != nullptr) node_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::nodeProperties& treeNodes::_internal_node() const { + const ::pb::nodeProperties* p = node_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_nodeProperties_default_instance_); +} +inline const ::pb::nodeProperties& treeNodes::node() const { + // @@protoc_insertion_point(field_get:pb.treeNodes.node) + return _internal_node(); +} +inline void treeNodes::unsafe_arena_set_allocated_node( + ::pb::nodeProperties* node) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_); + } + node_ = node; + if (node) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.treeNodes.node) +} +inline ::pb::nodeProperties* treeNodes::release_node() { + _has_bits_[0] &= ~0x00000001u; + ::pb::nodeProperties* temp = node_; + node_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::nodeProperties* treeNodes::unsafe_arena_release_node() { + // @@protoc_insertion_point(field_release:pb.treeNodes.node) + _has_bits_[0] &= ~0x00000001u; + ::pb::nodeProperties* temp = node_; + node_ = nullptr; + return temp; +} +inline ::pb::nodeProperties* treeNodes::_internal_mutable_node() { + _has_bits_[0] |= 0x00000001u; + if (node_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::nodeProperties>(GetArena()); + node_ = p; + } + return node_; +} +inline ::pb::nodeProperties* treeNodes::mutable_node() { + // @@protoc_insertion_point(field_mutable:pb.treeNodes.node) + return _internal_mutable_node(); +} +inline void treeNodes::set_allocated_node(::pb::nodeProperties* node) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete node_; + } + if (node) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(node); + if (message_arena != submessage_arena) { + node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, node, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + node_ = node; + // @@protoc_insertion_point(field_set_allocated:pb.treeNodes.node) +} + +// optional uint32 parent = 2; +inline bool treeNodes::_internal_has_parent() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool treeNodes::has_parent() const { + return _internal_has_parent(); +} +inline void treeNodes::clear_parent() { + parent_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 treeNodes::_internal_parent() const { + return parent_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 treeNodes::parent() const { + // @@protoc_insertion_point(field_get:pb.treeNodes.parent) + return _internal_parent(); +} +inline void treeNodes::_internal_set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + parent_ = value; +} +inline void treeNodes::set_parent(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_parent(value); + // @@protoc_insertion_point(field_set:pb.treeNodes.parent) +} + +// ------------------------------------------------------------------- + +// populationTree + +// repeated .pb.treeNodes node = 1; +inline int populationTree::_internal_node_size() const { + return node_.size(); +} +inline int populationTree::node_size() const { + return _internal_node_size(); +} +inline void populationTree::clear_node() { + node_.Clear(); +} +inline ::pb::treeNodes* populationTree::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:pb.populationTree.node) + return node_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >* +populationTree::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:pb.populationTree.node) + return &node_; +} +inline const ::pb::treeNodes& populationTree::_internal_node(int index) const { + return node_.Get(index); +} +inline const ::pb::treeNodes& populationTree::node(int index) const { + // @@protoc_insertion_point(field_get:pb.populationTree.node) + return _internal_node(index); +} +inline ::pb::treeNodes* populationTree::_internal_add_node() { + return node_.Add(); +} +inline ::pb::treeNodes* populationTree::add_node() { + // @@protoc_insertion_point(field_add:pb.populationTree.node) + return _internal_add_node(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::treeNodes >& +populationTree::node() const { + // @@protoc_insertion_point(field_list:pb.populationTree.node) + return node_; +} + +// ------------------------------------------------------------------- + +// COMP + +// optional string cid = 1; +inline bool COMP::_internal_has_cid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool COMP::has_cid() const { + return _internal_has_cid(); +} +inline void COMP::clear_cid() { + cid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& COMP::cid() const { + // @@protoc_insertion_point(field_get:pb.COMP.cid) + return _internal_cid(); +} +inline void COMP::set_cid(const std::string& value) { + _internal_set_cid(value); + // @@protoc_insertion_point(field_set:pb.COMP.cid) +} +inline std::string* COMP::mutable_cid() { + // @@protoc_insertion_point(field_mutable:pb.COMP.cid) + return _internal_mutable_cid(); +} +inline const std::string& COMP::_internal_cid() const { + return cid_.Get(); +} +inline void COMP::_internal_set_cid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + cid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void COMP::set_cid(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + cid_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.COMP.cid) +} +inline void COMP::set_cid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + cid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.COMP.cid) +} +inline void COMP::set_cid(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + cid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.cid) +} +inline std::string* COMP::_internal_mutable_cid() { + _has_bits_[0] |= 0x00000001u; + return cid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* COMP::release_cid() { + // @@protoc_insertion_point(field_release:pb.COMP.cid) + if (!_internal_has_cid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return cid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void COMP::set_allocated_cid(std::string* cid) { + if (cid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + cid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.COMP.cid) +} + +// optional string prefix = 2; +inline bool COMP::_internal_has_prefix() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool COMP::has_prefix() const { + return _internal_has_prefix(); +} +inline void COMP::clear_prefix() { + prefix_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& COMP::prefix() const { + // @@protoc_insertion_point(field_get:pb.COMP.prefix) + return _internal_prefix(); +} +inline void COMP::set_prefix(const std::string& value) { + _internal_set_prefix(value); + // @@protoc_insertion_point(field_set:pb.COMP.prefix) +} +inline std::string* COMP::mutable_prefix() { + // @@protoc_insertion_point(field_mutable:pb.COMP.prefix) + return _internal_mutable_prefix(); +} +inline const std::string& COMP::_internal_prefix() const { + return prefix_.Get(); +} +inline void COMP::_internal_set_prefix(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void COMP::set_prefix(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + prefix_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.COMP.prefix) +} +inline void COMP::set_prefix(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.COMP.prefix) +} +inline void COMP::set_prefix(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.prefix) +} +inline std::string* COMP::_internal_mutable_prefix() { + _has_bits_[0] |= 0x00000002u; + return prefix_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* COMP::release_prefix() { + // @@protoc_insertion_point(field_release:pb.COMP.prefix) + if (!_internal_has_prefix()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void COMP::set_allocated_prefix(std::string* prefix) { + if (prefix != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), prefix, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.COMP.prefix) +} + +// optional string suffix = 3; +inline bool COMP::_internal_has_suffix() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool COMP::has_suffix() const { + return _internal_has_suffix(); +} +inline void COMP::clear_suffix() { + suffix_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& COMP::suffix() const { + // @@protoc_insertion_point(field_get:pb.COMP.suffix) + return _internal_suffix(); +} +inline void COMP::set_suffix(const std::string& value) { + _internal_set_suffix(value); + // @@protoc_insertion_point(field_set:pb.COMP.suffix) +} +inline std::string* COMP::mutable_suffix() { + // @@protoc_insertion_point(field_mutable:pb.COMP.suffix) + return _internal_mutable_suffix(); +} +inline const std::string& COMP::_internal_suffix() const { + return suffix_.Get(); +} +inline void COMP::_internal_set_suffix(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + suffix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void COMP::set_suffix(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + suffix_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.COMP.suffix) +} +inline void COMP::set_suffix(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + suffix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.COMP.suffix) +} +inline void COMP::set_suffix(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + suffix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.suffix) +} +inline std::string* COMP::_internal_mutable_suffix() { + _has_bits_[0] |= 0x00000004u; + return suffix_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* COMP::release_suffix() { + // @@protoc_insertion_point(field_release:pb.COMP.suffix) + if (!_internal_has_suffix()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return suffix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void COMP::set_allocated_suffix(std::string* suffix) { + if (suffix != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + suffix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), suffix, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.COMP.suffix) +} + +// optional string name = 4; +inline bool COMP::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool COMP::has_name() const { + return _internal_has_name(); +} +inline void COMP::clear_name() { + name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& COMP::name() const { + // @@protoc_insertion_point(field_get:pb.COMP.name) + return _internal_name(); +} +inline void COMP::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:pb.COMP.name) +} +inline std::string* COMP::mutable_name() { + // @@protoc_insertion_point(field_mutable:pb.COMP.name) + return _internal_mutable_name(); +} +inline const std::string& COMP::_internal_name() const { + return name_.Get(); +} +inline void COMP::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void COMP::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + name_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.COMP.name) +} +inline void COMP::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.COMP.name) +} +inline void COMP::set_name(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000008u; + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.name) +} +inline std::string* COMP::_internal_mutable_name() { + _has_bits_[0] |= 0x00000008u; + return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* COMP::release_name() { + // @@protoc_insertion_point(field_release:pb.COMP.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void COMP::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.COMP.name) +} + +// optional string comment = 5; +inline bool COMP::_internal_has_comment() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool COMP::has_comment() const { + return _internal_has_comment(); +} +inline void COMP::clear_comment() { + comment_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& COMP::comment() const { + // @@protoc_insertion_point(field_get:pb.COMP.comment) + return _internal_comment(); +} +inline void COMP::set_comment(const std::string& value) { + _internal_set_comment(value); + // @@protoc_insertion_point(field_set:pb.COMP.comment) +} +inline std::string* COMP::mutable_comment() { + // @@protoc_insertion_point(field_mutable:pb.COMP.comment) + return _internal_mutable_comment(); +} +inline const std::string& COMP::_internal_comment() const { + return comment_.Get(); +} +inline void COMP::_internal_set_comment(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void COMP::set_comment(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + comment_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.COMP.comment) +} +inline void COMP::set_comment(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.COMP.comment) +} +inline void COMP::set_comment(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000010u; + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.comment) +} +inline std::string* COMP::_internal_mutable_comment() { + _has_bits_[0] |= 0x00000010u; + return comment_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* COMP::release_comment() { + // @@protoc_insertion_point(field_release:pb.COMP.comment) + if (!_internal_has_comment()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + return comment_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void COMP::set_allocated_comment(std::string* comment) { + if (comment != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + comment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.COMP.comment) +} + +// repeated string marker = 6; +inline int COMP::_internal_marker_size() const { + return marker_.size(); +} +inline int COMP::marker_size() const { + return _internal_marker_size(); +} +inline void COMP::clear_marker() { + marker_.Clear(); +} +inline std::string* COMP::add_marker() { + // @@protoc_insertion_point(field_add_mutable:pb.COMP.marker) + return _internal_add_marker(); +} +inline const std::string& COMP::_internal_marker(int index) const { + return marker_.Get(index); +} +inline const std::string& COMP::marker(int index) const { + // @@protoc_insertion_point(field_get:pb.COMP.marker) + return _internal_marker(index); +} +inline std::string* COMP::mutable_marker(int index) { + // @@protoc_insertion_point(field_mutable:pb.COMP.marker) + return marker_.Mutable(index); +} +inline void COMP::set_marker(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:pb.COMP.marker) + marker_.Mutable(index)->assign(value); +} +inline void COMP::set_marker(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:pb.COMP.marker) + marker_.Mutable(index)->assign(std::move(value)); +} +inline void COMP::set_marker(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + marker_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:pb.COMP.marker) +} +inline void COMP::set_marker(int index, const char* value, size_t size) { + marker_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:pb.COMP.marker) +} +inline std::string* COMP::_internal_add_marker() { + return marker_.Add(); +} +inline void COMP::add_marker(const std::string& value) { + marker_.Add()->assign(value); + // @@protoc_insertion_point(field_add:pb.COMP.marker) +} +inline void COMP::add_marker(std::string&& value) { + marker_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:pb.COMP.marker) +} +inline void COMP::add_marker(const char* value) { + GOOGLE_DCHECK(value != nullptr); + marker_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:pb.COMP.marker) +} +inline void COMP::add_marker(const char* value, size_t size) { + marker_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:pb.COMP.marker) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +COMP::marker() const { + // @@protoc_insertion_point(field_list:pb.COMP.marker) + return marker_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +COMP::mutable_marker() { + // @@protoc_insertion_point(field_mutable_list:pb.COMP.marker) + return &marker_; +} + +// repeated float spillOver = 7; +inline int COMP::_internal_spillover_size() const { + return spillover_.size(); +} +inline int COMP::spillover_size() const { + return _internal_spillover_size(); +} +inline void COMP::clear_spillover() { + spillover_.Clear(); +} +inline float COMP::_internal_spillover(int index) const { + return spillover_.Get(index); +} +inline float COMP::spillover(int index) const { + // @@protoc_insertion_point(field_get:pb.COMP.spillOver) + return _internal_spillover(index); +} +inline void COMP::set_spillover(int index, float value) { + spillover_.Set(index, value); + // @@protoc_insertion_point(field_set:pb.COMP.spillOver) +} +inline void COMP::_internal_add_spillover(float value) { + spillover_.Add(value); +} +inline void COMP::add_spillover(float value) { + _internal_add_spillover(value); + // @@protoc_insertion_point(field_add:pb.COMP.spillOver) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +COMP::_internal_spillover() const { + return spillover_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +COMP::spillover() const { + // @@protoc_insertion_point(field_list:pb.COMP.spillOver) + return _internal_spillover(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +COMP::_internal_mutable_spillover() { + return &spillover_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +COMP::mutable_spillover() { + // @@protoc_insertion_point(field_mutable_list:pb.COMP.spillOver) + return _internal_mutable_spillover(); +} + +// ------------------------------------------------------------------- + +// PARAM + +// optional string param = 1; +inline bool PARAM::_internal_has_param() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PARAM::has_param() const { + return _internal_has_param(); +} +inline void PARAM::clear_param() { + param_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PARAM::param() const { + // @@protoc_insertion_point(field_get:pb.PARAM.param) + return _internal_param(); +} +inline void PARAM::set_param(const std::string& value) { + _internal_set_param(value); + // @@protoc_insertion_point(field_set:pb.PARAM.param) +} +inline std::string* PARAM::mutable_param() { + // @@protoc_insertion_point(field_mutable:pb.PARAM.param) + return _internal_mutable_param(); +} +inline const std::string& PARAM::_internal_param() const { + return param_.Get(); +} +inline void PARAM::_internal_set_param(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void PARAM::set_param(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + param_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.PARAM.param) +} +inline void PARAM::set_param(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.PARAM.param) +} +inline void PARAM::set_param(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.PARAM.param) +} +inline std::string* PARAM::_internal_mutable_param() { + _has_bits_[0] |= 0x00000001u; + return param_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* PARAM::release_param() { + // @@protoc_insertion_point(field_release:pb.PARAM.param) + if (!_internal_has_param()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return param_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void PARAM::set_allocated_param(std::string* param) { + if (param != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + param_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.PARAM.param) +} + +// optional bool log = 2; +inline bool PARAM::_internal_has_log() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PARAM::has_log() const { + return _internal_has_log(); +} +inline void PARAM::clear_log() { + log_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool PARAM::_internal_log() const { + return log_; +} +inline bool PARAM::log() const { + // @@protoc_insertion_point(field_get:pb.PARAM.log) + return _internal_log(); +} +inline void PARAM::_internal_set_log(bool value) { + _has_bits_[0] |= 0x00000002u; + log_ = value; +} +inline void PARAM::set_log(bool value) { + _internal_set_log(value); + // @@protoc_insertion_point(field_set:pb.PARAM.log) +} + +// optional uint32 range = 3; +inline bool PARAM::_internal_has_range() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PARAM::has_range() const { + return _internal_has_range(); +} +inline void PARAM::clear_range() { + range_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::_internal_range() const { + return range_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::range() const { + // @@protoc_insertion_point(field_get:pb.PARAM.range) + return _internal_range(); +} +inline void PARAM::_internal_set_range(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + range_ = value; +} +inline void PARAM::set_range(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_range(value); + // @@protoc_insertion_point(field_set:pb.PARAM.range) +} + +// optional uint32 highValue = 4; +inline bool PARAM::_internal_has_highvalue() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PARAM::has_highvalue() const { + return _internal_has_highvalue(); +} +inline void PARAM::clear_highvalue() { + highvalue_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::_internal_highvalue() const { + return highvalue_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::highvalue() const { + // @@protoc_insertion_point(field_get:pb.PARAM.highValue) + return _internal_highvalue(); +} +inline void PARAM::_internal_set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + highvalue_ = value; +} +inline void PARAM::set_highvalue(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_highvalue(value); + // @@protoc_insertion_point(field_set:pb.PARAM.highValue) +} + +// optional uint32 calibrationIndex = 5; +inline bool PARAM::_internal_has_calibrationindex() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PARAM::has_calibrationindex() const { + return _internal_has_calibrationindex(); +} +inline void PARAM::clear_calibrationindex() { + calibrationindex_ = 0u; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::_internal_calibrationindex() const { + return calibrationindex_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 PARAM::calibrationindex() const { + // @@protoc_insertion_point(field_get:pb.PARAM.calibrationIndex) + return _internal_calibrationindex(); +} +inline void PARAM::_internal_set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000010u; + calibrationindex_ = value; +} +inline void PARAM::set_calibrationindex(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_calibrationindex(value); + // @@protoc_insertion_point(field_set:pb.PARAM.calibrationIndex) +} + +// ------------------------------------------------------------------- + +// GatingHierarchy + +// required .pb.populationTree tree = 2; +inline bool GatingHierarchy::_internal_has_tree() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || tree_ != nullptr); + return value; +} +inline bool GatingHierarchy::has_tree() const { + return _internal_has_tree(); +} +inline void GatingHierarchy::clear_tree() { + if (tree_ != nullptr) tree_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::pb::populationTree& GatingHierarchy::_internal_tree() const { + const ::pb::populationTree* p = tree_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_populationTree_default_instance_); +} +inline const ::pb::populationTree& GatingHierarchy::tree() const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.tree) + return _internal_tree(); +} +inline void GatingHierarchy::unsafe_arena_set_allocated_tree( + ::pb::populationTree* tree) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tree_); + } + tree_ = tree; + if (tree) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.GatingHierarchy.tree) +} +inline ::pb::populationTree* GatingHierarchy::release_tree() { + _has_bits_[0] &= ~0x00000002u; + ::pb::populationTree* temp = tree_; + tree_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::populationTree* GatingHierarchy::unsafe_arena_release_tree() { + // @@protoc_insertion_point(field_release:pb.GatingHierarchy.tree) + _has_bits_[0] &= ~0x00000002u; + ::pb::populationTree* temp = tree_; + tree_ = nullptr; + return temp; +} +inline ::pb::populationTree* GatingHierarchy::_internal_mutable_tree() { + _has_bits_[0] |= 0x00000002u; + if (tree_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::populationTree>(GetArena()); + tree_ = p; + } + return tree_; +} +inline ::pb::populationTree* GatingHierarchy::mutable_tree() { + // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.tree) + return _internal_mutable_tree(); +} +inline void GatingHierarchy::set_allocated_tree(::pb::populationTree* tree) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete tree_; + } + if (tree) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tree); + if (message_arena != submessage_arena) { + tree = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tree, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + tree_ = tree; + // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.tree) +} + +// optional .pb.COMP comp = 1; +inline bool GatingHierarchy::_internal_has_comp() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || comp_ != nullptr); + return value; +} +inline bool GatingHierarchy::has_comp() const { + return _internal_has_comp(); +} +inline void GatingHierarchy::clear_comp() { + if (comp_ != nullptr) comp_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::COMP& GatingHierarchy::_internal_comp() const { + const ::pb::COMP* p = comp_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_COMP_default_instance_); +} +inline const ::pb::COMP& GatingHierarchy::comp() const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.comp) + return _internal_comp(); +} +inline void GatingHierarchy::unsafe_arena_set_allocated_comp( + ::pb::COMP* comp) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(comp_); + } + comp_ = comp; + if (comp) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.GatingHierarchy.comp) +} +inline ::pb::COMP* GatingHierarchy::release_comp() { + _has_bits_[0] &= ~0x00000001u; + ::pb::COMP* temp = comp_; + comp_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::COMP* GatingHierarchy::unsafe_arena_release_comp() { + // @@protoc_insertion_point(field_release:pb.GatingHierarchy.comp) + _has_bits_[0] &= ~0x00000001u; + ::pb::COMP* temp = comp_; + comp_ = nullptr; + return temp; +} +inline ::pb::COMP* GatingHierarchy::_internal_mutable_comp() { + _has_bits_[0] |= 0x00000001u; + if (comp_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::COMP>(GetArena()); + comp_ = p; + } + return comp_; +} +inline ::pb::COMP* GatingHierarchy::mutable_comp() { + // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.comp) + return _internal_mutable_comp(); +} +inline void GatingHierarchy::set_allocated_comp(::pb::COMP* comp) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete comp_; + } + if (comp) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(comp); + if (message_arena != submessage_arena) { + comp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, comp, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + comp_ = comp; + // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.comp) +} + +// optional bool isLoaded = 3; +inline bool GatingHierarchy::_internal_has_isloaded() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool GatingHierarchy::has_isloaded() const { + return _internal_has_isloaded(); +} +inline void GatingHierarchy::clear_isloaded() { + isloaded_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool GatingHierarchy::_internal_isloaded() const { + return isloaded_; +} +inline bool GatingHierarchy::isloaded() const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.isLoaded) + return _internal_isloaded(); +} +inline void GatingHierarchy::_internal_set_isloaded(bool value) { + _has_bits_[0] |= 0x00000010u; + isloaded_ = value; +} +inline void GatingHierarchy::set_isloaded(bool value) { + _internal_set_isloaded(value); + // @@protoc_insertion_point(field_set:pb.GatingHierarchy.isLoaded) +} + +// repeated .pb.PARAM transFlag = 4; +inline int GatingHierarchy::_internal_transflag_size() const { + return transflag_.size(); +} +inline int GatingHierarchy::transflag_size() const { + return _internal_transflag_size(); +} +inline void GatingHierarchy::clear_transflag() { + transflag_.Clear(); +} +inline ::pb::PARAM* GatingHierarchy::mutable_transflag(int index) { + // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.transFlag) + return transflag_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >* +GatingHierarchy::mutable_transflag() { + // @@protoc_insertion_point(field_mutable_list:pb.GatingHierarchy.transFlag) + return &transflag_; +} +inline const ::pb::PARAM& GatingHierarchy::_internal_transflag(int index) const { + return transflag_.Get(index); +} +inline const ::pb::PARAM& GatingHierarchy::transflag(int index) const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.transFlag) + return _internal_transflag(index); +} +inline ::pb::PARAM* GatingHierarchy::_internal_add_transflag() { + return transflag_.Add(); +} +inline ::pb::PARAM* GatingHierarchy::add_transflag() { + // @@protoc_insertion_point(field_add:pb.GatingHierarchy.transFlag) + return _internal_add_transflag(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::PARAM >& +GatingHierarchy::transflag() const { + // @@protoc_insertion_point(field_list:pb.GatingHierarchy.transFlag) + return transflag_; +} + +// optional .pb.trans_local trans = 5; +inline bool GatingHierarchy::_internal_has_trans() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || trans_ != nullptr); + return value; +} +inline bool GatingHierarchy::has_trans() const { + return _internal_has_trans(); +} +inline void GatingHierarchy::clear_trans() { + if (trans_ != nullptr) trans_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::pb::trans_local& GatingHierarchy::_internal_trans() const { + const ::pb::trans_local* p = trans_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_trans_local_default_instance_); +} +inline const ::pb::trans_local& GatingHierarchy::trans() const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.trans) + return _internal_trans(); +} +inline void GatingHierarchy::unsafe_arena_set_allocated_trans( + ::pb::trans_local* trans) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(trans_); + } + trans_ = trans; + if (trans) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.GatingHierarchy.trans) +} +inline ::pb::trans_local* GatingHierarchy::release_trans() { + _has_bits_[0] &= ~0x00000004u; + ::pb::trans_local* temp = trans_; + trans_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::trans_local* GatingHierarchy::unsafe_arena_release_trans() { + // @@protoc_insertion_point(field_release:pb.GatingHierarchy.trans) + _has_bits_[0] &= ~0x00000004u; + ::pb::trans_local* temp = trans_; + trans_ = nullptr; + return temp; +} +inline ::pb::trans_local* GatingHierarchy::_internal_mutable_trans() { + _has_bits_[0] |= 0x00000004u; + if (trans_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::trans_local>(GetArena()); + trans_ = p; + } + return trans_; +} +inline ::pb::trans_local* GatingHierarchy::mutable_trans() { + // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.trans) + return _internal_mutable_trans(); +} +inline void GatingHierarchy::set_allocated_trans(::pb::trans_local* trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete trans_; + } + if (trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(trans); + if (message_arena != submessage_arena) { + trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, trans, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + trans_ = trans; + // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.trans) +} + +// optional .pb.CytoFrame frame = 6; +inline bool GatingHierarchy::_internal_has_frame() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || frame_ != nullptr); + return value; +} +inline bool GatingHierarchy::has_frame() const { + return _internal_has_frame(); +} +inline void GatingHierarchy::clear_frame() { + if (frame_ != nullptr) frame_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::pb::CytoFrame& GatingHierarchy::_internal_frame() const { + const ::pb::CytoFrame* p = frame_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_CytoFrame_default_instance_); +} +inline const ::pb::CytoFrame& GatingHierarchy::frame() const { + // @@protoc_insertion_point(field_get:pb.GatingHierarchy.frame) + return _internal_frame(); +} +inline void GatingHierarchy::unsafe_arena_set_allocated_frame( + ::pb::CytoFrame* frame) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(frame_); + } + frame_ = frame; + if (frame) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.GatingHierarchy.frame) +} +inline ::pb::CytoFrame* GatingHierarchy::release_frame() { + _has_bits_[0] &= ~0x00000008u; + ::pb::CytoFrame* temp = frame_; + frame_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::CytoFrame* GatingHierarchy::unsafe_arena_release_frame() { + // @@protoc_insertion_point(field_release:pb.GatingHierarchy.frame) + _has_bits_[0] &= ~0x00000008u; + ::pb::CytoFrame* temp = frame_; + frame_ = nullptr; + return temp; +} +inline ::pb::CytoFrame* GatingHierarchy::_internal_mutable_frame() { + _has_bits_[0] |= 0x00000008u; + if (frame_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::CytoFrame>(GetArena()); + frame_ = p; + } + return frame_; +} +inline ::pb::CytoFrame* GatingHierarchy::mutable_frame() { + // @@protoc_insertion_point(field_mutable:pb.GatingHierarchy.frame) + return _internal_mutable_frame(); +} +inline void GatingHierarchy::set_allocated_frame(::pb::CytoFrame* frame) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete frame_; + } + if (frame) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(frame); + if (message_arena != submessage_arena) { + frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, frame, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + frame_ = frame; + // @@protoc_insertion_point(field_set_allocated:pb.GatingHierarchy.frame) +} + +// ------------------------------------------------------------------- + +// CytoFrame + +// required bool is_h5 = 1; +inline bool CytoFrame::_internal_has_is_h5() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool CytoFrame::has_is_h5() const { + return _internal_has_is_h5(); +} +inline void CytoFrame::clear_is_h5() { + is_h5_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool CytoFrame::_internal_is_h5() const { + return is_h5_; +} +inline bool CytoFrame::is_h5() const { + // @@protoc_insertion_point(field_get:pb.CytoFrame.is_h5) + return _internal_is_h5(); +} +inline void CytoFrame::_internal_set_is_h5(bool value) { + _has_bits_[0] |= 0x00000001u; + is_h5_ = value; +} +inline void CytoFrame::set_is_h5(bool value) { + _internal_set_is_h5(value); + // @@protoc_insertion_point(field_set:pb.CytoFrame.is_h5) +} + +// ------------------------------------------------------------------- + +// TRANS_TBL + +// optional uint64 trans_address = 1; +inline bool TRANS_TBL::_internal_has_trans_address() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TRANS_TBL::has_trans_address() const { + return _internal_has_trans_address(); +} +inline void TRANS_TBL::clear_trans_address() { + trans_address_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 TRANS_TBL::_internal_trans_address() const { + return trans_address_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 TRANS_TBL::trans_address() const { + // @@protoc_insertion_point(field_get:pb.TRANS_TBL.trans_address) + return _internal_trans_address(); +} +inline void TRANS_TBL::_internal_set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000002u; + trans_address_ = value; +} +inline void TRANS_TBL::set_trans_address(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_trans_address(value); + // @@protoc_insertion_point(field_set:pb.TRANS_TBL.trans_address) +} + +// optional .pb.transformation trans = 2; +inline bool TRANS_TBL::_internal_has_trans() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || trans_ != nullptr); + return value; +} +inline bool TRANS_TBL::has_trans() const { + return _internal_has_trans(); +} +inline void TRANS_TBL::clear_trans() { + if (trans_ != nullptr) trans_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::pb::transformation& TRANS_TBL::_internal_trans() const { + const ::pb::transformation* p = trans_; + return p != nullptr ? *p : *reinterpret_cast( + &::pb::_transformation_default_instance_); +} +inline const ::pb::transformation& TRANS_TBL::trans() const { + // @@protoc_insertion_point(field_get:pb.TRANS_TBL.trans) + return _internal_trans(); +} +inline void TRANS_TBL::unsafe_arena_set_allocated_trans( + ::pb::transformation* trans) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(trans_); + } + trans_ = trans; + if (trans) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.TRANS_TBL.trans) +} +inline ::pb::transformation* TRANS_TBL::release_trans() { + _has_bits_[0] &= ~0x00000001u; + ::pb::transformation* temp = trans_; + trans_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::pb::transformation* TRANS_TBL::unsafe_arena_release_trans() { + // @@protoc_insertion_point(field_release:pb.TRANS_TBL.trans) + _has_bits_[0] &= ~0x00000001u; + ::pb::transformation* temp = trans_; + trans_ = nullptr; + return temp; +} +inline ::pb::transformation* TRANS_TBL::_internal_mutable_trans() { + _has_bits_[0] |= 0x00000001u; + if (trans_ == nullptr) { + auto* p = CreateMaybeMessage<::pb::transformation>(GetArena()); + trans_ = p; + } + return trans_; +} +inline ::pb::transformation* TRANS_TBL::mutable_trans() { + // @@protoc_insertion_point(field_mutable:pb.TRANS_TBL.trans) + return _internal_mutable_trans(); +} +inline void TRANS_TBL::set_allocated_trans(::pb::transformation* trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete trans_; + } + if (trans) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(trans); + if (message_arena != submessage_arena) { + trans = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, trans, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + trans_ = trans; + // @@protoc_insertion_point(field_set_allocated:pb.TRANS_TBL.trans) +} + +// ------------------------------------------------------------------- + +// GatingSet + +// repeated .pb.TRANS_TBL trans_tbl = 2; +inline int GatingSet::_internal_trans_tbl_size() const { + return trans_tbl_.size(); +} +inline int GatingSet::trans_tbl_size() const { + return _internal_trans_tbl_size(); +} +inline void GatingSet::clear_trans_tbl() { + trans_tbl_.Clear(); +} +inline ::pb::TRANS_TBL* GatingSet::mutable_trans_tbl(int index) { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.trans_tbl) + return trans_tbl_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >* +GatingSet::mutable_trans_tbl() { + // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.trans_tbl) + return &trans_tbl_; +} +inline const ::pb::TRANS_TBL& GatingSet::_internal_trans_tbl(int index) const { + return trans_tbl_.Get(index); +} +inline const ::pb::TRANS_TBL& GatingSet::trans_tbl(int index) const { + // @@protoc_insertion_point(field_get:pb.GatingSet.trans_tbl) + return _internal_trans_tbl(index); +} +inline ::pb::TRANS_TBL* GatingSet::_internal_add_trans_tbl() { + return trans_tbl_.Add(); +} +inline ::pb::TRANS_TBL* GatingSet::add_trans_tbl() { + // @@protoc_insertion_point(field_add:pb.GatingSet.trans_tbl) + return _internal_add_trans_tbl(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::TRANS_TBL >& +GatingSet::trans_tbl() const { + // @@protoc_insertion_point(field_list:pb.GatingSet.trans_tbl) + return trans_tbl_; +} + +// repeated string sampleName = 1; +inline int GatingSet::_internal_samplename_size() const { + return samplename_.size(); +} +inline int GatingSet::samplename_size() const { + return _internal_samplename_size(); +} +inline void GatingSet::clear_samplename() { + samplename_.Clear(); +} +inline std::string* GatingSet::add_samplename() { + // @@protoc_insertion_point(field_add_mutable:pb.GatingSet.sampleName) + return _internal_add_samplename(); +} +inline const std::string& GatingSet::_internal_samplename(int index) const { + return samplename_.Get(index); +} +inline const std::string& GatingSet::samplename(int index) const { + // @@protoc_insertion_point(field_get:pb.GatingSet.sampleName) + return _internal_samplename(index); +} +inline std::string* GatingSet::mutable_samplename(int index) { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.sampleName) + return samplename_.Mutable(index); +} +inline void GatingSet::set_samplename(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:pb.GatingSet.sampleName) + samplename_.Mutable(index)->assign(value); +} +inline void GatingSet::set_samplename(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:pb.GatingSet.sampleName) + samplename_.Mutable(index)->assign(std::move(value)); +} +inline void GatingSet::set_samplename(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + samplename_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:pb.GatingSet.sampleName) +} +inline void GatingSet::set_samplename(int index, const char* value, size_t size) { + samplename_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.sampleName) +} +inline std::string* GatingSet::_internal_add_samplename() { + return samplename_.Add(); +} +inline void GatingSet::add_samplename(const std::string& value) { + samplename_.Add()->assign(value); + // @@protoc_insertion_point(field_add:pb.GatingSet.sampleName) +} +inline void GatingSet::add_samplename(std::string&& value) { + samplename_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:pb.GatingSet.sampleName) +} +inline void GatingSet::add_samplename(const char* value) { + GOOGLE_DCHECK(value != nullptr); + samplename_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:pb.GatingSet.sampleName) +} +inline void GatingSet::add_samplename(const char* value, size_t size) { + samplename_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:pb.GatingSet.sampleName) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +GatingSet::samplename() const { + // @@protoc_insertion_point(field_list:pb.GatingSet.sampleName) + return samplename_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +GatingSet::mutable_samplename() { + // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.sampleName) + return &samplename_; +} + +// optional uint64 globalBiExpTrans = 3; +inline bool GatingSet::_internal_has_globalbiexptrans() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool GatingSet::has_globalbiexptrans() const { + return _internal_has_globalbiexptrans(); +} +inline void GatingSet::clear_globalbiexptrans() { + globalbiexptrans_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::_internal_globalbiexptrans() const { + return globalbiexptrans_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::globalbiexptrans() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.globalBiExpTrans) + return _internal_globalbiexptrans(); +} +inline void GatingSet::_internal_set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000010u; + globalbiexptrans_ = value; +} +inline void GatingSet::set_globalbiexptrans(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_globalbiexptrans(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.globalBiExpTrans) +} + +// optional uint64 globalLinTrans = 4; +inline bool GatingSet::_internal_has_globallintrans() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool GatingSet::has_globallintrans() const { + return _internal_has_globallintrans(); +} +inline void GatingSet::clear_globallintrans() { + globallintrans_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::_internal_globallintrans() const { + return globallintrans_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 GatingSet::globallintrans() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.globalLinTrans) + return _internal_globallintrans(); +} +inline void GatingSet::_internal_set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000020u; + globallintrans_ = value; +} +inline void GatingSet::set_globallintrans(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_globallintrans(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.globalLinTrans) +} + +// repeated .pb.trans_local gTrans = 5; +inline int GatingSet::_internal_gtrans_size() const { + return gtrans_.size(); +} +inline int GatingSet::gtrans_size() const { + return _internal_gtrans_size(); +} +inline void GatingSet::clear_gtrans() { + gtrans_.Clear(); +} +inline ::pb::trans_local* GatingSet::mutable_gtrans(int index) { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.gTrans) + return gtrans_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >* +GatingSet::mutable_gtrans() { + // @@protoc_insertion_point(field_mutable_list:pb.GatingSet.gTrans) + return >rans_; +} +inline const ::pb::trans_local& GatingSet::_internal_gtrans(int index) const { + return gtrans_.Get(index); +} +inline const ::pb::trans_local& GatingSet::gtrans(int index) const { + // @@protoc_insertion_point(field_get:pb.GatingSet.gTrans) + return _internal_gtrans(index); +} +inline ::pb::trans_local* GatingSet::_internal_add_gtrans() { + return gtrans_.Add(); +} +inline ::pb::trans_local* GatingSet::add_gtrans() { + // @@protoc_insertion_point(field_add:pb.GatingSet.gTrans) + return _internal_add_gtrans(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::trans_local >& +GatingSet::gtrans() const { + // @@protoc_insertion_point(field_list:pb.GatingSet.gTrans) + return gtrans_; +} + +// optional string guid = 6; +inline bool GatingSet::_internal_has_guid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool GatingSet::has_guid() const { + return _internal_has_guid(); +} +inline void GatingSet::clear_guid() { + guid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& GatingSet::guid() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.guid) + return _internal_guid(); +} +inline void GatingSet::set_guid(const std::string& value) { + _internal_set_guid(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.guid) +} +inline std::string* GatingSet::mutable_guid() { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.guid) + return _internal_mutable_guid(); +} +inline const std::string& GatingSet::_internal_guid() const { + return guid_.Get(); +} +inline void GatingSet::_internal_set_guid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + guid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void GatingSet::set_guid(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + guid_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.guid) +} +inline void GatingSet::set_guid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + guid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.GatingSet.guid) +} +inline void GatingSet::set_guid(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000001u; + guid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.guid) +} +inline std::string* GatingSet::_internal_mutable_guid() { + _has_bits_[0] |= 0x00000001u; + return guid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* GatingSet::release_guid() { + // @@protoc_insertion_point(field_release:pb.GatingSet.guid) + if (!_internal_has_guid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return guid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void GatingSet::set_allocated_guid(std::string* guid) { + if (guid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + guid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), guid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.guid) +} + +// optional string cytolib_verion = 7; +inline bool GatingSet::_internal_has_cytolib_verion() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool GatingSet::has_cytolib_verion() const { + return _internal_has_cytolib_verion(); +} +inline void GatingSet::clear_cytolib_verion() { + cytolib_verion_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& GatingSet::cytolib_verion() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.cytolib_verion) + return _internal_cytolib_verion(); +} +inline void GatingSet::set_cytolib_verion(const std::string& value) { + _internal_set_cytolib_verion(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.cytolib_verion) +} +inline std::string* GatingSet::mutable_cytolib_verion() { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.cytolib_verion) + return _internal_mutable_cytolib_verion(); +} +inline const std::string& GatingSet::_internal_cytolib_verion() const { + return cytolib_verion_.Get(); +} +inline void GatingSet::_internal_set_cytolib_verion(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + cytolib_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void GatingSet::set_cytolib_verion(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + cytolib_verion_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.cytolib_verion) +} +inline void GatingSet::set_cytolib_verion(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + cytolib_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.GatingSet.cytolib_verion) +} +inline void GatingSet::set_cytolib_verion(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000002u; + cytolib_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.cytolib_verion) +} +inline std::string* GatingSet::_internal_mutable_cytolib_verion() { + _has_bits_[0] |= 0x00000002u; + return cytolib_verion_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* GatingSet::release_cytolib_verion() { + // @@protoc_insertion_point(field_release:pb.GatingSet.cytolib_verion) + if (!_internal_has_cytolib_verion()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return cytolib_verion_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void GatingSet::set_allocated_cytolib_verion(std::string* cytolib_verion) { + if (cytolib_verion != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + cytolib_verion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cytolib_verion, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.cytolib_verion) +} + +// optional string pb_verion = 8; +inline bool GatingSet::_internal_has_pb_verion() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool GatingSet::has_pb_verion() const { + return _internal_has_pb_verion(); +} +inline void GatingSet::clear_pb_verion() { + pb_verion_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& GatingSet::pb_verion() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.pb_verion) + return _internal_pb_verion(); +} +inline void GatingSet::set_pb_verion(const std::string& value) { + _internal_set_pb_verion(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.pb_verion) +} +inline std::string* GatingSet::mutable_pb_verion() { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.pb_verion) + return _internal_mutable_pb_verion(); +} +inline const std::string& GatingSet::_internal_pb_verion() const { + return pb_verion_.Get(); +} +inline void GatingSet::_internal_set_pb_verion(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + pb_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void GatingSet::set_pb_verion(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + pb_verion_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.pb_verion) +} +inline void GatingSet::set_pb_verion(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + pb_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.GatingSet.pb_verion) +} +inline void GatingSet::set_pb_verion(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000004u; + pb_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.pb_verion) +} +inline std::string* GatingSet::_internal_mutable_pb_verion() { + _has_bits_[0] |= 0x00000004u; + return pb_verion_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* GatingSet::release_pb_verion() { + // @@protoc_insertion_point(field_release:pb.GatingSet.pb_verion) + if (!_internal_has_pb_verion()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return pb_verion_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void GatingSet::set_allocated_pb_verion(std::string* pb_verion) { + if (pb_verion != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + pb_verion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pb_verion, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.pb_verion) +} + +// optional string h5_verion = 9; +inline bool GatingSet::_internal_has_h5_verion() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool GatingSet::has_h5_verion() const { + return _internal_has_h5_verion(); +} +inline void GatingSet::clear_h5_verion() { + h5_verion_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& GatingSet::h5_verion() const { + // @@protoc_insertion_point(field_get:pb.GatingSet.h5_verion) + return _internal_h5_verion(); +} +inline void GatingSet::set_h5_verion(const std::string& value) { + _internal_set_h5_verion(value); + // @@protoc_insertion_point(field_set:pb.GatingSet.h5_verion) +} +inline std::string* GatingSet::mutable_h5_verion() { + // @@protoc_insertion_point(field_mutable:pb.GatingSet.h5_verion) + return _internal_mutable_h5_verion(); +} +inline const std::string& GatingSet::_internal_h5_verion() const { + return h5_verion_.Get(); +} +inline void GatingSet::_internal_set_h5_verion(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + h5_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); +} +inline void GatingSet::set_h5_verion(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + h5_verion_.Set( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:pb.GatingSet.h5_verion) +} +inline void GatingSet::set_h5_verion(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + h5_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value), + GetArena()); + // @@protoc_insertion_point(field_set_char:pb.GatingSet.h5_verion) +} +inline void GatingSet::set_h5_verion(const char* value, + size_t size) { + _has_bits_[0] |= 0x00000008u; + h5_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:pb.GatingSet.h5_verion) +} +inline std::string* GatingSet::_internal_mutable_h5_verion() { + _has_bits_[0] |= 0x00000008u; + return h5_verion_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline std::string* GatingSet::release_h5_verion() { + // @@protoc_insertion_point(field_release:pb.GatingSet.h5_verion) + if (!_internal_has_h5_verion()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return h5_verion_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void GatingSet::set_allocated_h5_verion(std::string* h5_verion) { + if (h5_verion != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + h5_verion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), h5_verion, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:pb.GatingSet.h5_verion) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace pb + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::pb::QUADRANT> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::QUADRANT>() { + return ::pb::QUADRANT_descriptor(); +} +template <> struct is_proto_enum< ::pb::GATE_TYPE> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::GATE_TYPE>() { + return ::pb::GATE_TYPE_descriptor(); +} +template <> struct is_proto_enum< ::pb::ind_type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::ind_type>() { + return ::pb::ind_type_descriptor(); +} +template <> struct is_proto_enum< ::pb::TRANS_TYPE> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::pb::TRANS_TYPE>() { + return ::pb::TRANS_TYPE_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_GatingSet_2eproto diff --git a/inst/include/generate_pb_code.sh b/inst/include/generate_pb_code.sh new file mode 100644 index 0000000..65c59f8 --- /dev/null +++ b/inst/include/generate_pb_code.sh @@ -0,0 +1,6 @@ +#generate pb code +protoc --cpp_out=cytolib/ GatingSet.proto +#move the source to src +mv cytolib/GatingSet.pb.cc ../../src/GatingSet_pb_lib/ +#update the include path to header +sed -i 's+"GatingSet.pb.h"++g' ../../src/GatingSet_pb_lib/GatingSet.pb.cc diff --git a/src/GatingSet_pb_lib/GatingSet.pb.cc b/src/GatingSet_pb_lib/GatingSet.pb.cc new file mode 100644 index 0000000..50b1b83 --- /dev/null +++ b/src/GatingSet_pb_lib/GatingSet.pb.cc @@ -0,0 +1,12657 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: GatingSet.proto + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BOOL_GATE_OP_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_COMP_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CytoFrame_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PARAM_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPINDICES_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPSTATS_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TRANS_TBL_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_biexpTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_boolGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_calibrationTable_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_clusterGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_coordinate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ellipseGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_fasinhTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_flinTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_gate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logGML2Trans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logicleTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_nodeProperties_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_paramPoly_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_paramRange_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_polygonGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_populationTree_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_quadGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_rangeGate_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_scaleTrans_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_local_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_pair_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<8> scc_info_transformation_GatingSet_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_GatingSet_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_treeNodes_GatingSet_2eproto; +namespace pb { +class paramRangeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _paramRange_default_instance_; +class rangeGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _rangeGate_default_instance_; +class paramPolyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _paramPoly_default_instance_; +class polygonGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _polygonGate_default_instance_; +class coordinateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _coordinate_default_instance_; +class ellipseGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ellipseGate_default_instance_; +class BOOL_GATE_OPDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BOOL_GATE_OP_default_instance_; +class boolGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _boolGate_default_instance_; +class clusterGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _clusterGate_default_instance_; +class quadGateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _quadGate_default_instance_; +class gateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _gate_default_instance_; +class POPSTATSDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _POPSTATS_default_instance_; +class calibrationTableDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _calibrationTable_default_instance_; +class biexpTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _biexpTrans_default_instance_; +class fasinhTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _fasinhTrans_default_instance_; +class scaleTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _scaleTrans_default_instance_; +class flinTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _flinTrans_default_instance_; +class logTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _logTrans_default_instance_; +class logGML2TransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _logGML2Trans_default_instance_; +class logicleTransDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _logicleTrans_default_instance_; +class transformationDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _transformation_default_instance_; +class trans_pairDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _trans_pair_default_instance_; +class trans_localDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _trans_local_default_instance_; +class POPINDICESDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _POPINDICES_default_instance_; +class nodePropertiesDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _nodeProperties_default_instance_; +class treeNodesDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _treeNodes_default_instance_; +class populationTreeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _populationTree_default_instance_; +class COMPDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _COMP_default_instance_; +class PARAMDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PARAM_default_instance_; +class GatingHierarchyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _GatingHierarchy_default_instance_; +class CytoFrameDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CytoFrame_default_instance_; +class TRANS_TBLDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TRANS_TBL_default_instance_; +class GatingSetDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _GatingSet_default_instance_; +} // namespace pb +static void InitDefaultsscc_info_BOOL_GATE_OP_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_BOOL_GATE_OP_default_instance_; + new (ptr) ::pb::BOOL_GATE_OP(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::BOOL_GATE_OP::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BOOL_GATE_OP_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_BOOL_GATE_OP_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_COMP_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_COMP_default_instance_; + new (ptr) ::pb::COMP(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::COMP::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_COMP_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_COMP_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_CytoFrame_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_CytoFrame_default_instance_; + new (ptr) ::pb::CytoFrame(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::CytoFrame::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CytoFrame_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CytoFrame_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_GatingHierarchy_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_GatingHierarchy_default_instance_; + new (ptr) ::pb::GatingHierarchy(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::GatingHierarchy::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_GatingHierarchy_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, 0, InitDefaultsscc_info_GatingHierarchy_GatingSet_2eproto}, { + &scc_info_populationTree_GatingSet_2eproto.base, + &scc_info_COMP_GatingSet_2eproto.base, + &scc_info_PARAM_GatingSet_2eproto.base, + &scc_info_trans_local_GatingSet_2eproto.base, + &scc_info_CytoFrame_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_GatingSet_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_GatingSet_default_instance_; + new (ptr) ::pb::GatingSet(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::GatingSet::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_GatingSet_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_GatingSet_GatingSet_2eproto}, { + &scc_info_TRANS_TBL_GatingSet_2eproto.base, + &scc_info_trans_local_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_PARAM_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_PARAM_default_instance_; + new (ptr) ::pb::PARAM(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::PARAM::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PARAM_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PARAM_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_POPINDICES_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_POPINDICES_default_instance_; + new (ptr) ::pb::POPINDICES(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::POPINDICES::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPINDICES_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_POPINDICES_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_POPSTATS_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_POPSTATS_default_instance_; + new (ptr) ::pb::POPSTATS(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::POPSTATS::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_POPSTATS_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_POPSTATS_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_TRANS_TBL_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_TRANS_TBL_default_instance_; + new (ptr) ::pb::TRANS_TBL(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::TRANS_TBL::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TRANS_TBL_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TRANS_TBL_GatingSet_2eproto}, { + &scc_info_transformation_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_biexpTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_biexpTrans_default_instance_; + new (ptr) ::pb::biexpTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::biexpTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_biexpTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_biexpTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_boolGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_boolGate_default_instance_; + new (ptr) ::pb::boolGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::boolGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_boolGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_boolGate_GatingSet_2eproto}, { + &scc_info_BOOL_GATE_OP_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_calibrationTable_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_calibrationTable_default_instance_; + new (ptr) ::pb::calibrationTable(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::calibrationTable::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_calibrationTable_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_calibrationTable_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_clusterGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_clusterGate_default_instance_; + new (ptr) ::pb::clusterGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::clusterGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_clusterGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_clusterGate_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_coordinate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_coordinate_default_instance_; + new (ptr) ::pb::coordinate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::coordinate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_coordinate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_coordinate_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_ellipseGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_ellipseGate_default_instance_; + new (ptr) ::pb::ellipseGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::ellipseGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ellipseGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ellipseGate_GatingSet_2eproto}, { + &scc_info_coordinate_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_fasinhTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_fasinhTrans_default_instance_; + new (ptr) ::pb::fasinhTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::fasinhTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_fasinhTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_fasinhTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_flinTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_flinTrans_default_instance_; + new (ptr) ::pb::flinTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::flinTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_flinTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_flinTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_gate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_gate_default_instance_; + new (ptr) ::pb::gate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::gate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<5> scc_info_gate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 5, 0, InitDefaultsscc_info_gate_GatingSet_2eproto}, { + &scc_info_rangeGate_GatingSet_2eproto.base, + &scc_info_polygonGate_GatingSet_2eproto.base, + &scc_info_ellipseGate_GatingSet_2eproto.base, + &scc_info_boolGate_GatingSet_2eproto.base, + &scc_info_clusterGate_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_logGML2Trans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_logGML2Trans_default_instance_; + new (ptr) ::pb::logGML2Trans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::logGML2Trans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logGML2Trans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_logGML2Trans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_logTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_logTrans_default_instance_; + new (ptr) ::pb::logTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::logTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_logTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_logicleTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_logicleTrans_default_instance_; + new (ptr) ::pb::logicleTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::logicleTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_logicleTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_logicleTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_nodeProperties_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_nodeProperties_default_instance_; + new (ptr) ::pb::nodeProperties(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::nodeProperties::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_nodeProperties_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_nodeProperties_GatingSet_2eproto}, { + &scc_info_POPSTATS_GatingSet_2eproto.base, + &scc_info_POPINDICES_GatingSet_2eproto.base, + &scc_info_gate_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_paramPoly_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_paramPoly_default_instance_; + new (ptr) ::pb::paramPoly(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::paramPoly::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_paramPoly_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_paramPoly_GatingSet_2eproto}, { + &scc_info_coordinate_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_paramRange_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_paramRange_default_instance_; + new (ptr) ::pb::paramRange(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::paramRange::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_paramRange_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_paramRange_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_polygonGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_polygonGate_default_instance_; + new (ptr) ::pb::polygonGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::polygonGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_polygonGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_polygonGate_GatingSet_2eproto}, { + &scc_info_paramPoly_GatingSet_2eproto.base, + &scc_info_quadGate_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_populationTree_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_populationTree_default_instance_; + new (ptr) ::pb::populationTree(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::populationTree::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_populationTree_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_populationTree_GatingSet_2eproto}, { + &scc_info_treeNodes_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_quadGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_quadGate_default_instance_; + new (ptr) ::pb::quadGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::quadGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_quadGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_quadGate_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_rangeGate_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_rangeGate_default_instance_; + new (ptr) ::pb::rangeGate(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::rangeGate::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_rangeGate_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_rangeGate_GatingSet_2eproto}, { + &scc_info_paramRange_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_scaleTrans_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_scaleTrans_default_instance_; + new (ptr) ::pb::scaleTrans(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::scaleTrans::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_scaleTrans_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_scaleTrans_GatingSet_2eproto}, {}}; + +static void InitDefaultsscc_info_trans_local_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_trans_local_default_instance_; + new (ptr) ::pb::trans_local(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::trans_local::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_local_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_trans_local_GatingSet_2eproto}, { + &scc_info_trans_pair_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_trans_pair_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_trans_pair_default_instance_; + new (ptr) ::pb::trans_pair(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::trans_pair::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_trans_pair_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_trans_pair_GatingSet_2eproto}, { + &scc_info_transformation_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_transformation_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_transformation_default_instance_; + new (ptr) ::pb::transformation(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::transformation::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<8> scc_info_transformation_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 8, 0, InitDefaultsscc_info_transformation_GatingSet_2eproto}, { + &scc_info_calibrationTable_GatingSet_2eproto.base, + &scc_info_biexpTrans_GatingSet_2eproto.base, + &scc_info_logTrans_GatingSet_2eproto.base, + &scc_info_flinTrans_GatingSet_2eproto.base, + &scc_info_scaleTrans_GatingSet_2eproto.base, + &scc_info_fasinhTrans_GatingSet_2eproto.base, + &scc_info_logicleTrans_GatingSet_2eproto.base, + &scc_info_logGML2Trans_GatingSet_2eproto.base,}}; + +static void InitDefaultsscc_info_treeNodes_GatingSet_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::pb::_treeNodes_default_instance_; + new (ptr) ::pb::treeNodes(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::pb::treeNodes::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_treeNodes_GatingSet_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_treeNodes_GatingSet_2eproto}, { + &scc_info_nodeProperties_GatingSet_2eproto.base,}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_GatingSet_2eproto[33]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_GatingSet_2eproto[4]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_GatingSet_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_GatingSet_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + PROTOBUF_FIELD_OFFSET(::pb::paramRange, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::paramRange, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::paramRange, name_), + PROTOBUF_FIELD_OFFSET(::pb::paramRange, min_), + PROTOBUF_FIELD_OFFSET(::pb::paramRange, max_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::pb::rangeGate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::rangeGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::rangeGate, param_), + 0, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::paramPoly, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::paramPoly, params_), + PROTOBUF_FIELD_OFFSET(::pb::paramPoly, vertices_), + PROTOBUF_FIELD_OFFSET(::pb::polygonGate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::polygonGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::polygonGate, param_), + PROTOBUF_FIELD_OFFSET(::pb::polygonGate, qg_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::coordinate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::coordinate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::coordinate, x_), + PROTOBUF_FIELD_OFFSET(::pb::coordinate, y_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, mu_), + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, cov_), + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, antipodal_vertices_), + PROTOBUF_FIELD_OFFSET(::pb::ellipseGate, dist_), + 0, + ~0u, + ~0u, + 1, + PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, path_), + PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, op_), + PROTOBUF_FIELD_OFFSET(::pb::BOOL_GATE_OP, isnot_), + ~0u, + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::boolGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::boolGate, boolopspec_), + PROTOBUF_FIELD_OFFSET(::pb::clusterGate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::clusterGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::clusterGate, cluster_method_), + 0, + PROTOBUF_FIELD_OFFSET(::pb::quadGate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::quadGate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::quadGate, uid_), + PROTOBUF_FIELD_OFFSET(::pb::quadGate, quadrant_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::gate, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::gate, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::gate, neg_), + PROTOBUF_FIELD_OFFSET(::pb::gate, istransformed_), + PROTOBUF_FIELD_OFFSET(::pb::gate, isgained_), + PROTOBUF_FIELD_OFFSET(::pb::gate, type_), + PROTOBUF_FIELD_OFFSET(::pb::gate, rg_), + PROTOBUF_FIELD_OFFSET(::pb::gate, pg_), + PROTOBUF_FIELD_OFFSET(::pb::gate, eg_), + PROTOBUF_FIELD_OFFSET(::pb::gate, bg_), + PROTOBUF_FIELD_OFFSET(::pb::gate, cg_), + 5, + 6, + 7, + 8, + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, stattype_), + PROTOBUF_FIELD_OFFSET(::pb::POPSTATS, statval_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, x_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, y_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, b_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, c_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, d_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, spline_method_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, caltype_), + PROTOBUF_FIELD_OFFSET(::pb::calibrationTable, flag_), + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 1, + 0, + 2, + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, channelrange_), + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, pos_), + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, neg_), + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, widthbasis_), + PROTOBUF_FIELD_OFFSET(::pb::biexpTrans, maxvalue_), + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, length_), + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, maxrange_), + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, t_), + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, a_), + PROTOBUF_FIELD_OFFSET(::pb::fasinhTrans, m_), + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, scale_factor_), + PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, t_scale_), + PROTOBUF_FIELD_OFFSET(::pb::scaleTrans, r_scale_), + 0, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::pb::flinTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::flinTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::flinTrans, min_), + PROTOBUF_FIELD_OFFSET(::pb::flinTrans, max_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::logTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::logTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::logTrans, offset_), + PROTOBUF_FIELD_OFFSET(::pb::logTrans, decade_), + PROTOBUF_FIELD_OFFSET(::pb::logTrans, t_), + PROTOBUF_FIELD_OFFSET(::pb::logTrans, scale_), + 0, + 1, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, t_), + PROTOBUF_FIELD_OFFSET(::pb::logGML2Trans, m_), + 0, + 1, + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, t_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, w_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, m_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, a_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, bins_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, isgml2_), + PROTOBUF_FIELD_OFFSET(::pb::logicleTrans, isinverse_), + 0, + 1, + 2, + 3, + 4, + 5, + 6, + PROTOBUF_FIELD_OFFSET(::pb::transformation, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::transformation, caltbl_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, isgateonly_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, name_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, channel_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, iscomputed_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, type_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, trans_type_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, bt_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, lt_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, flt_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, st_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, ft_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, lgt_), + PROTOBUF_FIELD_OFFSET(::pb::transformation, lgml2t_), + 2, + 11, + 0, + 1, + 12, + 13, + 10, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + PROTOBUF_FIELD_OFFSET(::pb::trans_pair, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::trans_pair, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::trans_pair, name_), + PROTOBUF_FIELD_OFFSET(::pb::trans_pair, trans_address_), + PROTOBUF_FIELD_OFFSET(::pb::trans_pair, trans_), + 0, + 2, + 1, + PROTOBUF_FIELD_OFFSET(::pb::trans_local, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::trans_local, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::trans_local, tp_), + PROTOBUF_FIELD_OFFSET(::pb::trans_local, groupname_), + PROTOBUF_FIELD_OFFSET(::pb::trans_local, sampleids_), + ~0u, + 0, + ~0u, + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, nevents_), + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, indtype_), + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, iind_), + PROTOBUF_FIELD_OFFSET(::pb::POPINDICES, bind_), + 1, + 2, + ~0u, + 0, + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, thisname_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, fjstats_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, fcstats_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, hidden_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, indices_), + PROTOBUF_FIELD_OFFSET(::pb::nodeProperties, thisgate_), + 0, + ~0u, + ~0u, + 3, + 1, + 2, + PROTOBUF_FIELD_OFFSET(::pb::treeNodes, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::treeNodes, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::treeNodes, node_), + PROTOBUF_FIELD_OFFSET(::pb::treeNodes, parent_), + 0, + 1, + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::pb::populationTree, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::populationTree, node_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::COMP, cid_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, prefix_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, suffix_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, name_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, comment_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, marker_), + PROTOBUF_FIELD_OFFSET(::pb::COMP, spillover_), + 0, + 1, + 2, + 3, + 4, + ~0u, + ~0u, + PROTOBUF_FIELD_OFFSET(::pb::PARAM, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::PARAM, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::PARAM, param_), + PROTOBUF_FIELD_OFFSET(::pb::PARAM, log_), + PROTOBUF_FIELD_OFFSET(::pb::PARAM, range_), + PROTOBUF_FIELD_OFFSET(::pb::PARAM, highvalue_), + PROTOBUF_FIELD_OFFSET(::pb::PARAM, calibrationindex_), + 0, + 1, + 2, + 3, + 4, + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, tree_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, comp_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, isloaded_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, transflag_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, trans_), + PROTOBUF_FIELD_OFFSET(::pb::GatingHierarchy, frame_), + 1, + 0, + 4, + ~0u, + 2, + 3, + PROTOBUF_FIELD_OFFSET(::pb::CytoFrame, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::CytoFrame, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::CytoFrame, is_h5_), + 0, + PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, trans_address_), + PROTOBUF_FIELD_OFFSET(::pb::TRANS_TBL, trans_), + 1, + 0, + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, _has_bits_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, trans_tbl_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, samplename_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, globalbiexptrans_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, globallintrans_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, gtrans_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, guid_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, cytolib_verion_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, pb_verion_), + PROTOBUF_FIELD_OFFSET(::pb::GatingSet, h5_verion_), + ~0u, + ~0u, + 4, + 5, + ~0u, + 0, + 1, + 2, + 3, +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, 8, sizeof(::pb::paramRange)}, + { 11, 17, sizeof(::pb::rangeGate)}, + { 18, -1, sizeof(::pb::paramPoly)}, + { 25, 32, sizeof(::pb::polygonGate)}, + { 34, 41, sizeof(::pb::coordinate)}, + { 43, 52, sizeof(::pb::ellipseGate)}, + { 56, 64, sizeof(::pb::BOOL_GATE_OP)}, + { 67, -1, sizeof(::pb::boolGate)}, + { 73, 79, sizeof(::pb::clusterGate)}, + { 80, 87, sizeof(::pb::quadGate)}, + { 89, 103, sizeof(::pb::gate)}, + { 112, 119, sizeof(::pb::POPSTATS)}, + { 121, 134, sizeof(::pb::calibrationTable)}, + { 142, 152, sizeof(::pb::biexpTrans)}, + { 157, 167, sizeof(::pb::fasinhTrans)}, + { 172, 180, sizeof(::pb::scaleTrans)}, + { 183, 190, sizeof(::pb::flinTrans)}, + { 192, 201, sizeof(::pb::logTrans)}, + { 205, 212, sizeof(::pb::logGML2Trans)}, + { 214, 226, sizeof(::pb::logicleTrans)}, + { 233, 252, sizeof(::pb::transformation)}, + { 266, 274, sizeof(::pb::trans_pair)}, + { 277, 285, sizeof(::pb::trans_local)}, + { 288, 297, sizeof(::pb::POPINDICES)}, + { 301, 312, sizeof(::pb::nodeProperties)}, + { 318, 325, sizeof(::pb::treeNodes)}, + { 327, -1, sizeof(::pb::populationTree)}, + { 333, 345, sizeof(::pb::COMP)}, + { 352, 362, sizeof(::pb::PARAM)}, + { 367, 378, sizeof(::pb::GatingHierarchy)}, + { 384, 390, sizeof(::pb::CytoFrame)}, + { 391, 398, sizeof(::pb::TRANS_TBL)}, + { 400, 414, sizeof(::pb::GatingSet)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::pb::_paramRange_default_instance_), + reinterpret_cast(&::pb::_rangeGate_default_instance_), + reinterpret_cast(&::pb::_paramPoly_default_instance_), + reinterpret_cast(&::pb::_polygonGate_default_instance_), + reinterpret_cast(&::pb::_coordinate_default_instance_), + reinterpret_cast(&::pb::_ellipseGate_default_instance_), + reinterpret_cast(&::pb::_BOOL_GATE_OP_default_instance_), + reinterpret_cast(&::pb::_boolGate_default_instance_), + reinterpret_cast(&::pb::_clusterGate_default_instance_), + reinterpret_cast(&::pb::_quadGate_default_instance_), + reinterpret_cast(&::pb::_gate_default_instance_), + reinterpret_cast(&::pb::_POPSTATS_default_instance_), + reinterpret_cast(&::pb::_calibrationTable_default_instance_), + reinterpret_cast(&::pb::_biexpTrans_default_instance_), + reinterpret_cast(&::pb::_fasinhTrans_default_instance_), + reinterpret_cast(&::pb::_scaleTrans_default_instance_), + reinterpret_cast(&::pb::_flinTrans_default_instance_), + reinterpret_cast(&::pb::_logTrans_default_instance_), + reinterpret_cast(&::pb::_logGML2Trans_default_instance_), + reinterpret_cast(&::pb::_logicleTrans_default_instance_), + reinterpret_cast(&::pb::_transformation_default_instance_), + reinterpret_cast(&::pb::_trans_pair_default_instance_), + reinterpret_cast(&::pb::_trans_local_default_instance_), + reinterpret_cast(&::pb::_POPINDICES_default_instance_), + reinterpret_cast(&::pb::_nodeProperties_default_instance_), + reinterpret_cast(&::pb::_treeNodes_default_instance_), + reinterpret_cast(&::pb::_populationTree_default_instance_), + reinterpret_cast(&::pb::_COMP_default_instance_), + reinterpret_cast(&::pb::_PARAM_default_instance_), + reinterpret_cast(&::pb::_GatingHierarchy_default_instance_), + reinterpret_cast(&::pb::_CytoFrame_default_instance_), + reinterpret_cast(&::pb::_TRANS_TBL_default_instance_), + reinterpret_cast(&::pb::_GatingSet_default_instance_), +}; + +const char descriptor_table_protodef_GatingSet_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\017GatingSet.proto\022\002pb\"4\n\nparamRange\022\014\n\004n" + "ame\030\001 \002(\t\022\013\n\003min\030\002 \002(\002\022\013\n\003max\030\003 \002(\002\"*\n\tr" + "angeGate\022\035\n\005param\030\001 \002(\0132\016.pb.paramRange\"" + "=\n\tparamPoly\022\016\n\006params\030\001 \003(\t\022 \n\010vertices" + "\030\002 \003(\0132\016.pb.coordinate\"E\n\013polygonGate\022\034\n" + "\005param\030\001 \002(\0132\r.pb.paramPoly\022\030\n\002qg\030\002 \001(\0132" + "\014.pb.quadGate\"\"\n\ncoordinate\022\t\n\001x\030\001 \002(\002\022\t" + "\n\001y\030\002 \002(\002\"\200\001\n\013ellipseGate\022\032\n\002mu\030\001 \002(\0132\016." + "pb.coordinate\022\033\n\003cov\030\002 \003(\0132\016.pb.coordina" + "te\022*\n\022antipodal_vertices\030\003 \003(\0132\016.pb.coor" + "dinate\022\014\n\004dist\030\004 \001(\002\"7\n\014BOOL_GATE_OP\022\014\n\004" + "path\030\001 \003(\t\022\n\n\002op\030\002 \002(\r\022\r\n\005isNot\030\003 \002(\010\"0\n" + "\010boolGate\022$\n\nboolOpSpec\030\001 \003(\0132\020.pb.BOOL_" + "GATE_OP\"%\n\013clusterGate\022\026\n\016cluster_method" + "\030\001 \002(\t\"7\n\010quadGate\022\013\n\003uid\030\001 \002(\t\022\036\n\010quadr" + "ant\030\003 \002(\0162\014.pb.QUADRANT\"\345\001\n\004gate\022\013\n\003neg\030" + "\001 \002(\010\022\025\n\risTransformed\030\002 \002(\010\022\020\n\010isGained" + "\030\003 \002(\010\022\033\n\004type\030\004 \002(\0162\r.pb.GATE_TYPE\022\031\n\002r" + "g\030\005 \001(\0132\r.pb.rangeGate\022\033\n\002pg\030\006 \001(\0132\017.pb." + "polygonGate\022\033\n\002eg\030\007 \001(\0132\017.pb.ellipseGate" + "\022\030\n\002bg\030\010 \001(\0132\014.pb.boolGate\022\033\n\002cg\030\t \001(\0132\017" + ".pb.clusterGate\"-\n\010POPSTATS\022\020\n\010statType\030" + "\001 \002(\t\022\017\n\007statVal\030\002 \002(\002\"\223\001\n\020calibrationTa" + "ble\022\r\n\001x\030\001 \003(\002B\002\020\001\022\r\n\001y\030\002 \003(\002B\002\020\001\022\r\n\001b\030\003" + " \003(\002B\002\020\001\022\r\n\001c\030\004 \003(\002B\002\020\001\022\r\n\001d\030\005 \003(\002B\002\020\001\022\025" + "\n\rspline_method\030\006 \001(\r\022\017\n\007caltype\030\007 \001(\t\022\014" + "\n\004flag\030\010 \001(\010\"b\n\nbiexpTrans\022\024\n\014channelRan" + "ge\030\001 \001(\r\022\013\n\003pos\030\002 \001(\002\022\013\n\003neg\030\003 \001(\002\022\022\n\nwi" + "dthBasis\030\004 \001(\002\022\020\n\010maxValue\030\005 \001(\002\"P\n\013fasi" + "nhTrans\022\016\n\006length\030\001 \001(\002\022\020\n\010maxRange\030\002 \001(" + "\002\022\t\n\001T\030\003 \001(\002\022\t\n\001A\030\004 \001(\002\022\t\n\001M\030\005 \001(\002\"D\n\nsc" + "aleTrans\022\024\n\014scale_factor\030\001 \001(\002\022\017\n\007t_scal" + "e\030\002 \001(\002\022\017\n\007r_scale\030\003 \001(\002\"%\n\tflinTrans\022\013\n" + "\003min\030\001 \001(\002\022\013\n\003max\030\002 \001(\002\"D\n\010logTrans\022\016\n\006o" + "ffset\030\001 \001(\002\022\016\n\006decade\030\002 \001(\002\022\t\n\001T\030\003 \001(\002\022\r" + "\n\005scale\030\004 \001(\002\"$\n\014logGML2Trans\022\t\n\001T\030\001 \001(\002" + "\022\t\n\001M\030\002 \001(\002\"k\n\014logicleTrans\022\t\n\001T\030\001 \001(\002\022\t" + "\n\001W\030\002 \001(\002\022\t\n\001M\030\003 \001(\002\022\t\n\001A\030\004 \001(\002\022\014\n\004bins\030" + "\005 \001(\002\022\016\n\006isGml2\030\006 \001(\010\022\021\n\tisInverse\030\007 \001(\010" + "\"\373\002\n\016transformation\022$\n\006calTbl\030\001 \001(\0132\024.pb" + ".calibrationTable\022\022\n\nisGateOnly\030\002 \001(\010\022\014\n" + "\004name\030\004 \001(\t\022\017\n\007channel\030\005 \001(\t\022\022\n\nisComput" + "ed\030\006 \001(\010\022\014\n\004type\030\014 \001(\r\022\"\n\ntrans_type\030\003 \001" + "(\0162\016.pb.TRANS_TYPE\022\032\n\002bt\030\007 \001(\0132\016.pb.biex" + "pTrans\022\030\n\002lt\030\010 \001(\0132\014.pb.logTrans\022\032\n\003flt\030" + "\t \001(\0132\r.pb.flinTrans\022\032\n\002st\030\n \001(\0132\016.pb.sc" + "aleTrans\022\033\n\002ft\030\013 \001(\0132\017.pb.fasinhTrans\022\035\n" + "\003lgt\030\r \001(\0132\020.pb.logicleTrans\022 \n\006lgml2t\030\016" + " \001(\0132\020.pb.logGML2Trans\"T\n\ntrans_pair\022\014\n\004" + "name\030\001 \002(\t\022\025\n\rtrans_address\030\002 \001(\004\022!\n\005tra" + "ns\030\003 \001(\0132\022.pb.transformation\"S\n\013trans_lo" + "cal\022\032\n\002tp\030\001 \003(\0132\016.pb.trans_pair\022\021\n\tgroup" + "Name\030\002 \001(\t\022\025\n\tsampleIDs\030\003 \003(\rB\002\020\001\"\\\n\nPOP" + "INDICES\022\017\n\007nEvents\030\001 \002(\r\022\035\n\007indtype\030\002 \002(" + "\0162\014.pb.ind_type\022\020\n\004iInd\030\003 \003(\rB\002\020\001\022\014\n\004bIn" + "d\030\004 \001(\014\"\255\001\n\016nodeProperties\022\020\n\010thisName\030\001" + " \002(\t\022\035\n\007fjStats\030\002 \003(\0132\014.pb.POPSTATS\022\035\n\007f" + "cStats\030\003 \003(\0132\014.pb.POPSTATS\022\016\n\006hidden\030\004 \002" + "(\010\022\037\n\007indices\030\005 \001(\0132\016.pb.POPINDICES\022\032\n\010t" + "hisGate\030\006 \001(\0132\010.pb.gate\"=\n\ttreeNodes\022 \n\004" + "node\030\001 \002(\0132\022.pb.nodeProperties\022\016\n\006parent" + "\030\002 \001(\r\"-\n\016populationTree\022\033\n\004node\030\001 \003(\0132\r" + ".pb.treeNodes\"u\n\004COMP\022\013\n\003cid\030\001 \001(\t\022\016\n\006pr" + "efix\030\002 \001(\t\022\016\n\006suffix\030\003 \001(\t\022\014\n\004name\030\004 \001(\t" + "\022\017\n\007comment\030\005 \001(\t\022\016\n\006marker\030\006 \003(\t\022\021\n\tspi" + "llOver\030\007 \003(\002\"_\n\005PARAM\022\r\n\005param\030\001 \001(\t\022\013\n\003" + "log\030\002 \001(\010\022\r\n\005range\030\003 \001(\r\022\021\n\thighValue\030\004 " + "\001(\r\022\030\n\020calibrationIndex\030\005 \001(\r\"\271\001\n\017Gating" + "Hierarchy\022 \n\004tree\030\002 \002(\0132\022.pb.populationT" + "ree\022\026\n\004comp\030\001 \001(\0132\010.pb.COMP\022\020\n\010isLoaded\030" + "\003 \001(\010\022\034\n\ttransFlag\030\004 \003(\0132\t.pb.PARAM\022\036\n\005t" + "rans\030\005 \001(\0132\017.pb.trans_local\022\034\n\005frame\030\006 \001" + "(\0132\r.pb.CytoFrame\"\032\n\tCytoFrame\022\r\n\005is_h5\030" + "\001 \002(\010\"E\n\tTRANS_TBL\022\025\n\rtrans_address\030\001 \001(" + "\004\022!\n\005trans\030\002 \001(\0132\022.pb.transformation\"\340\001\n" + "\tGatingSet\022 \n\ttrans_tbl\030\002 \003(\0132\r.pb.TRANS" + "_TBL\022\022\n\nsampleName\030\001 \003(\t\022\030\n\020globalBiExpT" + "rans\030\003 \001(\004\022\026\n\016globalLinTrans\030\004 \001(\004\022\037\n\006gT" + "rans\030\005 \003(\0132\017.pb.trans_local\022\014\n\004guid\030\006 \001(" + "\t\022\026\n\016cytolib_verion\030\007 \001(\t\022\021\n\tpb_verion\030\010" + " \001(\t\022\021\n\th5_verion\030\t \001(\t**\n\010QUADRANT\022\006\n\002Q" + "1\020\001\022\006\n\002Q2\020\002\022\006\n\002Q3\020\003\022\006\n\002Q4\020\004*\244\001\n\tGATE_TYP" + "E\022\020\n\014POLYGON_GATE\020\001\022\016\n\nRANGE_GATE\020\002\022\r\n\tB" + "OOL_GATE\020\003\022\020\n\014ELLIPSE_GATE\020\004\022\r\n\tRECT_GAT" + "E\020\005\022\020\n\014LOGICAL_GATE\020\006\022\022\n\016ELLIPSOID_GATE\020" + "\007\022\020\n\014CLUSTER_GATE\020\010\022\r\n\tQUAD_GATE\020\t*\'\n\010in" + "d_type\022\010\n\004BOOL\020\000\022\007\n\003INT\020\001\022\010\n\004ROOT\020\002*\214\001\n\n" + "TRANS_TYPE\022\r\n\tPB_CALTBL\020\000\022\n\n\006PB_LOG\020\001\022\n\n" + "\006PB_LIN\020\002\022\013\n\007PB_FLIN\020\003\022\016\n\nPB_FASIGNH\020\004\022\014" + "\n\010PB_BIEXP\020\005\022\016\n\nPB_LOGICLE\020\006\022\016\n\nPB_LOGGM" + "L2\020\007\022\014\n\010PB_SCALE\020\010" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_GatingSet_2eproto_deps[1] = { +}; +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_GatingSet_2eproto_sccs[33] = { + &scc_info_BOOL_GATE_OP_GatingSet_2eproto.base, + &scc_info_COMP_GatingSet_2eproto.base, + &scc_info_CytoFrame_GatingSet_2eproto.base, + &scc_info_GatingHierarchy_GatingSet_2eproto.base, + &scc_info_GatingSet_GatingSet_2eproto.base, + &scc_info_PARAM_GatingSet_2eproto.base, + &scc_info_POPINDICES_GatingSet_2eproto.base, + &scc_info_POPSTATS_GatingSet_2eproto.base, + &scc_info_TRANS_TBL_GatingSet_2eproto.base, + &scc_info_biexpTrans_GatingSet_2eproto.base, + &scc_info_boolGate_GatingSet_2eproto.base, + &scc_info_calibrationTable_GatingSet_2eproto.base, + &scc_info_clusterGate_GatingSet_2eproto.base, + &scc_info_coordinate_GatingSet_2eproto.base, + &scc_info_ellipseGate_GatingSet_2eproto.base, + &scc_info_fasinhTrans_GatingSet_2eproto.base, + &scc_info_flinTrans_GatingSet_2eproto.base, + &scc_info_gate_GatingSet_2eproto.base, + &scc_info_logGML2Trans_GatingSet_2eproto.base, + &scc_info_logTrans_GatingSet_2eproto.base, + &scc_info_logicleTrans_GatingSet_2eproto.base, + &scc_info_nodeProperties_GatingSet_2eproto.base, + &scc_info_paramPoly_GatingSet_2eproto.base, + &scc_info_paramRange_GatingSet_2eproto.base, + &scc_info_polygonGate_GatingSet_2eproto.base, + &scc_info_populationTree_GatingSet_2eproto.base, + &scc_info_quadGate_GatingSet_2eproto.base, + &scc_info_rangeGate_GatingSet_2eproto.base, + &scc_info_scaleTrans_GatingSet_2eproto.base, + &scc_info_trans_local_GatingSet_2eproto.base, + &scc_info_trans_pair_GatingSet_2eproto.base, + &scc_info_transformation_GatingSet_2eproto.base, + &scc_info_treeNodes_GatingSet_2eproto.base, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_GatingSet_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_GatingSet_2eproto = { + false, false, descriptor_table_protodef_GatingSet_2eproto, "GatingSet.proto", 3618, + &descriptor_table_GatingSet_2eproto_once, descriptor_table_GatingSet_2eproto_sccs, descriptor_table_GatingSet_2eproto_deps, 33, 0, + schemas, file_default_instances, TableStruct_GatingSet_2eproto::offsets, + file_level_metadata_GatingSet_2eproto, 33, file_level_enum_descriptors_GatingSet_2eproto, file_level_service_descriptors_GatingSet_2eproto, +}; + +// Force running AddDescriptors() at dynamic initialization time. +static bool dynamic_init_dummy_GatingSet_2eproto = (static_cast(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_GatingSet_2eproto)), true); +namespace pb { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* QUADRANT_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto); + return file_level_enum_descriptors_GatingSet_2eproto[0]; +} +bool QUADRANT_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GATE_TYPE_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto); + return file_level_enum_descriptors_GatingSet_2eproto[1]; +} +bool GATE_TYPE_IsValid(int value) { + switch (value) { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ind_type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto); + return file_level_enum_descriptors_GatingSet_2eproto[2]; +} +bool ind_type_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TRANS_TYPE_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_GatingSet_2eproto); + return file_level_enum_descriptors_GatingSet_2eproto[3]; +} +bool TRANS_TYPE_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + return true; + default: + return false; + } +} + + +// =================================================================== + +void paramRange::InitAsDefaultInstance() { +} +class paramRange::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_min(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_max(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0; + } +}; + +paramRange::paramRange(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.paramRange) +} +paramRange::paramRange(const paramRange& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + ::memcpy(&min_, &from.min_, + static_cast(reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); + // @@protoc_insertion_point(copy_constructor:pb.paramRange) +} + +void paramRange::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_paramRange_GatingSet_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&min_, 0, static_cast( + reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); +} + +paramRange::~paramRange() { + // @@protoc_insertion_point(destructor:pb.paramRange) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void paramRange::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void paramRange::ArenaDtor(void* object) { + paramRange* _this = reinterpret_cast< paramRange* >(object); + (void)_this; +} +void paramRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void paramRange::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const paramRange& paramRange::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_paramRange_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void paramRange::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.paramRange) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&min_, 0, static_cast( + reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* paramRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required 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); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.paramRange.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // required float min = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_min(&has_bits); + min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // required float max = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_max(&has_bits); + max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* paramRange::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.paramRange) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.paramRange.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // required float min = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_min(), target); + } + + // required float max = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_max(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.paramRange) + return target; +} + +size_t paramRange::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.paramRange) + size_t total_size = 0; + + if (_internal_has_name()) { + // required string name = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + if (_internal_has_min()) { + // required float min = 2; + total_size += 1 + 4; + } + + if (_internal_has_max()) { + // required float max = 3; + total_size += 1 + 4; + } + + return total_size; +} +size_t paramRange::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.paramRange) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) { // All required fields are present. + // required string name = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + + // required float min = 2; + total_size += 1 + 4; + + // required float max = 3; + total_size += 1 + 4; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::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 paramRange::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.paramRange) + GOOGLE_DCHECK_NE(&from, this); + const paramRange* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.paramRange) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.paramRange) + MergeFrom(*source); + } +} + +void paramRange::MergeFrom(const paramRange& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.paramRange) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + min_ = from.min_; + } + if (cached_has_bits & 0x00000004u) { + max_ = from.max_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void paramRange::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.paramRange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void paramRange::CopyFrom(const paramRange& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.paramRange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool paramRange::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void paramRange::InternalSwap(paramRange* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(paramRange, max_) + + sizeof(paramRange::max_) + - PROTOBUF_FIELD_OFFSET(paramRange, min_)>( + reinterpret_cast(&min_), + reinterpret_cast(&other->min_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata paramRange::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void rangeGate::InitAsDefaultInstance() { + ::pb::_rangeGate_default_instance_._instance.get_mutable()->param_ = const_cast< ::pb::paramRange*>( + ::pb::paramRange::internal_default_instance()); +} +class rangeGate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::paramRange& param(const rangeGate* msg); + static void set_has_param(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::pb::paramRange& +rangeGate::_Internal::param(const rangeGate* msg) { + return *msg->param_; +} +rangeGate::rangeGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.rangeGate) +} +rangeGate::rangeGate(const rangeGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_param()) { + param_ = new ::pb::paramRange(*from.param_); + } else { + param_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:pb.rangeGate) +} + +void rangeGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_rangeGate_GatingSet_2eproto.base); + param_ = nullptr; +} + +rangeGate::~rangeGate() { + // @@protoc_insertion_point(destructor:pb.rangeGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void rangeGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete param_; +} + +void rangeGate::ArenaDtor(void* object) { + rangeGate* _this = reinterpret_cast< rangeGate* >(object); + (void)_this; +} +void rangeGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void rangeGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const rangeGate& rangeGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_rangeGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void rangeGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.rangeGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(param_ != nullptr); + param_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* rangeGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required .pb.paramRange param = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_param(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* rangeGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.rangeGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required .pb.paramRange param = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::param(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:pb.rangeGate) + return target; +} + +size_t rangeGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.rangeGate) + size_t total_size = 0; + + // required .pb.paramRange param = 1; + if (_internal_has_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *param_); + } + ::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 rangeGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.rangeGate) + GOOGLE_DCHECK_NE(&from, this); + const rangeGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.rangeGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.rangeGate) + MergeFrom(*source); + } +} + +void rangeGate::MergeFrom(const rangeGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.rangeGate) + GOOGLE_DCHECK_NE(&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._internal_has_param()) { + _internal_mutable_param()->::pb::paramRange::MergeFrom(from._internal_param()); + } +} + +void rangeGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.rangeGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void rangeGate::CopyFrom(const rangeGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.rangeGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool rangeGate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (_internal_has_param()) { + if (!param_->IsInitialized()) return false; + } + return true; +} + +void rangeGate::InternalSwap(rangeGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(param_, other->param_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata rangeGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void paramPoly::InitAsDefaultInstance() { +} +class paramPoly::_Internal { + public: +}; + +paramPoly::paramPoly(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + params_(arena), + vertices_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.paramPoly) +} +paramPoly::paramPoly(const paramPoly& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + params_(from.params_), + vertices_(from.vertices_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.paramPoly) +} + +void paramPoly::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_paramPoly_GatingSet_2eproto.base); +} + +paramPoly::~paramPoly() { + // @@protoc_insertion_point(destructor:pb.paramPoly) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void paramPoly::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void paramPoly::ArenaDtor(void* object) { + paramPoly* _this = reinterpret_cast< paramPoly* >(object); + (void)_this; +} +void paramPoly::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void paramPoly::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const paramPoly& paramPoly::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_paramPoly_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void paramPoly::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.paramPoly) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + params_.Clear(); + vertices_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* paramPoly::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string params = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_params(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.paramPoly.params"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // repeated .pb.coordinate vertices = 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_vertices(), 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 & 7) == 4 || tag == 0) { + 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* paramPoly::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.paramPoly) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string params = 1; + for (int i = 0, n = this->_internal_params_size(); i < n; i++) { + const auto& s = this->_internal_params(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.paramPoly.params"); + target = stream->WriteString(1, s, target); + } + + // repeated .pb.coordinate vertices = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_vertices_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_vertices(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:pb.paramPoly) + return target; +} + +size_t paramPoly::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.paramPoly) + size_t 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 params = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(params_.size()); + for (int i = 0, n = params_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + params_.Get(i)); + } + + // repeated .pb.coordinate vertices = 2; + total_size += 1UL * this->_internal_vertices_size(); + for (const auto& msg : this->vertices_) { + 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 paramPoly::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.paramPoly) + GOOGLE_DCHECK_NE(&from, this); + const paramPoly* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.paramPoly) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.paramPoly) + MergeFrom(*source); + } +} + +void paramPoly::MergeFrom(const paramPoly& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.paramPoly) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + params_.MergeFrom(from.params_); + vertices_.MergeFrom(from.vertices_); +} + +void paramPoly::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.paramPoly) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void paramPoly::CopyFrom(const paramPoly& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.paramPoly) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool paramPoly::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(vertices_)) return false; + return true; +} + +void paramPoly::InternalSwap(paramPoly* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + params_.InternalSwap(&other->params_); + vertices_.InternalSwap(&other->vertices_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata paramPoly::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void polygonGate::InitAsDefaultInstance() { + ::pb::_polygonGate_default_instance_._instance.get_mutable()->param_ = const_cast< ::pb::paramPoly*>( + ::pb::paramPoly::internal_default_instance()); + ::pb::_polygonGate_default_instance_._instance.get_mutable()->qg_ = const_cast< ::pb::quadGate*>( + ::pb::quadGate::internal_default_instance()); +} +class polygonGate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::paramPoly& param(const polygonGate* msg); + static void set_has_param(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::pb::quadGate& qg(const polygonGate* msg); + static void set_has_qg(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::pb::paramPoly& +polygonGate::_Internal::param(const polygonGate* msg) { + return *msg->param_; +} +const ::pb::quadGate& +polygonGate::_Internal::qg(const polygonGate* msg) { + return *msg->qg_; +} +polygonGate::polygonGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.polygonGate) +} +polygonGate::polygonGate(const polygonGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_param()) { + param_ = new ::pb::paramPoly(*from.param_); + } else { + param_ = nullptr; + } + if (from._internal_has_qg()) { + qg_ = new ::pb::quadGate(*from.qg_); + } else { + qg_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:pb.polygonGate) +} + +void polygonGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_polygonGate_GatingSet_2eproto.base); + ::memset(¶m_, 0, static_cast( + reinterpret_cast(&qg_) - + reinterpret_cast(¶m_)) + sizeof(qg_)); +} + +polygonGate::~polygonGate() { + // @@protoc_insertion_point(destructor:pb.polygonGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void polygonGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete param_; + if (this != internal_default_instance()) delete qg_; +} + +void polygonGate::ArenaDtor(void* object) { + polygonGate* _this = reinterpret_cast< polygonGate* >(object); + (void)_this; +} +void polygonGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void polygonGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const polygonGate& polygonGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_polygonGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void polygonGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.polygonGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(param_ != nullptr); + param_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(qg_ != nullptr); + qg_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* polygonGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required .pb.paramPoly param = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_param(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.quadGate qg = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_qg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* polygonGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.polygonGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required .pb.paramPoly param = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::param(this), target, stream); + } + + // optional .pb.quadGate qg = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::qg(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:pb.polygonGate) + return target; +} + +size_t polygonGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.polygonGate) + size_t total_size = 0; + + // required .pb.paramPoly param = 1; + if (_internal_has_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *param_); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .pb.quadGate qg = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *qg_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 polygonGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.polygonGate) + GOOGLE_DCHECK_NE(&from, this); + const polygonGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.polygonGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.polygonGate) + MergeFrom(*source); + } +} + +void polygonGate::MergeFrom(const polygonGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.polygonGate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_param()->::pb::paramPoly::MergeFrom(from._internal_param()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_qg()->::pb::quadGate::MergeFrom(from._internal_qg()); + } + } +} + +void polygonGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.polygonGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void polygonGate::CopyFrom(const polygonGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.polygonGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool polygonGate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (_internal_has_param()) { + if (!param_->IsInitialized()) return false; + } + if (_internal_has_qg()) { + if (!qg_->IsInitialized()) return false; + } + return true; +} + +void polygonGate::InternalSwap(polygonGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(polygonGate, qg_) + + sizeof(polygonGate::qg_) + - PROTOBUF_FIELD_OFFSET(polygonGate, param_)>( + reinterpret_cast(¶m_), + reinterpret_cast(&other->param_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata polygonGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void coordinate::InitAsDefaultInstance() { +} +class coordinate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_x(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_y(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; + } +}; + +coordinate::coordinate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.coordinate) +} +coordinate::coordinate(const coordinate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&x_, &from.x_, + static_cast(reinterpret_cast(&y_) - + reinterpret_cast(&x_)) + sizeof(y_)); + // @@protoc_insertion_point(copy_constructor:pb.coordinate) +} + +void coordinate::SharedCtor() { + ::memset(&x_, 0, static_cast( + reinterpret_cast(&y_) - + reinterpret_cast(&x_)) + sizeof(y_)); +} + +coordinate::~coordinate() { + // @@protoc_insertion_point(destructor:pb.coordinate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void coordinate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void coordinate::ArenaDtor(void* object) { + coordinate* _this = reinterpret_cast< coordinate* >(object); + (void)_this; +} +void coordinate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void coordinate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const coordinate& coordinate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_coordinate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void coordinate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.coordinate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&x_, 0, static_cast( + reinterpret_cast(&y_) - + reinterpret_cast(&x_)) + sizeof(y_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* coordinate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required float x = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_x(&has_bits); + x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // required float y = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_y(&has_bits); + y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* coordinate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.coordinate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required float x = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target); + } + + // required float y = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), 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:pb.coordinate) + return target; +} + +size_t coordinate::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.coordinate) + size_t total_size = 0; + + if (_internal_has_x()) { + // required float x = 1; + total_size += 1 + 4; + } + + if (_internal_has_y()) { + // required float y = 2; + total_size += 1 + 4; + } + + return total_size; +} +size_t coordinate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.coordinate) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present. + // required float x = 1; + total_size += 1 + 4; + + // required float y = 2; + total_size += 1 + 4; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::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 coordinate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.coordinate) + GOOGLE_DCHECK_NE(&from, this); + const coordinate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.coordinate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.coordinate) + MergeFrom(*source); + } +} + +void coordinate::MergeFrom(const coordinate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.coordinate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + x_ = from.x_; + } + if (cached_has_bits & 0x00000002u) { + y_ = from.y_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void coordinate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.coordinate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void coordinate::CopyFrom(const coordinate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.coordinate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool coordinate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void coordinate::InternalSwap(coordinate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(coordinate, y_) + + sizeof(coordinate::y_) + - PROTOBUF_FIELD_OFFSET(coordinate, x_)>( + reinterpret_cast(&x_), + reinterpret_cast(&other->x_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata coordinate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void ellipseGate::InitAsDefaultInstance() { + ::pb::_ellipseGate_default_instance_._instance.get_mutable()->mu_ = const_cast< ::pb::coordinate*>( + ::pb::coordinate::internal_default_instance()); +} +class ellipseGate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::coordinate& mu(const ellipseGate* msg); + static void set_has_mu(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_dist(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::pb::coordinate& +ellipseGate::_Internal::mu(const ellipseGate* msg) { + return *msg->mu_; +} +ellipseGate::ellipseGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + cov_(arena), + antipodal_vertices_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.ellipseGate) +} +ellipseGate::ellipseGate(const ellipseGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + cov_(from.cov_), + antipodal_vertices_(from.antipodal_vertices_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_mu()) { + mu_ = new ::pb::coordinate(*from.mu_); + } else { + mu_ = nullptr; + } + dist_ = from.dist_; + // @@protoc_insertion_point(copy_constructor:pb.ellipseGate) +} + +void ellipseGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ellipseGate_GatingSet_2eproto.base); + ::memset(&mu_, 0, static_cast( + reinterpret_cast(&dist_) - + reinterpret_cast(&mu_)) + sizeof(dist_)); +} + +ellipseGate::~ellipseGate() { + // @@protoc_insertion_point(destructor:pb.ellipseGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ellipseGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete mu_; +} + +void ellipseGate::ArenaDtor(void* object) { + ellipseGate* _this = reinterpret_cast< ellipseGate* >(object); + (void)_this; +} +void ellipseGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ellipseGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ellipseGate& ellipseGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ellipseGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void ellipseGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.ellipseGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cov_.Clear(); + antipodal_vertices_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(mu_ != nullptr); + mu_->Clear(); + } + dist_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ellipseGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required .pb.coordinate mu = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_mu(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.coordinate cov = 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_cov(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .pb.coordinate antipodal_vertices = 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_antipodal_vertices(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // optional float dist = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + _Internal::set_has_dist(&has_bits); + dist_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ellipseGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.ellipseGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required .pb.coordinate mu = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::mu(this), target, stream); + } + + // repeated .pb.coordinate cov = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_cov_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_cov(i), target, stream); + } + + // repeated .pb.coordinate antipodal_vertices = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_antipodal_vertices_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_antipodal_vertices(i), target, stream); + } + + // optional float dist = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_dist(), 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:pb.ellipseGate) + return target; +} + +size_t ellipseGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.ellipseGate) + size_t total_size = 0; + + // required .pb.coordinate mu = 1; + if (_internal_has_mu()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mu_); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .pb.coordinate cov = 2; + total_size += 1UL * this->_internal_cov_size(); + for (const auto& msg : this->cov_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .pb.coordinate antipodal_vertices = 3; + total_size += 1UL * this->_internal_antipodal_vertices_size(); + for (const auto& msg : this->antipodal_vertices_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional float dist = 4; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 ellipseGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.ellipseGate) + GOOGLE_DCHECK_NE(&from, this); + const ellipseGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.ellipseGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.ellipseGate) + MergeFrom(*source); + } +} + +void ellipseGate::MergeFrom(const ellipseGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.ellipseGate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cov_.MergeFrom(from.cov_); + antipodal_vertices_.MergeFrom(from.antipodal_vertices_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_mu()->::pb::coordinate::MergeFrom(from._internal_mu()); + } + if (cached_has_bits & 0x00000002u) { + dist_ = from.dist_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ellipseGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.ellipseGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ellipseGate::CopyFrom(const ellipseGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.ellipseGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ellipseGate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(cov_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(antipodal_vertices_)) return false; + if (_internal_has_mu()) { + if (!mu_->IsInitialized()) return false; + } + return true; +} + +void ellipseGate::InternalSwap(ellipseGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + cov_.InternalSwap(&other->cov_); + antipodal_vertices_.InternalSwap(&other->antipodal_vertices_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ellipseGate, dist_) + + sizeof(ellipseGate::dist_) + - PROTOBUF_FIELD_OFFSET(ellipseGate, mu_)>( + reinterpret_cast(&mu_), + reinterpret_cast(&other->mu_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ellipseGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BOOL_GATE_OP::InitAsDefaultInstance() { +} +class BOOL_GATE_OP::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_op(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_isnot(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; + } +}; + +BOOL_GATE_OP::BOOL_GATE_OP(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + path_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.BOOL_GATE_OP) +} +BOOL_GATE_OP::BOOL_GATE_OP(const BOOL_GATE_OP& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + path_(from.path_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&op_, &from.op_, + static_cast(reinterpret_cast(&isnot_) - + reinterpret_cast(&op_)) + sizeof(isnot_)); + // @@protoc_insertion_point(copy_constructor:pb.BOOL_GATE_OP) +} + +void BOOL_GATE_OP::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BOOL_GATE_OP_GatingSet_2eproto.base); + ::memset(&op_, 0, static_cast( + reinterpret_cast(&isnot_) - + reinterpret_cast(&op_)) + sizeof(isnot_)); +} + +BOOL_GATE_OP::~BOOL_GATE_OP() { + // @@protoc_insertion_point(destructor:pb.BOOL_GATE_OP) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void BOOL_GATE_OP::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void BOOL_GATE_OP::ArenaDtor(void* object) { + BOOL_GATE_OP* _this = reinterpret_cast< BOOL_GATE_OP* >(object); + (void)_this; +} +void BOOL_GATE_OP::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BOOL_GATE_OP::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BOOL_GATE_OP& BOOL_GATE_OP::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BOOL_GATE_OP_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void BOOL_GATE_OP::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.BOOL_GATE_OP) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + path_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&op_, 0, static_cast( + reinterpret_cast(&isnot_) - + reinterpret_cast(&op_)) + sizeof(isnot_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* BOOL_GATE_OP::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string path = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_path(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.BOOL_GATE_OP.path"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // required uint32 op = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_op(&has_bits); + op_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required bool isNot = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_isnot(&has_bits); + isnot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* BOOL_GATE_OP::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.BOOL_GATE_OP) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string path = 1; + for (int i = 0, n = this->_internal_path_size(); i < n; i++) { + const auto& s = this->_internal_path(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.BOOL_GATE_OP.path"); + target = stream->WriteString(1, s, target); + } + + cached_has_bits = _has_bits_[0]; + // required uint32 op = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_op(), target); + } + + // required bool isNot = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_isnot(), 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:pb.BOOL_GATE_OP) + return target; +} + +size_t BOOL_GATE_OP::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.BOOL_GATE_OP) + size_t total_size = 0; + + if (_internal_has_op()) { + // required uint32 op = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_op()); + } + + if (_internal_has_isnot()) { + // required bool isNot = 3; + total_size += 1 + 1; + } + + return total_size; +} +size_t BOOL_GATE_OP::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.BOOL_GATE_OP) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present. + // required uint32 op = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_op()); + + // required bool isNot = 3; + total_size += 1 + 1; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string path = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(path_.size()); + for (int i = 0, n = path_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + path_.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 BOOL_GATE_OP::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.BOOL_GATE_OP) + GOOGLE_DCHECK_NE(&from, this); + const BOOL_GATE_OP* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.BOOL_GATE_OP) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.BOOL_GATE_OP) + MergeFrom(*source); + } +} + +void BOOL_GATE_OP::MergeFrom(const BOOL_GATE_OP& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.BOOL_GATE_OP) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + path_.MergeFrom(from.path_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + op_ = from.op_; + } + if (cached_has_bits & 0x00000002u) { + isnot_ = from.isnot_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void BOOL_GATE_OP::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.BOOL_GATE_OP) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BOOL_GATE_OP::CopyFrom(const BOOL_GATE_OP& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.BOOL_GATE_OP) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BOOL_GATE_OP::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void BOOL_GATE_OP::InternalSwap(BOOL_GATE_OP* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + path_.InternalSwap(&other->path_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BOOL_GATE_OP, isnot_) + + sizeof(BOOL_GATE_OP::isnot_) + - PROTOBUF_FIELD_OFFSET(BOOL_GATE_OP, op_)>( + reinterpret_cast(&op_), + reinterpret_cast(&other->op_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BOOL_GATE_OP::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void boolGate::InitAsDefaultInstance() { +} +class boolGate::_Internal { + public: +}; + +boolGate::boolGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + boolopspec_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.boolGate) +} +boolGate::boolGate(const boolGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + boolopspec_(from.boolopspec_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.boolGate) +} + +void boolGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_boolGate_GatingSet_2eproto.base); +} + +boolGate::~boolGate() { + // @@protoc_insertion_point(destructor:pb.boolGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void boolGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void boolGate::ArenaDtor(void* object) { + boolGate* _this = reinterpret_cast< boolGate* >(object); + (void)_this; +} +void boolGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void boolGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const boolGate& boolGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_boolGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void boolGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.boolGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + boolopspec_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* boolGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .pb.BOOL_GATE_OP boolOpSpec = 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_boolopspec(), 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 & 7) == 4 || tag == 0) { + 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* boolGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.boolGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .pb.BOOL_GATE_OP boolOpSpec = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_boolopspec_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_boolopspec(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:pb.boolGate) + return target; +} + +size_t boolGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.boolGate) + size_t 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 .pb.BOOL_GATE_OP boolOpSpec = 1; + total_size += 1UL * this->_internal_boolopspec_size(); + for (const auto& msg : this->boolopspec_) { + 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 boolGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.boolGate) + GOOGLE_DCHECK_NE(&from, this); + const boolGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.boolGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.boolGate) + MergeFrom(*source); + } +} + +void boolGate::MergeFrom(const boolGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.boolGate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + boolopspec_.MergeFrom(from.boolopspec_); +} + +void boolGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.boolGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void boolGate::CopyFrom(const boolGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.boolGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool boolGate::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(boolopspec_)) return false; + return true; +} + +void boolGate::InternalSwap(boolGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + boolopspec_.InternalSwap(&other->boolopspec_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata boolGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void clusterGate::InitAsDefaultInstance() { +} +class clusterGate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_cluster_method(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +clusterGate::clusterGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.clusterGate) +} +clusterGate::clusterGate(const clusterGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + cluster_method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cluster_method()) { + cluster_method_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_cluster_method(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:pb.clusterGate) +} + +void clusterGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_clusterGate_GatingSet_2eproto.base); + cluster_method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +clusterGate::~clusterGate() { + // @@protoc_insertion_point(destructor:pb.clusterGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void clusterGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + cluster_method_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void clusterGate::ArenaDtor(void* object) { + clusterGate* _this = reinterpret_cast< clusterGate* >(object); + (void)_this; +} +void clusterGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void clusterGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const clusterGate& clusterGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_clusterGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void clusterGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.clusterGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + cluster_method_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* clusterGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string cluster_method = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_cluster_method(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.clusterGate.cluster_method"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* clusterGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.clusterGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string cluster_method = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_cluster_method().data(), static_cast(this->_internal_cluster_method().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.clusterGate.cluster_method"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_cluster_method(), 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:pb.clusterGate) + return target; +} + +size_t clusterGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.clusterGate) + size_t total_size = 0; + + // required string cluster_method = 1; + if (_internal_has_cluster_method()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cluster_method()); + } + ::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 clusterGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.clusterGate) + GOOGLE_DCHECK_NE(&from, this); + const clusterGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.clusterGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.clusterGate) + MergeFrom(*source); + } +} + +void clusterGate::MergeFrom(const clusterGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.clusterGate) + GOOGLE_DCHECK_NE(&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._internal_has_cluster_method()) { + _internal_set_cluster_method(from._internal_cluster_method()); + } +} + +void clusterGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.clusterGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void clusterGate::CopyFrom(const clusterGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.clusterGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool clusterGate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void clusterGate::InternalSwap(clusterGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + cluster_method_.Swap(&other->cluster_method_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata clusterGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void quadGate::InitAsDefaultInstance() { +} +class quadGate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_uid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_quadrant(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; + } +}; + +quadGate::quadGate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.quadGate) +} +quadGate::quadGate(const quadGate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + uid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_uid()) { + uid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_uid(), + GetArena()); + } + quadrant_ = from.quadrant_; + // @@protoc_insertion_point(copy_constructor:pb.quadGate) +} + +void quadGate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_quadGate_GatingSet_2eproto.base); + uid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + quadrant_ = 1; +} + +quadGate::~quadGate() { + // @@protoc_insertion_point(destructor:pb.quadGate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void quadGate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + uid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void quadGate::ArenaDtor(void* object) { + quadGate* _this = reinterpret_cast< quadGate* >(object); + (void)_this; +} +void quadGate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void quadGate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const quadGate& quadGate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_quadGate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void quadGate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.quadGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + uid_.ClearNonDefaultToEmpty(); + } + quadrant_ = 1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* quadGate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string uid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_uid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.quadGate.uid"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // required .pb.QUADRANT quadrant = 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); + if (PROTOBUF_PREDICT_TRUE(::pb::QUADRANT_IsValid(val))) { + _internal_set_quadrant(static_cast<::pb::QUADRANT>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* quadGate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.quadGate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string uid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_uid().data(), static_cast(this->_internal_uid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.quadGate.uid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_uid(), target); + } + + // required .pb.QUADRANT quadrant = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_quadrant(), 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:pb.quadGate) + return target; +} + +size_t quadGate::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.quadGate) + size_t total_size = 0; + + if (_internal_has_uid()) { + // required string uid = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uid()); + } + + if (_internal_has_quadrant()) { + // required .pb.QUADRANT quadrant = 3; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_quadrant()); + } + + return total_size; +} +size_t quadGate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.quadGate) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present. + // required string uid = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uid()); + + // required .pb.QUADRANT quadrant = 3; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_quadrant()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::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 quadGate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.quadGate) + GOOGLE_DCHECK_NE(&from, this); + const quadGate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.quadGate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.quadGate) + MergeFrom(*source); + } +} + +void quadGate::MergeFrom(const quadGate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.quadGate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_uid(from._internal_uid()); + } + if (cached_has_bits & 0x00000002u) { + quadrant_ = from.quadrant_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void quadGate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.quadGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void quadGate::CopyFrom(const quadGate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.quadGate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool quadGate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void quadGate::InternalSwap(quadGate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + uid_.Swap(&other->uid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(quadrant_, other->quadrant_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata quadGate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void gate::InitAsDefaultInstance() { + ::pb::_gate_default_instance_._instance.get_mutable()->rg_ = const_cast< ::pb::rangeGate*>( + ::pb::rangeGate::internal_default_instance()); + ::pb::_gate_default_instance_._instance.get_mutable()->pg_ = const_cast< ::pb::polygonGate*>( + ::pb::polygonGate::internal_default_instance()); + ::pb::_gate_default_instance_._instance.get_mutable()->eg_ = const_cast< ::pb::ellipseGate*>( + ::pb::ellipseGate::internal_default_instance()); + ::pb::_gate_default_instance_._instance.get_mutable()->bg_ = const_cast< ::pb::boolGate*>( + ::pb::boolGate::internal_default_instance()); + ::pb::_gate_default_instance_._instance.get_mutable()->cg_ = const_cast< ::pb::clusterGate*>( + ::pb::clusterGate::internal_default_instance()); +} +class gate::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_neg(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_istransformed(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_isgained(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::pb::rangeGate& rg(const gate* msg); + static void set_has_rg(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::pb::polygonGate& pg(const gate* msg); + static void set_has_pg(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::pb::ellipseGate& eg(const gate* msg); + static void set_has_eg(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::pb::boolGate& bg(const gate* msg); + static void set_has_bg(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::pb::clusterGate& cg(const gate* msg); + static void set_has_cg(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x000001e0) ^ 0x000001e0) != 0; + } +}; + +const ::pb::rangeGate& +gate::_Internal::rg(const gate* msg) { + return *msg->rg_; +} +const ::pb::polygonGate& +gate::_Internal::pg(const gate* msg) { + return *msg->pg_; +} +const ::pb::ellipseGate& +gate::_Internal::eg(const gate* msg) { + return *msg->eg_; +} +const ::pb::boolGate& +gate::_Internal::bg(const gate* msg) { + return *msg->bg_; +} +const ::pb::clusterGate& +gate::_Internal::cg(const gate* msg) { + return *msg->cg_; +} +gate::gate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.gate) +} +gate::gate(const gate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_rg()) { + rg_ = new ::pb::rangeGate(*from.rg_); + } else { + rg_ = nullptr; + } + if (from._internal_has_pg()) { + pg_ = new ::pb::polygonGate(*from.pg_); + } else { + pg_ = nullptr; + } + if (from._internal_has_eg()) { + eg_ = new ::pb::ellipseGate(*from.eg_); + } else { + eg_ = nullptr; + } + if (from._internal_has_bg()) { + bg_ = new ::pb::boolGate(*from.bg_); + } else { + bg_ = nullptr; + } + if (from._internal_has_cg()) { + cg_ = new ::pb::clusterGate(*from.cg_); + } else { + cg_ = nullptr; + } + ::memcpy(&neg_, &from.neg_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&neg_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:pb.gate) +} + +void gate::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_gate_GatingSet_2eproto.base); + ::memset(&rg_, 0, static_cast( + reinterpret_cast(&isgained_) - + reinterpret_cast(&rg_)) + sizeof(isgained_)); + type_ = 1; +} + +gate::~gate() { + // @@protoc_insertion_point(destructor:pb.gate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void gate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete rg_; + if (this != internal_default_instance()) delete pg_; + if (this != internal_default_instance()) delete eg_; + if (this != internal_default_instance()) delete bg_; + if (this != internal_default_instance()) delete cg_; +} + +void gate::ArenaDtor(void* object) { + gate* _this = reinterpret_cast< gate* >(object); + (void)_this; +} +void gate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void gate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const gate& gate::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_gate_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void gate::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.gate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(rg_ != nullptr); + rg_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(pg_ != nullptr); + pg_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(eg_ != nullptr); + eg_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(bg_ != nullptr); + bg_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(cg_ != nullptr); + cg_->Clear(); + } + } + ::memset(&neg_, 0, static_cast( + reinterpret_cast(&isgained_) - + reinterpret_cast(&neg_)) + sizeof(isgained_)); + type_ = 1; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* gate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bool neg = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_neg(&has_bits); + neg_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required bool isTransformed = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_istransformed(&has_bits); + istransformed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required bool isGained = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_isgained(&has_bits); + isgained_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required .pb.GATE_TYPE type = 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); + if (PROTOBUF_PREDICT_TRUE(::pb::GATE_TYPE_IsValid(val))) { + _internal_set_type(static_cast<::pb::GATE_TYPE>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + // optional .pb.rangeGate rg = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_rg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.polygonGate pg = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_pg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.ellipseGate eg = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_eg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.boolGate bg = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_bg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.clusterGate cg = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_cg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* gate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.gate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bool neg = 1; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_neg(), target); + } + + // required bool isTransformed = 2; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_istransformed(), target); + } + + // required bool isGained = 3; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_isgained(), target); + } + + // required .pb.GATE_TYPE type = 4; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_type(), target); + } + + // optional .pb.rangeGate rg = 5; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::rg(this), target, stream); + } + + // optional .pb.polygonGate pg = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::pg(this), target, stream); + } + + // optional .pb.ellipseGate eg = 7; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::eg(this), target, stream); + } + + // optional .pb.boolGate bg = 8; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::bg(this), target, stream); + } + + // optional .pb.clusterGate cg = 9; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::cg(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:pb.gate) + return target; +} + +size_t gate::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.gate) + size_t total_size = 0; + + if (_internal_has_neg()) { + // required bool neg = 1; + total_size += 1 + 1; + } + + if (_internal_has_istransformed()) { + // required bool isTransformed = 2; + total_size += 1 + 1; + } + + if (_internal_has_isgained()) { + // required bool isGained = 3; + total_size += 1 + 1; + } + + if (_internal_has_type()) { + // required .pb.GATE_TYPE type = 4; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + return total_size; +} +size_t gate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.gate) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x000001e0) ^ 0x000001e0) == 0) { // All required fields are present. + // required bool neg = 1; + total_size += 1 + 1; + + // required bool isTransformed = 2; + total_size += 1 + 1; + + // required bool isGained = 3; + total_size += 1 + 1; + + // required .pb.GATE_TYPE type = 4; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional .pb.rangeGate rg = 5; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rg_); + } + + // optional .pb.polygonGate pg = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *pg_); + } + + // optional .pb.ellipseGate eg = 7; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *eg_); + } + + // optional .pb.boolGate bg = 8; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bg_); + } + + // optional .pb.clusterGate cg = 9; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cg_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 gate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.gate) + GOOGLE_DCHECK_NE(&from, this); + const gate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.gate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.gate) + MergeFrom(*source); + } +} + +void gate::MergeFrom(const gate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.gate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_rg()->::pb::rangeGate::MergeFrom(from._internal_rg()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_pg()->::pb::polygonGate::MergeFrom(from._internal_pg()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_eg()->::pb::ellipseGate::MergeFrom(from._internal_eg()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_bg()->::pb::boolGate::MergeFrom(from._internal_bg()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_cg()->::pb::clusterGate::MergeFrom(from._internal_cg()); + } + if (cached_has_bits & 0x00000020u) { + neg_ = from.neg_; + } + if (cached_has_bits & 0x00000040u) { + istransformed_ = from.istransformed_; + } + if (cached_has_bits & 0x00000080u) { + isgained_ = from.isgained_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + _internal_set_type(from._internal_type()); + } +} + +void gate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.gate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void gate::CopyFrom(const gate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.gate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool gate::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (_internal_has_rg()) { + if (!rg_->IsInitialized()) return false; + } + if (_internal_has_pg()) { + if (!pg_->IsInitialized()) return false; + } + if (_internal_has_eg()) { + if (!eg_->IsInitialized()) return false; + } + if (_internal_has_bg()) { + if (!bg_->IsInitialized()) return false; + } + if (_internal_has_cg()) { + if (!cg_->IsInitialized()) return false; + } + return true; +} + +void gate::InternalSwap(gate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(gate, isgained_) + + sizeof(gate::isgained_) + - PROTOBUF_FIELD_OFFSET(gate, rg_)>( + reinterpret_cast(&rg_), + reinterpret_cast(&other->rg_)); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata gate::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void POPSTATS::InitAsDefaultInstance() { +} +class POPSTATS::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_stattype(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_statval(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; + } +}; + +POPSTATS::POPSTATS(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.POPSTATS) +} +POPSTATS::POPSTATS(const POPSTATS& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + stattype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_stattype()) { + stattype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_stattype(), + GetArena()); + } + statval_ = from.statval_; + // @@protoc_insertion_point(copy_constructor:pb.POPSTATS) +} + +void POPSTATS::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_POPSTATS_GatingSet_2eproto.base); + stattype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + statval_ = 0; +} + +POPSTATS::~POPSTATS() { + // @@protoc_insertion_point(destructor:pb.POPSTATS) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void POPSTATS::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + stattype_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void POPSTATS::ArenaDtor(void* object) { + POPSTATS* _this = reinterpret_cast< POPSTATS* >(object); + (void)_this; +} +void POPSTATS::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void POPSTATS::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const POPSTATS& POPSTATS::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_POPSTATS_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void POPSTATS::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.POPSTATS) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + stattype_.ClearNonDefaultToEmpty(); + } + statval_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* POPSTATS::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string statType = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_stattype(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.POPSTATS.statType"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // required float statVal = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_statval(&has_bits); + statval_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* POPSTATS::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.POPSTATS) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string statType = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_stattype().data(), static_cast(this->_internal_stattype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.POPSTATS.statType"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_stattype(), target); + } + + // required float statVal = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_statval(), 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:pb.POPSTATS) + return target; +} + +size_t POPSTATS::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.POPSTATS) + size_t total_size = 0; + + if (_internal_has_stattype()) { + // required string statType = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stattype()); + } + + if (_internal_has_statval()) { + // required float statVal = 2; + total_size += 1 + 4; + } + + return total_size; +} +size_t POPSTATS::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.POPSTATS) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present. + // required string statType = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_stattype()); + + // required float statVal = 2; + total_size += 1 + 4; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::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 POPSTATS::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.POPSTATS) + GOOGLE_DCHECK_NE(&from, this); + const POPSTATS* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.POPSTATS) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.POPSTATS) + MergeFrom(*source); + } +} + +void POPSTATS::MergeFrom(const POPSTATS& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.POPSTATS) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_stattype(from._internal_stattype()); + } + if (cached_has_bits & 0x00000002u) { + statval_ = from.statval_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void POPSTATS::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.POPSTATS) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void POPSTATS::CopyFrom(const POPSTATS& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.POPSTATS) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool POPSTATS::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void POPSTATS::InternalSwap(POPSTATS* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + stattype_.Swap(&other->stattype_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(statval_, other->statval_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata POPSTATS::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void calibrationTable::InitAsDefaultInstance() { +} +class calibrationTable::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_spline_method(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_caltype(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_flag(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +calibrationTable::calibrationTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + x_(arena), + y_(arena), + b_(arena), + c_(arena), + d_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.calibrationTable) +} +calibrationTable::calibrationTable(const calibrationTable& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + x_(from.x_), + y_(from.y_), + b_(from.b_), + c_(from.c_), + d_(from.d_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + caltype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_caltype()) { + caltype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_caltype(), + GetArena()); + } + ::memcpy(&spline_method_, &from.spline_method_, + static_cast(reinterpret_cast(&flag_) - + reinterpret_cast(&spline_method_)) + sizeof(flag_)); + // @@protoc_insertion_point(copy_constructor:pb.calibrationTable) +} + +void calibrationTable::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_calibrationTable_GatingSet_2eproto.base); + caltype_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&spline_method_, 0, static_cast( + reinterpret_cast(&flag_) - + reinterpret_cast(&spline_method_)) + sizeof(flag_)); +} + +calibrationTable::~calibrationTable() { + // @@protoc_insertion_point(destructor:pb.calibrationTable) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void calibrationTable::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + caltype_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void calibrationTable::ArenaDtor(void* object) { + calibrationTable* _this = reinterpret_cast< calibrationTable* >(object); + (void)_this; +} +void calibrationTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void calibrationTable::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const calibrationTable& calibrationTable::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_calibrationTable_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void calibrationTable::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.calibrationTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + x_.Clear(); + y_.Clear(); + b_.Clear(); + c_.Clear(); + d_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + caltype_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&spline_method_, 0, static_cast( + reinterpret_cast(&flag_) - + reinterpret_cast(&spline_method_)) + sizeof(flag_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* calibrationTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated float x = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_x(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13) { + _internal_add_x(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float y = 2 [packed = true]; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_y(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21) { + _internal_add_y(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float b = 3 [packed = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_b(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29) { + _internal_add_b(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float c = 4 [packed = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_c(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) { + _internal_add_c(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float d = 5 [packed = true]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_d(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45) { + _internal_add_d(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional uint32 spline_method = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_spline_method(&has_bits); + spline_method_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string caltype = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + auto str = _internal_mutable_caltype(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.calibrationTable.caltype"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool flag = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_flag(&has_bits); + flag_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* calibrationTable::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.calibrationTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated float x = 1 [packed = true]; + if (this->_internal_x_size() > 0) { + target = stream->WriteFixedPacked(1, _internal_x(), target); + } + + // repeated float y = 2 [packed = true]; + if (this->_internal_y_size() > 0) { + target = stream->WriteFixedPacked(2, _internal_y(), target); + } + + // repeated float b = 3 [packed = true]; + if (this->_internal_b_size() > 0) { + target = stream->WriteFixedPacked(3, _internal_b(), target); + } + + // repeated float c = 4 [packed = true]; + if (this->_internal_c_size() > 0) { + target = stream->WriteFixedPacked(4, _internal_c(), target); + } + + // repeated float d = 5 [packed = true]; + if (this->_internal_d_size() > 0) { + target = stream->WriteFixedPacked(5, _internal_d(), target); + } + + cached_has_bits = _has_bits_[0]; + // optional uint32 spline_method = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_spline_method(), target); + } + + // optional string caltype = 7; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_caltype().data(), static_cast(this->_internal_caltype().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.calibrationTable.caltype"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_caltype(), target); + } + + // optional bool flag = 8; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_flag(), 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:pb.calibrationTable) + return target; +} + +size_t calibrationTable::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.calibrationTable) + size_t 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 float x = 1 [packed = true]; + { + unsigned int count = static_cast(this->_internal_x_size()); + size_t data_size = 4UL * count; + 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); + _x_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float y = 2 [packed = true]; + { + unsigned int count = static_cast(this->_internal_y_size()); + size_t data_size = 4UL * count; + 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); + _y_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float b = 3 [packed = true]; + { + unsigned int count = static_cast(this->_internal_b_size()); + size_t data_size = 4UL * count; + 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); + _b_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float c = 4 [packed = true]; + { + unsigned int count = static_cast(this->_internal_c_size()); + size_t data_size = 4UL * count; + 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); + _c_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float d = 5 [packed = true]; + { + unsigned int count = static_cast(this->_internal_d_size()); + size_t data_size = 4UL * count; + 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); + _d_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string caltype = 7; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_caltype()); + } + + // optional uint32 spline_method = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_spline_method()); + } + + // optional bool flag = 8; + if (cached_has_bits & 0x00000004u) { + 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 calibrationTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.calibrationTable) + GOOGLE_DCHECK_NE(&from, this); + const calibrationTable* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.calibrationTable) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.calibrationTable) + MergeFrom(*source); + } +} + +void calibrationTable::MergeFrom(const calibrationTable& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.calibrationTable) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + x_.MergeFrom(from.x_); + y_.MergeFrom(from.y_); + b_.MergeFrom(from.b_); + c_.MergeFrom(from.c_); + d_.MergeFrom(from.d_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_caltype(from._internal_caltype()); + } + if (cached_has_bits & 0x00000002u) { + spline_method_ = from.spline_method_; + } + if (cached_has_bits & 0x00000004u) { + flag_ = from.flag_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void calibrationTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.calibrationTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void calibrationTable::CopyFrom(const calibrationTable& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.calibrationTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool calibrationTable::IsInitialized() const { + return true; +} + +void calibrationTable::InternalSwap(calibrationTable* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + x_.InternalSwap(&other->x_); + y_.InternalSwap(&other->y_); + b_.InternalSwap(&other->b_); + c_.InternalSwap(&other->c_); + d_.InternalSwap(&other->d_); + caltype_.Swap(&other->caltype_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(calibrationTable, flag_) + + sizeof(calibrationTable::flag_) + - PROTOBUF_FIELD_OFFSET(calibrationTable, spline_method_)>( + reinterpret_cast(&spline_method_), + reinterpret_cast(&other->spline_method_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata calibrationTable::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void biexpTrans::InitAsDefaultInstance() { +} +class biexpTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_channelrange(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_pos(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_neg(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_widthbasis(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_maxvalue(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +biexpTrans::biexpTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.biexpTrans) +} +biexpTrans::biexpTrans(const biexpTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&channelrange_, &from.channelrange_, + static_cast(reinterpret_cast(&maxvalue_) - + reinterpret_cast(&channelrange_)) + sizeof(maxvalue_)); + // @@protoc_insertion_point(copy_constructor:pb.biexpTrans) +} + +void biexpTrans::SharedCtor() { + ::memset(&channelrange_, 0, static_cast( + reinterpret_cast(&maxvalue_) - + reinterpret_cast(&channelrange_)) + sizeof(maxvalue_)); +} + +biexpTrans::~biexpTrans() { + // @@protoc_insertion_point(destructor:pb.biexpTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void biexpTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void biexpTrans::ArenaDtor(void* object) { + biexpTrans* _this = reinterpret_cast< biexpTrans* >(object); + (void)_this; +} +void biexpTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void biexpTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const biexpTrans& biexpTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_biexpTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void biexpTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.biexpTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + ::memset(&channelrange_, 0, static_cast( + reinterpret_cast(&maxvalue_) - + reinterpret_cast(&channelrange_)) + sizeof(maxvalue_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* biexpTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 channelRange = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_channelrange(&has_bits); + channelrange_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional float pos = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_pos(&has_bits); + pos_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float neg = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_neg(&has_bits); + neg_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float widthBasis = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + _Internal::set_has_widthbasis(&has_bits); + widthbasis_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float maxValue = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { + _Internal::set_has_maxvalue(&has_bits); + maxvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* biexpTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.biexpTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 channelRange = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_channelrange(), target); + } + + // optional float pos = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_pos(), target); + } + + // optional float neg = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_neg(), target); + } + + // optional float widthBasis = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_widthbasis(), target); + } + + // optional float maxValue = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_maxvalue(), 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:pb.biexpTrans) + return target; +} + +size_t biexpTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.biexpTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional uint32 channelRange = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_channelrange()); + } + + // optional float pos = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float neg = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float widthBasis = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional float maxValue = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 biexpTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.biexpTrans) + GOOGLE_DCHECK_NE(&from, this); + const biexpTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.biexpTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.biexpTrans) + MergeFrom(*source); + } +} + +void biexpTrans::MergeFrom(const biexpTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.biexpTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + channelrange_ = from.channelrange_; + } + if (cached_has_bits & 0x00000002u) { + pos_ = from.pos_; + } + if (cached_has_bits & 0x00000004u) { + neg_ = from.neg_; + } + if (cached_has_bits & 0x00000008u) { + widthbasis_ = from.widthbasis_; + } + if (cached_has_bits & 0x00000010u) { + maxvalue_ = from.maxvalue_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void biexpTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.biexpTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void biexpTrans::CopyFrom(const biexpTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.biexpTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool biexpTrans::IsInitialized() const { + return true; +} + +void biexpTrans::InternalSwap(biexpTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(biexpTrans, maxvalue_) + + sizeof(biexpTrans::maxvalue_) + - PROTOBUF_FIELD_OFFSET(biexpTrans, channelrange_)>( + reinterpret_cast(&channelrange_), + reinterpret_cast(&other->channelrange_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata biexpTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void fasinhTrans::InitAsDefaultInstance() { +} +class fasinhTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_length(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_maxrange(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_t(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_a(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_m(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +fasinhTrans::fasinhTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.fasinhTrans) +} +fasinhTrans::fasinhTrans(const fasinhTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&length_, &from.length_, + static_cast(reinterpret_cast(&m_) - + reinterpret_cast(&length_)) + sizeof(m_)); + // @@protoc_insertion_point(copy_constructor:pb.fasinhTrans) +} + +void fasinhTrans::SharedCtor() { + ::memset(&length_, 0, static_cast( + reinterpret_cast(&m_) - + reinterpret_cast(&length_)) + sizeof(m_)); +} + +fasinhTrans::~fasinhTrans() { + // @@protoc_insertion_point(destructor:pb.fasinhTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void fasinhTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void fasinhTrans::ArenaDtor(void* object) { + fasinhTrans* _this = reinterpret_cast< fasinhTrans* >(object); + (void)_this; +} +void fasinhTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void fasinhTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const fasinhTrans& fasinhTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_fasinhTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void fasinhTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.fasinhTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + ::memset(&length_, 0, static_cast( + reinterpret_cast(&m_) - + reinterpret_cast(&length_)) + sizeof(m_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* fasinhTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_length(&has_bits); + length_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float maxRange = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_maxrange(&has_bits); + maxrange_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float T = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_t(&has_bits); + t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float A = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + _Internal::set_has_a(&has_bits); + a_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float M = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { + _Internal::set_has_m(&has_bits); + m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* fasinhTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.fasinhTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float length = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_length(), target); + } + + // optional float maxRange = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_maxrange(), target); + } + + // optional float T = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_t(), target); + } + + // optional float A = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_a(), target); + } + + // optional float M = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_m(), 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:pb.fasinhTrans) + return target; +} + +size_t fasinhTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.fasinhTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional float length = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float maxRange = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float T = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float A = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional float M = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 fasinhTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.fasinhTrans) + GOOGLE_DCHECK_NE(&from, this); + const fasinhTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.fasinhTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.fasinhTrans) + MergeFrom(*source); + } +} + +void fasinhTrans::MergeFrom(const fasinhTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.fasinhTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + length_ = from.length_; + } + if (cached_has_bits & 0x00000002u) { + maxrange_ = from.maxrange_; + } + if (cached_has_bits & 0x00000004u) { + t_ = from.t_; + } + if (cached_has_bits & 0x00000008u) { + a_ = from.a_; + } + if (cached_has_bits & 0x00000010u) { + m_ = from.m_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void fasinhTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.fasinhTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void fasinhTrans::CopyFrom(const fasinhTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.fasinhTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool fasinhTrans::IsInitialized() const { + return true; +} + +void fasinhTrans::InternalSwap(fasinhTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(fasinhTrans, m_) + + sizeof(fasinhTrans::m_) + - PROTOBUF_FIELD_OFFSET(fasinhTrans, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata fasinhTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void scaleTrans::InitAsDefaultInstance() { +} +class scaleTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_scale_factor(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_t_scale(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_r_scale(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +scaleTrans::scaleTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.scaleTrans) +} +scaleTrans::scaleTrans(const scaleTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&scale_factor_, &from.scale_factor_, + static_cast(reinterpret_cast(&r_scale_) - + reinterpret_cast(&scale_factor_)) + sizeof(r_scale_)); + // @@protoc_insertion_point(copy_constructor:pb.scaleTrans) +} + +void scaleTrans::SharedCtor() { + ::memset(&scale_factor_, 0, static_cast( + reinterpret_cast(&r_scale_) - + reinterpret_cast(&scale_factor_)) + sizeof(r_scale_)); +} + +scaleTrans::~scaleTrans() { + // @@protoc_insertion_point(destructor:pb.scaleTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void scaleTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void scaleTrans::ArenaDtor(void* object) { + scaleTrans* _this = reinterpret_cast< scaleTrans* >(object); + (void)_this; +} +void scaleTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void scaleTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const scaleTrans& scaleTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_scaleTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void scaleTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.scaleTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&scale_factor_, 0, static_cast( + reinterpret_cast(&r_scale_) - + reinterpret_cast(&scale_factor_)) + sizeof(r_scale_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* scaleTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float scale_factor = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_scale_factor(&has_bits); + scale_factor_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float t_scale = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_t_scale(&has_bits); + t_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float r_scale = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_r_scale(&has_bits); + r_scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* scaleTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.scaleTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float scale_factor = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_scale_factor(), target); + } + + // optional float t_scale = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_t_scale(), target); + } + + // optional float r_scale = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_r_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:pb.scaleTrans) + return target; +} + +size_t scaleTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.scaleTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional float scale_factor = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float t_scale = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float r_scale = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 scaleTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.scaleTrans) + GOOGLE_DCHECK_NE(&from, this); + const scaleTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.scaleTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.scaleTrans) + MergeFrom(*source); + } +} + +void scaleTrans::MergeFrom(const scaleTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.scaleTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + scale_factor_ = from.scale_factor_; + } + if (cached_has_bits & 0x00000002u) { + t_scale_ = from.t_scale_; + } + if (cached_has_bits & 0x00000004u) { + r_scale_ = from.r_scale_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void scaleTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.scaleTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void scaleTrans::CopyFrom(const scaleTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.scaleTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool scaleTrans::IsInitialized() const { + return true; +} + +void scaleTrans::InternalSwap(scaleTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(scaleTrans, r_scale_) + + sizeof(scaleTrans::r_scale_) + - PROTOBUF_FIELD_OFFSET(scaleTrans, scale_factor_)>( + reinterpret_cast(&scale_factor_), + reinterpret_cast(&other->scale_factor_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata scaleTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void flinTrans::InitAsDefaultInstance() { +} +class flinTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_min(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_max(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +flinTrans::flinTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.flinTrans) +} +flinTrans::flinTrans(const flinTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&min_, &from.min_, + static_cast(reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); + // @@protoc_insertion_point(copy_constructor:pb.flinTrans) +} + +void flinTrans::SharedCtor() { + ::memset(&min_, 0, static_cast( + reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); +} + +flinTrans::~flinTrans() { + // @@protoc_insertion_point(destructor:pb.flinTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void flinTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void flinTrans::ArenaDtor(void* object) { + flinTrans* _this = reinterpret_cast< flinTrans* >(object); + (void)_this; +} +void flinTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void flinTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const flinTrans& flinTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_flinTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void flinTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.flinTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&min_, 0, static_cast( + reinterpret_cast(&max_) - + reinterpret_cast(&min_)) + sizeof(max_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* flinTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float min = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_min(&has_bits); + min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float max = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_max(&has_bits); + max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* flinTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.flinTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float min = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_min(), target); + } + + // optional float max = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_max(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:pb.flinTrans) + return target; +} + +size_t flinTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.flinTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional float min = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float max = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 flinTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.flinTrans) + GOOGLE_DCHECK_NE(&from, this); + const flinTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.flinTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.flinTrans) + MergeFrom(*source); + } +} + +void flinTrans::MergeFrom(const flinTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.flinTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + min_ = from.min_; + } + if (cached_has_bits & 0x00000002u) { + max_ = from.max_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void flinTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.flinTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void flinTrans::CopyFrom(const flinTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.flinTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool flinTrans::IsInitialized() const { + return true; +} + +void flinTrans::InternalSwap(flinTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(flinTrans, max_) + + sizeof(flinTrans::max_) + - PROTOBUF_FIELD_OFFSET(flinTrans, min_)>( + reinterpret_cast(&min_), + reinterpret_cast(&other->min_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata flinTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void logTrans::InitAsDefaultInstance() { +} +class logTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_offset(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_decade(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_t(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_scale(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +logTrans::logTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.logTrans) +} +logTrans::logTrans(const logTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&offset_, &from.offset_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&offset_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:pb.logTrans) +} + +void logTrans::SharedCtor() { + ::memset(&offset_, 0, static_cast( + reinterpret_cast(&scale_) - + reinterpret_cast(&offset_)) + sizeof(scale_)); +} + +logTrans::~logTrans() { + // @@protoc_insertion_point(destructor:pb.logTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void logTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void logTrans::ArenaDtor(void* object) { + logTrans* _this = reinterpret_cast< logTrans* >(object); + (void)_this; +} +void logTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void logTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const logTrans& logTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void logTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.logTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + ::memset(&offset_, 0, static_cast( + reinterpret_cast(&scale_) - + reinterpret_cast(&offset_)) + sizeof(scale_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* logTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_offset(&has_bits); + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float decade = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_decade(&has_bits); + decade_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float T = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_t(&has_bits); + t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float scale = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + _Internal::set_has_scale(&has_bits); + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* logTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.logTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float offset = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_offset(), target); + } + + // optional float decade = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_decade(), target); + } + + // optional float T = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_t(), target); + } + + // optional float scale = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, 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:pb.logTrans) + return target; +} + +size_t logTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.logTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional float offset = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float decade = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float T = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float scale = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 logTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.logTrans) + GOOGLE_DCHECK_NE(&from, this); + const logTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logTrans) + MergeFrom(*source); + } +} + +void logTrans::MergeFrom(const logTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.logTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + offset_ = from.offset_; + } + if (cached_has_bits & 0x00000002u) { + decade_ = from.decade_; + } + if (cached_has_bits & 0x00000004u) { + t_ = from.t_; + } + if (cached_has_bits & 0x00000008u) { + scale_ = from.scale_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void logTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.logTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void logTrans::CopyFrom(const logTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.logTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool logTrans::IsInitialized() const { + return true; +} + +void logTrans::InternalSwap(logTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(logTrans, scale_) + + sizeof(logTrans::scale_) + - PROTOBUF_FIELD_OFFSET(logTrans, offset_)>( + reinterpret_cast(&offset_), + reinterpret_cast(&other->offset_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata logTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void logGML2Trans::InitAsDefaultInstance() { +} +class logGML2Trans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_t(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_m(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +logGML2Trans::logGML2Trans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.logGML2Trans) +} +logGML2Trans::logGML2Trans(const logGML2Trans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&t_, &from.t_, + static_cast(reinterpret_cast(&m_) - + reinterpret_cast(&t_)) + sizeof(m_)); + // @@protoc_insertion_point(copy_constructor:pb.logGML2Trans) +} + +void logGML2Trans::SharedCtor() { + ::memset(&t_, 0, static_cast( + reinterpret_cast(&m_) - + reinterpret_cast(&t_)) + sizeof(m_)); +} + +logGML2Trans::~logGML2Trans() { + // @@protoc_insertion_point(destructor:pb.logGML2Trans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void logGML2Trans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void logGML2Trans::ArenaDtor(void* object) { + logGML2Trans* _this = reinterpret_cast< logGML2Trans* >(object); + (void)_this; +} +void logGML2Trans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void logGML2Trans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const logGML2Trans& logGML2Trans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logGML2Trans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void logGML2Trans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.logGML2Trans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&t_, 0, static_cast( + reinterpret_cast(&m_) - + reinterpret_cast(&t_)) + sizeof(m_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* logGML2Trans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float T = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_t(&has_bits); + t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float M = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_m(&has_bits); + m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* logGML2Trans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.logGML2Trans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float T = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_t(), target); + } + + // optional float M = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_m(), 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:pb.logGML2Trans) + return target; +} + +size_t logGML2Trans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.logGML2Trans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional float T = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float M = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 logGML2Trans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.logGML2Trans) + GOOGLE_DCHECK_NE(&from, this); + const logGML2Trans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logGML2Trans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logGML2Trans) + MergeFrom(*source); + } +} + +void logGML2Trans::MergeFrom(const logGML2Trans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.logGML2Trans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + t_ = from.t_; + } + if (cached_has_bits & 0x00000002u) { + m_ = from.m_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void logGML2Trans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.logGML2Trans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void logGML2Trans::CopyFrom(const logGML2Trans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.logGML2Trans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool logGML2Trans::IsInitialized() const { + return true; +} + +void logGML2Trans::InternalSwap(logGML2Trans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(logGML2Trans, m_) + + sizeof(logGML2Trans::m_) + - PROTOBUF_FIELD_OFFSET(logGML2Trans, t_)>( + reinterpret_cast(&t_), + reinterpret_cast(&other->t_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata logGML2Trans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void logicleTrans::InitAsDefaultInstance() { +} +class logicleTrans::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_t(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_w(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_m(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_a(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_bins(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_isgml2(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_isinverse(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +logicleTrans::logicleTrans(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.logicleTrans) +} +logicleTrans::logicleTrans(const logicleTrans& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&t_, &from.t_, + static_cast(reinterpret_cast(&isinverse_) - + reinterpret_cast(&t_)) + sizeof(isinverse_)); + // @@protoc_insertion_point(copy_constructor:pb.logicleTrans) +} + +void logicleTrans::SharedCtor() { + ::memset(&t_, 0, static_cast( + reinterpret_cast(&isinverse_) - + reinterpret_cast(&t_)) + sizeof(isinverse_)); +} + +logicleTrans::~logicleTrans() { + // @@protoc_insertion_point(destructor:pb.logicleTrans) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void logicleTrans::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void logicleTrans::ArenaDtor(void* object) { + logicleTrans* _this = reinterpret_cast< logicleTrans* >(object); + (void)_this; +} +void logicleTrans::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void logicleTrans::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const logicleTrans& logicleTrans::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_logicleTrans_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void logicleTrans::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.logicleTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + ::memset(&t_, 0, static_cast( + reinterpret_cast(&isinverse_) - + reinterpret_cast(&t_)) + sizeof(isinverse_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* logicleTrans::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional float T = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) { + _Internal::set_has_t(&has_bits); + t_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float W = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_w(&has_bits); + w_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float M = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + _Internal::set_has_m(&has_bits); + m_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float A = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + _Internal::set_has_a(&has_bits); + a_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional float bins = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { + _Internal::set_has_bins(&has_bits); + bins_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // optional bool isGml2 = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_isgml2(&has_bits); + isgml2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool isInverse = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_isinverse(&has_bits); + isinverse_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* logicleTrans::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.logicleTrans) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional float T = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_t(), target); + } + + // optional float W = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_w(), target); + } + + // optional float M = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_m(), target); + } + + // optional float A = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_a(), target); + } + + // optional float bins = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_bins(), target); + } + + // optional bool isGml2 = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_isgml2(), target); + } + + // optional bool isInverse = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_isinverse(), 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:pb.logicleTrans) + return target; +} + +size_t logicleTrans::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.logicleTrans) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional float T = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 4; + } + + // optional float W = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 4; + } + + // optional float M = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 4; + } + + // optional float A = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 4; + } + + // optional float bins = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + 4; + } + + // optional bool isGml2 = 6; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool isInverse = 7; + if (cached_has_bits & 0x00000040u) { + 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 logicleTrans::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.logicleTrans) + GOOGLE_DCHECK_NE(&from, this); + const logicleTrans* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.logicleTrans) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.logicleTrans) + MergeFrom(*source); + } +} + +void logicleTrans::MergeFrom(const logicleTrans& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.logicleTrans) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + t_ = from.t_; + } + if (cached_has_bits & 0x00000002u) { + w_ = from.w_; + } + if (cached_has_bits & 0x00000004u) { + m_ = from.m_; + } + if (cached_has_bits & 0x00000008u) { + a_ = from.a_; + } + if (cached_has_bits & 0x00000010u) { + bins_ = from.bins_; + } + if (cached_has_bits & 0x00000020u) { + isgml2_ = from.isgml2_; + } + if (cached_has_bits & 0x00000040u) { + isinverse_ = from.isinverse_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void logicleTrans::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.logicleTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void logicleTrans::CopyFrom(const logicleTrans& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.logicleTrans) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool logicleTrans::IsInitialized() const { + return true; +} + +void logicleTrans::InternalSwap(logicleTrans* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(logicleTrans, isinverse_) + + sizeof(logicleTrans::isinverse_) + - PROTOBUF_FIELD_OFFSET(logicleTrans, t_)>( + reinterpret_cast(&t_), + reinterpret_cast(&other->t_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata logicleTrans::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void transformation::InitAsDefaultInstance() { + ::pb::_transformation_default_instance_._instance.get_mutable()->caltbl_ = const_cast< ::pb::calibrationTable*>( + ::pb::calibrationTable::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->bt_ = const_cast< ::pb::biexpTrans*>( + ::pb::biexpTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->lt_ = const_cast< ::pb::logTrans*>( + ::pb::logTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->flt_ = const_cast< ::pb::flinTrans*>( + ::pb::flinTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->st_ = const_cast< ::pb::scaleTrans*>( + ::pb::scaleTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->ft_ = const_cast< ::pb::fasinhTrans*>( + ::pb::fasinhTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->lgt_ = const_cast< ::pb::logicleTrans*>( + ::pb::logicleTrans::internal_default_instance()); + ::pb::_transformation_default_instance_._instance.get_mutable()->lgml2t_ = const_cast< ::pb::logGML2Trans*>( + ::pb::logGML2Trans::internal_default_instance()); +} +class transformation::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::calibrationTable& caltbl(const transformation* msg); + static void set_has_caltbl(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_isgateonly(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_channel(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_iscomputed(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_trans_type(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::pb::biexpTrans& bt(const transformation* msg); + static void set_has_bt(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::pb::logTrans& lt(const transformation* msg); + static void set_has_lt(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::pb::flinTrans& flt(const transformation* msg); + static void set_has_flt(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::pb::scaleTrans& st(const transformation* msg); + static void set_has_st(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::pb::fasinhTrans& ft(const transformation* msg); + static void set_has_ft(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::pb::logicleTrans& lgt(const transformation* msg); + static void set_has_lgt(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static const ::pb::logGML2Trans& lgml2t(const transformation* msg); + static void set_has_lgml2t(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } +}; + +const ::pb::calibrationTable& +transformation::_Internal::caltbl(const transformation* msg) { + return *msg->caltbl_; +} +const ::pb::biexpTrans& +transformation::_Internal::bt(const transformation* msg) { + return *msg->bt_; +} +const ::pb::logTrans& +transformation::_Internal::lt(const transformation* msg) { + return *msg->lt_; +} +const ::pb::flinTrans& +transformation::_Internal::flt(const transformation* msg) { + return *msg->flt_; +} +const ::pb::scaleTrans& +transformation::_Internal::st(const transformation* msg) { + return *msg->st_; +} +const ::pb::fasinhTrans& +transformation::_Internal::ft(const transformation* msg) { + return *msg->ft_; +} +const ::pb::logicleTrans& +transformation::_Internal::lgt(const transformation* msg) { + return *msg->lgt_; +} +const ::pb::logGML2Trans& +transformation::_Internal::lgml2t(const transformation* msg) { + return *msg->lgml2t_; +} +transformation::transformation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.transformation) +} +transformation::transformation(const transformation& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + channel_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_channel()) { + channel_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_channel(), + GetArena()); + } + if (from._internal_has_caltbl()) { + caltbl_ = new ::pb::calibrationTable(*from.caltbl_); + } else { + caltbl_ = nullptr; + } + if (from._internal_has_bt()) { + bt_ = new ::pb::biexpTrans(*from.bt_); + } else { + bt_ = nullptr; + } + if (from._internal_has_lt()) { + lt_ = new ::pb::logTrans(*from.lt_); + } else { + lt_ = nullptr; + } + if (from._internal_has_flt()) { + flt_ = new ::pb::flinTrans(*from.flt_); + } else { + flt_ = nullptr; + } + if (from._internal_has_st()) { + st_ = new ::pb::scaleTrans(*from.st_); + } else { + st_ = nullptr; + } + if (from._internal_has_ft()) { + ft_ = new ::pb::fasinhTrans(*from.ft_); + } else { + ft_ = nullptr; + } + if (from._internal_has_lgt()) { + lgt_ = new ::pb::logicleTrans(*from.lgt_); + } else { + lgt_ = nullptr; + } + if (from._internal_has_lgml2t()) { + lgml2t_ = new ::pb::logGML2Trans(*from.lgml2t_); + } else { + lgml2t_ = nullptr; + } + ::memcpy(&trans_type_, &from.trans_type_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&trans_type_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:pb.transformation) +} + +void transformation::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_transformation_GatingSet_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + channel_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&caltbl_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&caltbl_)) + sizeof(type_)); +} + +transformation::~transformation() { + // @@protoc_insertion_point(destructor:pb.transformation) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void transformation::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + channel_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete caltbl_; + if (this != internal_default_instance()) delete bt_; + if (this != internal_default_instance()) delete lt_; + if (this != internal_default_instance()) delete flt_; + if (this != internal_default_instance()) delete st_; + if (this != internal_default_instance()) delete ft_; + if (this != internal_default_instance()) delete lgt_; + if (this != internal_default_instance()) delete lgml2t_; +} + +void transformation::ArenaDtor(void* object) { + transformation* _this = reinterpret_cast< transformation* >(object); + (void)_this; +} +void transformation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void transformation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const transformation& transformation::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_transformation_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void transformation::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.transformation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + channel_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(caltbl_ != nullptr); + caltbl_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(bt_ != nullptr); + bt_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(lt_ != nullptr); + lt_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(flt_ != nullptr); + flt_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(st_ != nullptr); + st_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(ft_ != nullptr); + ft_->Clear(); + } + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(lgt_ != nullptr); + lgt_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(lgml2t_ != nullptr); + lgml2t_->Clear(); + } + } + if (cached_has_bits & 0x00003c00u) { + ::memset(&trans_type_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&trans_type_)) + sizeof(type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* transformation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .pb.calibrationTable calTbl = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_caltbl(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool isGateOnly = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_isgateonly(&has_bits); + isgateonly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.TRANS_TYPE trans_type = 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); + if (PROTOBUF_PREDICT_TRUE(::pb::TRANS_TYPE_IsValid(val))) { + _internal_set_trans_type(static_cast<::pb::TRANS_TYPE>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + // optional string name = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.transformation.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string channel = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_channel(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.transformation.channel"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool isComputed = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_iscomputed(&has_bits); + iscomputed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.biexpTrans bt = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_bt(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.logTrans lt = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_lt(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.flinTrans flt = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_flt(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.scaleTrans st = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_st(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.fasinhTrans ft = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_ft(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 type = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + _Internal::set_has_type(&has_bits); + type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.logicleTrans lgt = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_lgt(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.logGML2Trans lgml2t = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_lgml2t(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* transformation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.transformation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .pb.calibrationTable calTbl = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::caltbl(this), target, stream); + } + + // optional bool isGateOnly = 2; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_isgateonly(), target); + } + + // optional .pb.TRANS_TYPE trans_type = 3; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_trans_type(), target); + } + + // optional string name = 4; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.transformation.name"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_name(), target); + } + + // optional string channel = 5; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_channel().data(), static_cast(this->_internal_channel().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.transformation.channel"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_channel(), target); + } + + // optional bool isComputed = 6; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_iscomputed(), target); + } + + // optional .pb.biexpTrans bt = 7; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::bt(this), target, stream); + } + + // optional .pb.logTrans lt = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::lt(this), target, stream); + } + + // optional .pb.flinTrans flt = 9; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::flt(this), target, stream); + } + + // optional .pb.scaleTrans st = 10; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::st(this), target, stream); + } + + // optional .pb.fasinhTrans ft = 11; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::ft(this), target, stream); + } + + // optional uint32 type = 12; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(12, this->_internal_type(), target); + } + + // optional .pb.logicleTrans lgt = 13; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::lgt(this), target, stream); + } + + // optional .pb.logGML2Trans lgml2t = 14; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::lgml2t(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:pb.transformation) + return target; +} + +size_t transformation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.transformation) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string channel = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_channel()); + } + + // optional .pb.calibrationTable calTbl = 1; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *caltbl_); + } + + // optional .pb.biexpTrans bt = 7; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bt_); + } + + // optional .pb.logTrans lt = 8; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lt_); + } + + // optional .pb.flinTrans flt = 9; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *flt_); + } + + // optional .pb.scaleTrans st = 10; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *st_); + } + + // optional .pb.fasinhTrans ft = 11; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *ft_); + } + + } + if (cached_has_bits & 0x00003f00u) { + // optional .pb.logicleTrans lgt = 13; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lgt_); + } + + // optional .pb.logGML2Trans lgml2t = 14; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lgml2t_); + } + + // optional .pb.TRANS_TYPE trans_type = 3; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_trans_type()); + } + + // optional bool isGateOnly = 2; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + // optional bool isComputed = 6; + if (cached_has_bits & 0x00001000u) { + total_size += 1 + 1; + } + + // optional uint32 type = 12; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + 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 transformation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.transformation) + GOOGLE_DCHECK_NE(&from, this); + const transformation* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.transformation) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.transformation) + MergeFrom(*source); + } +} + +void transformation::MergeFrom(const transformation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.transformation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_channel(from._internal_channel()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_caltbl()->::pb::calibrationTable::MergeFrom(from._internal_caltbl()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_bt()->::pb::biexpTrans::MergeFrom(from._internal_bt()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_lt()->::pb::logTrans::MergeFrom(from._internal_lt()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_flt()->::pb::flinTrans::MergeFrom(from._internal_flt()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_st()->::pb::scaleTrans::MergeFrom(from._internal_st()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_ft()->::pb::fasinhTrans::MergeFrom(from._internal_ft()); + } + } + if (cached_has_bits & 0x00003f00u) { + if (cached_has_bits & 0x00000100u) { + _internal_mutable_lgt()->::pb::logicleTrans::MergeFrom(from._internal_lgt()); + } + if (cached_has_bits & 0x00000200u) { + _internal_mutable_lgml2t()->::pb::logGML2Trans::MergeFrom(from._internal_lgml2t()); + } + if (cached_has_bits & 0x00000400u) { + trans_type_ = from.trans_type_; + } + if (cached_has_bits & 0x00000800u) { + isgateonly_ = from.isgateonly_; + } + if (cached_has_bits & 0x00001000u) { + iscomputed_ = from.iscomputed_; + } + if (cached_has_bits & 0x00002000u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void transformation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.transformation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void transformation::CopyFrom(const transformation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.transformation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool transformation::IsInitialized() const { + return true; +} + +void transformation::InternalSwap(transformation* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + channel_.Swap(&other->channel_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(transformation, type_) + + sizeof(transformation::type_) + - PROTOBUF_FIELD_OFFSET(transformation, caltbl_)>( + reinterpret_cast(&caltbl_), + reinterpret_cast(&other->caltbl_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata transformation::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void trans_pair::InitAsDefaultInstance() { + ::pb::_trans_pair_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::transformation*>( + ::pb::transformation::internal_default_instance()); +} +class trans_pair::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_trans_address(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::pb::transformation& trans(const trans_pair* msg); + static void set_has_trans(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::pb::transformation& +trans_pair::_Internal::trans(const trans_pair* msg) { + return *msg->trans_; +} +trans_pair::trans_pair(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.trans_pair) +} +trans_pair::trans_pair(const trans_pair& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + if (from._internal_has_trans()) { + trans_ = new ::pb::transformation(*from.trans_); + } else { + trans_ = nullptr; + } + trans_address_ = from.trans_address_; + // @@protoc_insertion_point(copy_constructor:pb.trans_pair) +} + +void trans_pair::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_trans_pair_GatingSet_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&trans_, 0, static_cast( + reinterpret_cast(&trans_address_) - + reinterpret_cast(&trans_)) + sizeof(trans_address_)); +} + +trans_pair::~trans_pair() { + // @@protoc_insertion_point(destructor:pb.trans_pair) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void trans_pair::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete trans_; +} + +void trans_pair::ArenaDtor(void* object) { + trans_pair* _this = reinterpret_cast< trans_pair* >(object); + (void)_this; +} +void trans_pair::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void trans_pair::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const trans_pair& trans_pair::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_trans_pair_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void trans_pair::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.trans_pair) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(trans_ != nullptr); + trans_->Clear(); + } + } + trans_address_ = PROTOBUF_ULONGLONG(0); + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* trans_pair::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required 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); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.trans_pair.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint64 trans_address = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_trans_address(&has_bits); + trans_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.transformation trans = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_trans(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* trans_pair::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.trans_pair) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string name = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.trans_pair.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // optional uint64 trans_address = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_trans_address(), target); + } + + // optional .pb.transformation trans = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::trans(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:pb.trans_pair) + return target; +} + +size_t trans_pair::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.trans_pair) + size_t total_size = 0; + + // required string name = 1; + if (_internal_has_name()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000006u) { + // optional .pb.transformation trans = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *trans_); + } + + // optional uint64 trans_address = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_trans_address()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 trans_pair::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.trans_pair) + GOOGLE_DCHECK_NE(&from, this); + const trans_pair* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.trans_pair) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.trans_pair) + MergeFrom(*source); + } +} + +void trans_pair::MergeFrom(const trans_pair& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.trans_pair) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_trans()->::pb::transformation::MergeFrom(from._internal_trans()); + } + if (cached_has_bits & 0x00000004u) { + trans_address_ = from.trans_address_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void trans_pair::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.trans_pair) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void trans_pair::CopyFrom(const trans_pair& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.trans_pair) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool trans_pair::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void trans_pair::InternalSwap(trans_pair* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(trans_pair, trans_address_) + + sizeof(trans_pair::trans_address_) + - PROTOBUF_FIELD_OFFSET(trans_pair, trans_)>( + reinterpret_cast(&trans_), + reinterpret_cast(&other->trans_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata trans_pair::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void trans_local::InitAsDefaultInstance() { +} +class trans_local::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_groupname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +trans_local::trans_local(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + tp_(arena), + sampleids_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.trans_local) +} +trans_local::trans_local(const trans_local& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + tp_(from.tp_), + sampleids_(from.sampleids_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + groupname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_groupname()) { + groupname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_groupname(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:pb.trans_local) +} + +void trans_local::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_trans_local_GatingSet_2eproto.base); + groupname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +trans_local::~trans_local() { + // @@protoc_insertion_point(destructor:pb.trans_local) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void trans_local::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + groupname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void trans_local::ArenaDtor(void* object) { + trans_local* _this = reinterpret_cast< trans_local* >(object); + (void)_this; +} +void trans_local::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void trans_local::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const trans_local& trans_local::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_trans_local_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void trans_local::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.trans_local) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + tp_.Clear(); + sampleids_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + groupname_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* trans_local::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .pb.trans_pair tp = 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_tp(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // optional string groupName = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_groupname(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.trans_local.groupName"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated uint32 sampleIDs = 3 [packed = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_sampleids(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) { + _internal_add_sampleids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* trans_local::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.trans_local) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .pb.trans_pair tp = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_tp_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_tp(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional string groupName = 2; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_groupname().data(), static_cast(this->_internal_groupname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.trans_local.groupName"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_groupname(), target); + } + + // repeated uint32 sampleIDs = 3 [packed = true]; + { + int byte_size = _sampleids_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 3, _internal_sampleids(), 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:pb.trans_local) + return target; +} + +size_t trans_local::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.trans_local) + size_t 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 .pb.trans_pair tp = 1; + total_size += 1UL * this->_internal_tp_size(); + for (const auto& msg : this->tp_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated uint32 sampleIDs = 3 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->sampleids_); + 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); + _sampleids_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // optional string groupName = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_groupname()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 trans_local::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.trans_local) + GOOGLE_DCHECK_NE(&from, this); + const trans_local* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.trans_local) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.trans_local) + MergeFrom(*source); + } +} + +void trans_local::MergeFrom(const trans_local& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.trans_local) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + tp_.MergeFrom(from.tp_); + sampleids_.MergeFrom(from.sampleids_); + if (from._internal_has_groupname()) { + _internal_set_groupname(from._internal_groupname()); + } +} + +void trans_local::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.trans_local) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void trans_local::CopyFrom(const trans_local& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.trans_local) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool trans_local::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(tp_)) return false; + return true; +} + +void trans_local::InternalSwap(trans_local* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + tp_.InternalSwap(&other->tp_); + sampleids_.InternalSwap(&other->sampleids_); + groupname_.Swap(&other->groupname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata trans_local::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void POPINDICES::InitAsDefaultInstance() { +} +class POPINDICES::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_nevents(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_indtype(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_bind(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000006) ^ 0x00000006) != 0; + } +}; + +POPINDICES::POPINDICES(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + iind_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.POPINDICES) +} +POPINDICES::POPINDICES(const POPINDICES& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + iind_(from.iind_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + bind_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_bind()) { + bind_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_bind(), + GetArena()); + } + ::memcpy(&nevents_, &from.nevents_, + static_cast(reinterpret_cast(&indtype_) - + reinterpret_cast(&nevents_)) + sizeof(indtype_)); + // @@protoc_insertion_point(copy_constructor:pb.POPINDICES) +} + +void POPINDICES::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_POPINDICES_GatingSet_2eproto.base); + bind_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&nevents_, 0, static_cast( + reinterpret_cast(&indtype_) - + reinterpret_cast(&nevents_)) + sizeof(indtype_)); +} + +POPINDICES::~POPINDICES() { + // @@protoc_insertion_point(destructor:pb.POPINDICES) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void POPINDICES::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + bind_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void POPINDICES::ArenaDtor(void* object) { + POPINDICES* _this = reinterpret_cast< POPINDICES* >(object); + (void)_this; +} +void POPINDICES::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void POPINDICES::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const POPINDICES& POPINDICES::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_POPINDICES_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void POPINDICES::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.POPINDICES) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + iind_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + bind_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&nevents_, 0, static_cast( + reinterpret_cast(&indtype_) - + reinterpret_cast(&nevents_)) + sizeof(indtype_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* POPINDICES::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 nEvents = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_nevents(&has_bits); + nevents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required .pb.ind_type indtype = 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); + if (PROTOBUF_PREDICT_TRUE(::pb::ind_type_IsValid(val))) { + _internal_set_indtype(static_cast<::pb::ind_type>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else goto handle_unusual; + continue; + // repeated uint32 iInd = 3 [packed = true]; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_iind(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) { + _internal_add_iind(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes bInd = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_bind(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* POPINDICES::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.POPINDICES) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 nEvents = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_nevents(), target); + } + + // required .pb.ind_type indtype = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_indtype(), target); + } + + // repeated uint32 iInd = 3 [packed = true]; + { + int byte_size = _iind_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 3, _internal_iind(), byte_size, target); + } + } + + // optional bytes bInd = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 4, this->_internal_bind(), 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:pb.POPINDICES) + return target; +} + +size_t POPINDICES::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.POPINDICES) + size_t total_size = 0; + + if (_internal_has_nevents()) { + // required uint32 nEvents = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_nevents()); + } + + if (_internal_has_indtype()) { + // required .pb.ind_type indtype = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_indtype()); + } + + return total_size; +} +size_t POPINDICES::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.POPINDICES) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000006) ^ 0x00000006) == 0) { // All required fields are present. + // required uint32 nEvents = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_nevents()); + + // required .pb.ind_type indtype = 2; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_indtype()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated uint32 iInd = 3 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->iind_); + 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); + _iind_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // optional bytes bInd = 4; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_bind()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 POPINDICES::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.POPINDICES) + GOOGLE_DCHECK_NE(&from, this); + const POPINDICES* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.POPINDICES) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.POPINDICES) + MergeFrom(*source); + } +} + +void POPINDICES::MergeFrom(const POPINDICES& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.POPINDICES) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + iind_.MergeFrom(from.iind_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_bind(from._internal_bind()); + } + if (cached_has_bits & 0x00000002u) { + nevents_ = from.nevents_; + } + if (cached_has_bits & 0x00000004u) { + indtype_ = from.indtype_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void POPINDICES::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.POPINDICES) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void POPINDICES::CopyFrom(const POPINDICES& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.POPINDICES) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool POPINDICES::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void POPINDICES::InternalSwap(POPINDICES* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + iind_.InternalSwap(&other->iind_); + bind_.Swap(&other->bind_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(POPINDICES, indtype_) + + sizeof(POPINDICES::indtype_) + - PROTOBUF_FIELD_OFFSET(POPINDICES, nevents_)>( + reinterpret_cast(&nevents_), + reinterpret_cast(&other->nevents_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata POPINDICES::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void nodeProperties::InitAsDefaultInstance() { + ::pb::_nodeProperties_default_instance_._instance.get_mutable()->indices_ = const_cast< ::pb::POPINDICES*>( + ::pb::POPINDICES::internal_default_instance()); + ::pb::_nodeProperties_default_instance_._instance.get_mutable()->thisgate_ = const_cast< ::pb::gate*>( + ::pb::gate::internal_default_instance()); +} +class nodeProperties::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_thisname(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_hidden(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::pb::POPINDICES& indices(const nodeProperties* msg); + static void set_has_indices(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::pb::gate& thisgate(const nodeProperties* msg); + static void set_has_thisgate(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000009) ^ 0x00000009) != 0; + } +}; + +const ::pb::POPINDICES& +nodeProperties::_Internal::indices(const nodeProperties* msg) { + return *msg->indices_; +} +const ::pb::gate& +nodeProperties::_Internal::thisgate(const nodeProperties* msg) { + return *msg->thisgate_; +} +nodeProperties::nodeProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + fjstats_(arena), + fcstats_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.nodeProperties) +} +nodeProperties::nodeProperties(const nodeProperties& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + fjstats_(from.fjstats_), + fcstats_(from.fcstats_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + thisname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_thisname()) { + thisname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_thisname(), + GetArena()); + } + if (from._internal_has_indices()) { + indices_ = new ::pb::POPINDICES(*from.indices_); + } else { + indices_ = nullptr; + } + if (from._internal_has_thisgate()) { + thisgate_ = new ::pb::gate(*from.thisgate_); + } else { + thisgate_ = nullptr; + } + hidden_ = from.hidden_; + // @@protoc_insertion_point(copy_constructor:pb.nodeProperties) +} + +void nodeProperties::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_nodeProperties_GatingSet_2eproto.base); + thisname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&indices_, 0, static_cast( + reinterpret_cast(&hidden_) - + reinterpret_cast(&indices_)) + sizeof(hidden_)); +} + +nodeProperties::~nodeProperties() { + // @@protoc_insertion_point(destructor:pb.nodeProperties) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void nodeProperties::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + thisname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete indices_; + if (this != internal_default_instance()) delete thisgate_; +} + +void nodeProperties::ArenaDtor(void* object) { + nodeProperties* _this = reinterpret_cast< nodeProperties* >(object); + (void)_this; +} +void nodeProperties::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void nodeProperties::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const nodeProperties& nodeProperties::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_nodeProperties_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void nodeProperties::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.nodeProperties) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fjstats_.Clear(); + fcstats_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + thisname_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(indices_ != nullptr); + indices_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(thisgate_ != nullptr); + thisgate_->Clear(); + } + } + hidden_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* nodeProperties::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string thisName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_thisname(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.nodeProperties.thisName"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.POPSTATS fjStats = 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_fjstats(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .pb.POPSTATS fcStats = 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_fcstats(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // required bool hidden = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_hidden(&has_bits); + hidden_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.POPINDICES indices = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_indices(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.gate thisGate = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_thisgate(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* nodeProperties::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.nodeProperties) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required string thisName = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_thisname().data(), static_cast(this->_internal_thisname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.nodeProperties.thisName"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_thisname(), target); + } + + // repeated .pb.POPSTATS fjStats = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_fjstats_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_fjstats(i), target, stream); + } + + // repeated .pb.POPSTATS fcStats = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_fcstats_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_fcstats(i), target, stream); + } + + // required bool hidden = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_hidden(), target); + } + + // optional .pb.POPINDICES indices = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::indices(this), target, stream); + } + + // optional .pb.gate thisGate = 6; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::thisgate(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:pb.nodeProperties) + return target; +} + +size_t nodeProperties::RequiredFieldsByteSizeFallback() const { +// @@protoc_insertion_point(required_fields_byte_size_fallback_start:pb.nodeProperties) + size_t total_size = 0; + + if (_internal_has_thisname()) { + // required string thisName = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thisname()); + } + + if (_internal_has_hidden()) { + // required bool hidden = 4; + total_size += 1 + 1; + } + + return total_size; +} +size_t nodeProperties::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.nodeProperties) + size_t total_size = 0; + + if (((_has_bits_[0] & 0x00000009) ^ 0x00000009) == 0) { // All required fields are present. + // required string thisName = 1; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_thisname()); + + // required bool hidden = 4; + total_size += 1 + 1; + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .pb.POPSTATS fjStats = 2; + total_size += 1UL * this->_internal_fjstats_size(); + for (const auto& msg : this->fjstats_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .pb.POPSTATS fcStats = 3; + total_size += 1UL * this->_internal_fcstats_size(); + for (const auto& msg : this->fcstats_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000006u) { + // optional .pb.POPINDICES indices = 5; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *indices_); + } + + // optional .pb.gate thisGate = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *thisgate_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 nodeProperties::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.nodeProperties) + GOOGLE_DCHECK_NE(&from, this); + const nodeProperties* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.nodeProperties) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.nodeProperties) + MergeFrom(*source); + } +} + +void nodeProperties::MergeFrom(const nodeProperties& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.nodeProperties) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fjstats_.MergeFrom(from.fjstats_); + fcstats_.MergeFrom(from.fcstats_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_thisname(from._internal_thisname()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_indices()->::pb::POPINDICES::MergeFrom(from._internal_indices()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_thisgate()->::pb::gate::MergeFrom(from._internal_thisgate()); + } + if (cached_has_bits & 0x00000008u) { + hidden_ = from.hidden_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void nodeProperties::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.nodeProperties) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void nodeProperties::CopyFrom(const nodeProperties& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.nodeProperties) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool nodeProperties::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(fjstats_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(fcstats_)) return false; + if (_internal_has_indices()) { + if (!indices_->IsInitialized()) return false; + } + if (_internal_has_thisgate()) { + if (!thisgate_->IsInitialized()) return false; + } + return true; +} + +void nodeProperties::InternalSwap(nodeProperties* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + fjstats_.InternalSwap(&other->fjstats_); + fcstats_.InternalSwap(&other->fcstats_); + thisname_.Swap(&other->thisname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(nodeProperties, hidden_) + + sizeof(nodeProperties::hidden_) + - PROTOBUF_FIELD_OFFSET(nodeProperties, indices_)>( + reinterpret_cast(&indices_), + reinterpret_cast(&other->indices_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata nodeProperties::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void treeNodes::InitAsDefaultInstance() { + ::pb::_treeNodes_default_instance_._instance.get_mutable()->node_ = const_cast< ::pb::nodeProperties*>( + ::pb::nodeProperties::internal_default_instance()); +} +class treeNodes::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::nodeProperties& node(const treeNodes* msg); + static void set_has_node(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_parent(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +const ::pb::nodeProperties& +treeNodes::_Internal::node(const treeNodes* msg) { + return *msg->node_; +} +treeNodes::treeNodes(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.treeNodes) +} +treeNodes::treeNodes(const treeNodes& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_node()) { + node_ = new ::pb::nodeProperties(*from.node_); + } else { + node_ = nullptr; + } + parent_ = from.parent_; + // @@protoc_insertion_point(copy_constructor:pb.treeNodes) +} + +void treeNodes::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_treeNodes_GatingSet_2eproto.base); + ::memset(&node_, 0, static_cast( + reinterpret_cast(&parent_) - + reinterpret_cast(&node_)) + sizeof(parent_)); +} + +treeNodes::~treeNodes() { + // @@protoc_insertion_point(destructor:pb.treeNodes) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void treeNodes::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete node_; +} + +void treeNodes::ArenaDtor(void* object) { + treeNodes* _this = reinterpret_cast< treeNodes* >(object); + (void)_this; +} +void treeNodes::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void treeNodes::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const treeNodes& treeNodes::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_treeNodes_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void treeNodes::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.treeNodes) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(node_ != nullptr); + node_->Clear(); + } + parent_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* treeNodes::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required .pb.nodeProperties node = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_node(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 parent = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_parent(&has_bits); + parent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* treeNodes::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.treeNodes) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required .pb.nodeProperties node = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::node(this), target, stream); + } + + // optional uint32 parent = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_parent(), 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:pb.treeNodes) + return target; +} + +size_t treeNodes::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.treeNodes) + size_t total_size = 0; + + // required .pb.nodeProperties node = 1; + if (_internal_has_node()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *node_); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional uint32 parent = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_parent()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 treeNodes::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.treeNodes) + GOOGLE_DCHECK_NE(&from, this); + const treeNodes* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.treeNodes) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.treeNodes) + MergeFrom(*source); + } +} + +void treeNodes::MergeFrom(const treeNodes& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.treeNodes) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_node()->::pb::nodeProperties::MergeFrom(from._internal_node()); + } + if (cached_has_bits & 0x00000002u) { + parent_ = from.parent_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void treeNodes::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.treeNodes) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void treeNodes::CopyFrom(const treeNodes& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.treeNodes) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool treeNodes::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (_internal_has_node()) { + if (!node_->IsInitialized()) return false; + } + return true; +} + +void treeNodes::InternalSwap(treeNodes* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(treeNodes, parent_) + + sizeof(treeNodes::parent_) + - PROTOBUF_FIELD_OFFSET(treeNodes, node_)>( + reinterpret_cast(&node_), + reinterpret_cast(&other->node_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata treeNodes::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void populationTree::InitAsDefaultInstance() { +} +class populationTree::_Internal { + public: +}; + +populationTree::populationTree(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + node_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.populationTree) +} +populationTree::populationTree(const populationTree& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + node_(from.node_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:pb.populationTree) +} + +void populationTree::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_populationTree_GatingSet_2eproto.base); +} + +populationTree::~populationTree() { + // @@protoc_insertion_point(destructor:pb.populationTree) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void populationTree::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void populationTree::ArenaDtor(void* object) { + populationTree* _this = reinterpret_cast< populationTree* >(object); + (void)_this; +} +void populationTree::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void populationTree::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const populationTree& populationTree::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_populationTree_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void populationTree::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.populationTree) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + node_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* populationTree::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .pb.treeNodes node = 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_node(), 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 & 7) == 4 || tag == 0) { + 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* populationTree::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.populationTree) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .pb.treeNodes node = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_node_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_node(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:pb.populationTree) + return target; +} + +size_t populationTree::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.populationTree) + size_t 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 .pb.treeNodes node = 1; + total_size += 1UL * this->_internal_node_size(); + for (const auto& msg : this->node_) { + 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 populationTree::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.populationTree) + GOOGLE_DCHECK_NE(&from, this); + const populationTree* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.populationTree) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.populationTree) + MergeFrom(*source); + } +} + +void populationTree::MergeFrom(const populationTree& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.populationTree) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + node_.MergeFrom(from.node_); +} + +void populationTree::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.populationTree) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void populationTree::CopyFrom(const populationTree& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.populationTree) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool populationTree::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(node_)) return false; + return true; +} + +void populationTree::InternalSwap(populationTree* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + node_.InternalSwap(&other->node_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata populationTree::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void COMP::InitAsDefaultInstance() { +} +class COMP::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_cid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_prefix(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_suffix(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_name(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_comment(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +COMP::COMP(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + marker_(arena), + spillover_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.COMP) +} +COMP::COMP(const COMP& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + marker_(from.marker_), + spillover_(from.spillover_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + cid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cid()) { + cid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_cid(), + GetArena()); + } + prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_prefix()) { + prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_prefix(), + GetArena()); + } + suffix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_suffix()) { + suffix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_suffix(), + GetArena()); + } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(), + GetArena()); + } + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_comment()) { + comment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_comment(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:pb.COMP) +} + +void COMP::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_COMP_GatingSet_2eproto.base); + cid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + suffix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +COMP::~COMP() { + // @@protoc_insertion_point(destructor:pb.COMP) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void COMP::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + cid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + suffix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + comment_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void COMP::ArenaDtor(void* object) { + COMP* _this = reinterpret_cast< COMP* >(object); + (void)_this; +} +void COMP::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void COMP::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const COMP& COMP::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_COMP_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void COMP::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.COMP) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + marker_.Clear(); + spillover_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + cid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + prefix_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + suffix_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + comment_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* COMP::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string cid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_cid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.cid"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string prefix = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_prefix(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.prefix"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string suffix = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_suffix(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.suffix"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.name"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string comment = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_comment(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.comment"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string marker = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_marker(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.COMP.marker"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else goto handle_unusual; + continue; + // repeated float spillOver = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_spillover(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_spillover(), ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* COMP::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.COMP) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string cid = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_cid().data(), static_cast(this->_internal_cid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.cid"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_cid(), target); + } + + // optional string prefix = 2; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_prefix().data(), static_cast(this->_internal_prefix().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.prefix"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_prefix(), target); + } + + // optional string suffix = 3; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_suffix().data(), static_cast(this->_internal_suffix().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.suffix"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_suffix(), target); + } + + // optional string name = 4; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.name"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_name(), target); + } + + // optional string comment = 5; + if (cached_has_bits & 0x00000010u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_comment().data(), static_cast(this->_internal_comment().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.comment"); + target = stream->WriteStringMaybeAliased( + 5, this->_internal_comment(), target); + } + + // repeated string marker = 6; + for (int i = 0, n = this->_internal_marker_size(); i < n; i++) { + const auto& s = this->_internal_marker(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.COMP.marker"); + target = stream->WriteString(6, s, target); + } + + // repeated float spillOver = 7; + for (int i = 0, n = this->_internal_spillover_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_spillover(i), 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:pb.COMP) + return target; +} + +size_t COMP::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.COMP) + size_t 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 marker = 6; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(marker_.size()); + for (int i = 0, n = marker_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + marker_.Get(i)); + } + + // repeated float spillOver = 7; + { + unsigned int count = static_cast(this->_internal_spillover_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_spillover_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string cid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cid()); + } + + // optional string prefix = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_prefix()); + } + + // optional string suffix = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_suffix()); + } + + // optional string name = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string comment = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_comment()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 COMP::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.COMP) + GOOGLE_DCHECK_NE(&from, this); + const COMP* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.COMP) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.COMP) + MergeFrom(*source); + } +} + +void COMP::MergeFrom(const COMP& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.COMP) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + marker_.MergeFrom(from.marker_); + spillover_.MergeFrom(from.spillover_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_cid(from._internal_cid()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_prefix(from._internal_prefix()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_suffix(from._internal_suffix()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_comment(from._internal_comment()); + } + } +} + +void COMP::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.COMP) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void COMP::CopyFrom(const COMP& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.COMP) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool COMP::IsInitialized() const { + return true; +} + +void COMP::InternalSwap(COMP* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + marker_.InternalSwap(&other->marker_); + spillover_.InternalSwap(&other->spillover_); + cid_.Swap(&other->cid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + prefix_.Swap(&other->prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + suffix_.Swap(&other->suffix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + comment_.Swap(&other->comment_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata COMP::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PARAM::InitAsDefaultInstance() { +} +class PARAM::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_param(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_log(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_range(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_highvalue(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_calibrationindex(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +PARAM::PARAM(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.PARAM) +} +PARAM::PARAM(const PARAM& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_param()) { + param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_param(), + GetArena()); + } + ::memcpy(&log_, &from.log_, + static_cast(reinterpret_cast(&calibrationindex_) - + reinterpret_cast(&log_)) + sizeof(calibrationindex_)); + // @@protoc_insertion_point(copy_constructor:pb.PARAM) +} + +void PARAM::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PARAM_GatingSet_2eproto.base); + param_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&log_, 0, static_cast( + reinterpret_cast(&calibrationindex_) - + reinterpret_cast(&log_)) + sizeof(calibrationindex_)); +} + +PARAM::~PARAM() { + // @@protoc_insertion_point(destructor:pb.PARAM) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void PARAM::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + param_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PARAM::ArenaDtor(void* object) { + PARAM* _this = reinterpret_cast< PARAM* >(object); + (void)_this; +} +void PARAM::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PARAM::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PARAM& PARAM::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PARAM_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void PARAM::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.PARAM) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + param_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000001eu) { + ::memset(&log_, 0, static_cast( + reinterpret_cast(&calibrationindex_) - + reinterpret_cast(&log_)) + sizeof(calibrationindex_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PARAM::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string param = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_param(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.PARAM.param"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool log = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_log(&has_bits); + log_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 range = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_range(&has_bits); + range_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 highValue = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_highvalue(&has_bits); + highvalue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 calibrationIndex = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_calibrationindex(&has_bits); + calibrationindex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* PARAM::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.PARAM) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string param = 1; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_param().data(), static_cast(this->_internal_param().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.PARAM.param"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_param(), target); + } + + // optional bool log = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_log(), target); + } + + // optional uint32 range = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_range(), target); + } + + // optional uint32 highValue = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_highvalue(), target); + } + + // optional uint32 calibrationIndex = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_calibrationindex(), 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:pb.PARAM) + return target; +} + +size_t PARAM::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.PARAM) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string param = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_param()); + } + + // optional bool log = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + // optional uint32 range = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_range()); + } + + // optional uint32 highValue = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_highvalue()); + } + + // optional uint32 calibrationIndex = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_calibrationindex()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 PARAM::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.PARAM) + GOOGLE_DCHECK_NE(&from, this); + const PARAM* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.PARAM) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.PARAM) + MergeFrom(*source); + } +} + +void PARAM::MergeFrom(const PARAM& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.PARAM) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_param(from._internal_param()); + } + if (cached_has_bits & 0x00000002u) { + log_ = from.log_; + } + if (cached_has_bits & 0x00000004u) { + range_ = from.range_; + } + if (cached_has_bits & 0x00000008u) { + highvalue_ = from.highvalue_; + } + if (cached_has_bits & 0x00000010u) { + calibrationindex_ = from.calibrationindex_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void PARAM::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.PARAM) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PARAM::CopyFrom(const PARAM& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.PARAM) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PARAM::IsInitialized() const { + return true; +} + +void PARAM::InternalSwap(PARAM* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + param_.Swap(&other->param_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PARAM, calibrationindex_) + + sizeof(PARAM::calibrationindex_) + - PROTOBUF_FIELD_OFFSET(PARAM, log_)>( + reinterpret_cast(&log_), + reinterpret_cast(&other->log_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PARAM::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GatingHierarchy::InitAsDefaultInstance() { + ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->tree_ = const_cast< ::pb::populationTree*>( + ::pb::populationTree::internal_default_instance()); + ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->comp_ = const_cast< ::pb::COMP*>( + ::pb::COMP::internal_default_instance()); + ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::trans_local*>( + ::pb::trans_local::internal_default_instance()); + ::pb::_GatingHierarchy_default_instance_._instance.get_mutable()->frame_ = const_cast< ::pb::CytoFrame*>( + ::pb::CytoFrame::internal_default_instance()); +} +class GatingHierarchy::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::pb::populationTree& tree(const GatingHierarchy* msg); + static void set_has_tree(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::pb::COMP& comp(const GatingHierarchy* msg); + static void set_has_comp(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_isloaded(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::pb::trans_local& trans(const GatingHierarchy* msg); + static void set_has_trans(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::pb::CytoFrame& frame(const GatingHierarchy* msg); + static void set_has_frame(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000002) ^ 0x00000002) != 0; + } +}; + +const ::pb::populationTree& +GatingHierarchy::_Internal::tree(const GatingHierarchy* msg) { + return *msg->tree_; +} +const ::pb::COMP& +GatingHierarchy::_Internal::comp(const GatingHierarchy* msg) { + return *msg->comp_; +} +const ::pb::trans_local& +GatingHierarchy::_Internal::trans(const GatingHierarchy* msg) { + return *msg->trans_; +} +const ::pb::CytoFrame& +GatingHierarchy::_Internal::frame(const GatingHierarchy* msg) { + return *msg->frame_; +} +GatingHierarchy::GatingHierarchy(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + transflag_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.GatingHierarchy) +} +GatingHierarchy::GatingHierarchy(const GatingHierarchy& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + transflag_(from.transflag_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_comp()) { + comp_ = new ::pb::COMP(*from.comp_); + } else { + comp_ = nullptr; + } + if (from._internal_has_tree()) { + tree_ = new ::pb::populationTree(*from.tree_); + } else { + tree_ = nullptr; + } + if (from._internal_has_trans()) { + trans_ = new ::pb::trans_local(*from.trans_); + } else { + trans_ = nullptr; + } + if (from._internal_has_frame()) { + frame_ = new ::pb::CytoFrame(*from.frame_); + } else { + frame_ = nullptr; + } + isloaded_ = from.isloaded_; + // @@protoc_insertion_point(copy_constructor:pb.GatingHierarchy) +} + +void GatingHierarchy::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GatingHierarchy_GatingSet_2eproto.base); + ::memset(&comp_, 0, static_cast( + reinterpret_cast(&isloaded_) - + reinterpret_cast(&comp_)) + sizeof(isloaded_)); +} + +GatingHierarchy::~GatingHierarchy() { + // @@protoc_insertion_point(destructor:pb.GatingHierarchy) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void GatingHierarchy::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete comp_; + if (this != internal_default_instance()) delete tree_; + if (this != internal_default_instance()) delete trans_; + if (this != internal_default_instance()) delete frame_; +} + +void GatingHierarchy::ArenaDtor(void* object) { + GatingHierarchy* _this = reinterpret_cast< GatingHierarchy* >(object); + (void)_this; +} +void GatingHierarchy::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void GatingHierarchy::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GatingHierarchy& GatingHierarchy::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GatingHierarchy_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void GatingHierarchy::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.GatingHierarchy) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + transflag_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(comp_ != nullptr); + comp_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(tree_ != nullptr); + tree_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(trans_ != nullptr); + trans_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(frame_ != nullptr); + frame_->Clear(); + } + } + isloaded_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GatingHierarchy::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .pb.COMP comp = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_comp(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required .pb.populationTree tree = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_tree(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool isLoaded = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_isloaded(&has_bits); + isloaded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.PARAM transFlag = 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_transflag(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else goto handle_unusual; + continue; + // optional .pb.trans_local trans = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_trans(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.CytoFrame frame = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_frame(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* GatingHierarchy::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.GatingHierarchy) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .pb.COMP comp = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::comp(this), target, stream); + } + + // required .pb.populationTree tree = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::tree(this), target, stream); + } + + // optional bool isLoaded = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_isloaded(), target); + } + + // repeated .pb.PARAM transFlag = 4; + for (unsigned int i = 0, + n = static_cast(this->_internal_transflag_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_transflag(i), target, stream); + } + + // optional .pb.trans_local trans = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::trans(this), target, stream); + } + + // optional .pb.CytoFrame frame = 6; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::frame(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:pb.GatingHierarchy) + return target; +} + +size_t GatingHierarchy::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.GatingHierarchy) + size_t total_size = 0; + + // required .pb.populationTree tree = 2; + if (_internal_has_tree()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *tree_); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .pb.PARAM transFlag = 4; + total_size += 1UL * this->_internal_transflag_size(); + for (const auto& msg : this->transflag_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .pb.COMP comp = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *comp_); + } + + if (cached_has_bits & 0x0000001cu) { + // optional .pb.trans_local trans = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *trans_); + } + + // optional .pb.CytoFrame frame = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *frame_); + } + + // optional bool isLoaded = 3; + if (cached_has_bits & 0x00000010u) { + 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 GatingHierarchy::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.GatingHierarchy) + GOOGLE_DCHECK_NE(&from, this); + const GatingHierarchy* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.GatingHierarchy) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.GatingHierarchy) + MergeFrom(*source); + } +} + +void GatingHierarchy::MergeFrom(const GatingHierarchy& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.GatingHierarchy) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + transflag_.MergeFrom(from.transflag_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_comp()->::pb::COMP::MergeFrom(from._internal_comp()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_tree()->::pb::populationTree::MergeFrom(from._internal_tree()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_trans()->::pb::trans_local::MergeFrom(from._internal_trans()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_frame()->::pb::CytoFrame::MergeFrom(from._internal_frame()); + } + if (cached_has_bits & 0x00000010u) { + isloaded_ = from.isloaded_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void GatingHierarchy::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.GatingHierarchy) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GatingHierarchy::CopyFrom(const GatingHierarchy& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.GatingHierarchy) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GatingHierarchy::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + if (_internal_has_tree()) { + if (!tree_->IsInitialized()) return false; + } + if (_internal_has_trans()) { + if (!trans_->IsInitialized()) return false; + } + if (_internal_has_frame()) { + if (!frame_->IsInitialized()) return false; + } + return true; +} + +void GatingHierarchy::InternalSwap(GatingHierarchy* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + transflag_.InternalSwap(&other->transflag_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(GatingHierarchy, isloaded_) + + sizeof(GatingHierarchy::isloaded_) + - PROTOBUF_FIELD_OFFSET(GatingHierarchy, comp_)>( + reinterpret_cast(&comp_), + reinterpret_cast(&other->comp_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GatingHierarchy::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CytoFrame::InitAsDefaultInstance() { +} +class CytoFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_is_h5(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static bool MissingRequiredFields(const HasBits& has_bits) { + return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; + } +}; + +CytoFrame::CytoFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.CytoFrame) +} +CytoFrame::CytoFrame(const CytoFrame& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + is_h5_ = from.is_h5_; + // @@protoc_insertion_point(copy_constructor:pb.CytoFrame) +} + +void CytoFrame::SharedCtor() { + is_h5_ = false; +} + +CytoFrame::~CytoFrame() { + // @@protoc_insertion_point(destructor:pb.CytoFrame) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CytoFrame::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void CytoFrame::ArenaDtor(void* object) { + CytoFrame* _this = reinterpret_cast< CytoFrame* >(object); + (void)_this; +} +void CytoFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CytoFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CytoFrame& CytoFrame::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CytoFrame_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void CytoFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.CytoFrame) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + is_h5_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CytoFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bool is_h5 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_is_h5(&has_bits); + is_h5_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* CytoFrame::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.CytoFrame) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bool is_h5 = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_is_h5(), 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:pb.CytoFrame) + return target; +} + +size_t CytoFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.CytoFrame) + size_t total_size = 0; + + // required bool is_h5 = 1; + if (_internal_has_is_h5()) { + total_size += 1 + 1; + } + ::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 CytoFrame::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.CytoFrame) + GOOGLE_DCHECK_NE(&from, this); + const CytoFrame* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.CytoFrame) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.CytoFrame) + MergeFrom(*source); + } +} + +void CytoFrame::MergeFrom(const CytoFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.CytoFrame) + GOOGLE_DCHECK_NE(&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._internal_has_is_h5()) { + _internal_set_is_h5(from._internal_is_h5()); + } +} + +void CytoFrame::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.CytoFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CytoFrame::CopyFrom(const CytoFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.CytoFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CytoFrame::IsInitialized() const { + if (_Internal::MissingRequiredFields(_has_bits_)) return false; + return true; +} + +void CytoFrame::InternalSwap(CytoFrame* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(is_h5_, other->is_h5_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CytoFrame::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TRANS_TBL::InitAsDefaultInstance() { + ::pb::_TRANS_TBL_default_instance_._instance.get_mutable()->trans_ = const_cast< ::pb::transformation*>( + ::pb::transformation::internal_default_instance()); +} +class TRANS_TBL::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_trans_address(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::pb::transformation& trans(const TRANS_TBL* msg); + static void set_has_trans(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::pb::transformation& +TRANS_TBL::_Internal::trans(const TRANS_TBL* msg) { + return *msg->trans_; +} +TRANS_TBL::TRANS_TBL(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.TRANS_TBL) +} +TRANS_TBL::TRANS_TBL(const TRANS_TBL& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_trans()) { + trans_ = new ::pb::transformation(*from.trans_); + } else { + trans_ = nullptr; + } + trans_address_ = from.trans_address_; + // @@protoc_insertion_point(copy_constructor:pb.TRANS_TBL) +} + +void TRANS_TBL::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TRANS_TBL_GatingSet_2eproto.base); + ::memset(&trans_, 0, static_cast( + reinterpret_cast(&trans_address_) - + reinterpret_cast(&trans_)) + sizeof(trans_address_)); +} + +TRANS_TBL::~TRANS_TBL() { + // @@protoc_insertion_point(destructor:pb.TRANS_TBL) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void TRANS_TBL::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete trans_; +} + +void TRANS_TBL::ArenaDtor(void* object) { + TRANS_TBL* _this = reinterpret_cast< TRANS_TBL* >(object); + (void)_this; +} +void TRANS_TBL::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void TRANS_TBL::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TRANS_TBL& TRANS_TBL::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TRANS_TBL_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void TRANS_TBL::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.TRANS_TBL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(trans_ != nullptr); + trans_->Clear(); + } + trans_address_ = PROTOBUF_ULONGLONG(0); + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* TRANS_TBL::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint64 trans_address = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_trans_address(&has_bits); + trans_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .pb.transformation trans = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_trans(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* TRANS_TBL::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.TRANS_TBL) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint64 trans_address = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_trans_address(), target); + } + + // optional .pb.transformation trans = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::trans(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:pb.TRANS_TBL) + return target; +} + +size_t TRANS_TBL::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.TRANS_TBL) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .pb.transformation trans = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *trans_); + } + + // optional uint64 trans_address = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_trans_address()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 TRANS_TBL::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.TRANS_TBL) + GOOGLE_DCHECK_NE(&from, this); + const TRANS_TBL* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.TRANS_TBL) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.TRANS_TBL) + MergeFrom(*source); + } +} + +void TRANS_TBL::MergeFrom(const TRANS_TBL& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.TRANS_TBL) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_trans()->::pb::transformation::MergeFrom(from._internal_trans()); + } + if (cached_has_bits & 0x00000002u) { + trans_address_ = from.trans_address_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void TRANS_TBL::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.TRANS_TBL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TRANS_TBL::CopyFrom(const TRANS_TBL& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.TRANS_TBL) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TRANS_TBL::IsInitialized() const { + return true; +} + +void TRANS_TBL::InternalSwap(TRANS_TBL* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TRANS_TBL, trans_address_) + + sizeof(TRANS_TBL::trans_address_) + - PROTOBUF_FIELD_OFFSET(TRANS_TBL, trans_)>( + reinterpret_cast(&trans_), + reinterpret_cast(&other->trans_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TRANS_TBL::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GatingSet::InitAsDefaultInstance() { +} +class GatingSet::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_globalbiexptrans(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_globallintrans(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_guid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_cytolib_verion(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_pb_verion(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_h5_verion(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +GatingSet::GatingSet(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + samplename_(arena), + trans_tbl_(arena), + gtrans_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:pb.GatingSet) +} +GatingSet::GatingSet(const GatingSet& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _has_bits_(from._has_bits_), + samplename_(from.samplename_), + trans_tbl_(from.trans_tbl_), + gtrans_(from.gtrans_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + guid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_guid()) { + guid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_guid(), + GetArena()); + } + cytolib_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cytolib_verion()) { + cytolib_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_cytolib_verion(), + GetArena()); + } + pb_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_pb_verion()) { + pb_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_pb_verion(), + GetArena()); + } + h5_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_h5_verion()) { + h5_verion_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_h5_verion(), + GetArena()); + } + ::memcpy(&globalbiexptrans_, &from.globalbiexptrans_, + static_cast(reinterpret_cast(&globallintrans_) - + reinterpret_cast(&globalbiexptrans_)) + sizeof(globallintrans_)); + // @@protoc_insertion_point(copy_constructor:pb.GatingSet) +} + +void GatingSet::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GatingSet_GatingSet_2eproto.base); + guid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cytolib_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + pb_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + h5_verion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&globalbiexptrans_, 0, static_cast( + reinterpret_cast(&globallintrans_) - + reinterpret_cast(&globalbiexptrans_)) + sizeof(globallintrans_)); +} + +GatingSet::~GatingSet() { + // @@protoc_insertion_point(destructor:pb.GatingSet) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void GatingSet::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + guid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cytolib_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + pb_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + h5_verion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void GatingSet::ArenaDtor(void* object) { + GatingSet* _this = reinterpret_cast< GatingSet* >(object); + (void)_this; +} +void GatingSet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void GatingSet::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GatingSet& GatingSet::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GatingSet_GatingSet_2eproto.base); + return *internal_default_instance(); +} + + +void GatingSet::Clear() { +// @@protoc_insertion_point(message_clear_start:pb.GatingSet) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + samplename_.Clear(); + trans_tbl_.Clear(); + gtrans_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + guid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + cytolib_verion_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + pb_verion_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + h5_verion_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x00000030u) { + ::memset(&globalbiexptrans_, 0, static_cast( + reinterpret_cast(&globallintrans_) - + reinterpret_cast(&globalbiexptrans_)) + sizeof(globallintrans_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* GatingSet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string sampleName = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_samplename(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.GatingSet.sampleName"); + #endif // !NDEBUG + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // repeated .pb.TRANS_TBL trans_tbl = 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_trans_tbl(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // optional uint64 globalBiExpTrans = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_globalbiexptrans(&has_bits); + globalbiexptrans_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint64 globalLinTrans = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_globallintrans(&has_bits); + globallintrans_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .pb.trans_local gTrans = 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_gtrans(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else goto handle_unusual; + continue; + // optional string guid = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + auto str = _internal_mutable_guid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.GatingSet.guid"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string cytolib_verion = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + auto str = _internal_mutable_cytolib_verion(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.GatingSet.cytolib_verion"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string pb_verion = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + auto str = _internal_mutable_pb_verion(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.GatingSet.pb_verion"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string h5_verion = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + auto str = _internal_mutable_h5_verion(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + #ifndef NDEBUG + ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "pb.GatingSet.h5_verion"); + #endif // !NDEBUG + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* GatingSet::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:pb.GatingSet) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string sampleName = 1; + for (int i = 0, n = this->_internal_samplename_size(); i < n; i++) { + const auto& s = this->_internal_samplename(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.GatingSet.sampleName"); + target = stream->WriteString(1, s, target); + } + + // repeated .pb.TRANS_TBL trans_tbl = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_trans_tbl_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_trans_tbl(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional uint64 globalBiExpTrans = 3; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(3, this->_internal_globalbiexptrans(), target); + } + + // optional uint64 globalLinTrans = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->_internal_globallintrans(), target); + } + + // repeated .pb.trans_local gTrans = 5; + for (unsigned int i = 0, + n = static_cast(this->_internal_gtrans_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_gtrans(i), target, stream); + } + + // optional string guid = 6; + if (cached_has_bits & 0x00000001u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_guid().data(), static_cast(this->_internal_guid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.GatingSet.guid"); + target = stream->WriteStringMaybeAliased( + 6, this->_internal_guid(), target); + } + + // optional string cytolib_verion = 7; + if (cached_has_bits & 0x00000002u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_cytolib_verion().data(), static_cast(this->_internal_cytolib_verion().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.GatingSet.cytolib_verion"); + target = stream->WriteStringMaybeAliased( + 7, this->_internal_cytolib_verion(), target); + } + + // optional string pb_verion = 8; + if (cached_has_bits & 0x00000004u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_pb_verion().data(), static_cast(this->_internal_pb_verion().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.GatingSet.pb_verion"); + target = stream->WriteStringMaybeAliased( + 8, this->_internal_pb_verion(), target); + } + + // optional string h5_verion = 9; + if (cached_has_bits & 0x00000008u) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField( + this->_internal_h5_verion().data(), static_cast(this->_internal_h5_verion().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE, + "pb.GatingSet.h5_verion"); + target = stream->WriteStringMaybeAliased( + 9, this->_internal_h5_verion(), 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:pb.GatingSet) + return target; +} + +size_t GatingSet::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:pb.GatingSet) + size_t 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 sampleName = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(samplename_.size()); + for (int i = 0, n = samplename_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + samplename_.Get(i)); + } + + // repeated .pb.TRANS_TBL trans_tbl = 2; + total_size += 1UL * this->_internal_trans_tbl_size(); + for (const auto& msg : this->trans_tbl_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .pb.trans_local gTrans = 5; + total_size += 1UL * this->_internal_gtrans_size(); + for (const auto& msg : this->gtrans_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string guid = 6; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_guid()); + } + + // optional string cytolib_verion = 7; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cytolib_verion()); + } + + // optional string pb_verion = 8; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pb_verion()); + } + + // optional string h5_verion = 9; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_h5_verion()); + } + + // optional uint64 globalBiExpTrans = 3; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_globalbiexptrans()); + } + + // optional uint64 globalLinTrans = 4; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_globallintrans()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::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 GatingSet::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:pb.GatingSet) + GOOGLE_DCHECK_NE(&from, this); + const GatingSet* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:pb.GatingSet) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:pb.GatingSet) + MergeFrom(*source); + } +} + +void GatingSet::MergeFrom(const GatingSet& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:pb.GatingSet) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + samplename_.MergeFrom(from.samplename_); + trans_tbl_.MergeFrom(from.trans_tbl_); + gtrans_.MergeFrom(from.gtrans_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_guid(from._internal_guid()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_cytolib_verion(from._internal_cytolib_verion()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_pb_verion(from._internal_pb_verion()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_h5_verion(from._internal_h5_verion()); + } + if (cached_has_bits & 0x00000010u) { + globalbiexptrans_ = from.globalbiexptrans_; + } + if (cached_has_bits & 0x00000020u) { + globallintrans_ = from.globallintrans_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void GatingSet::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:pb.GatingSet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GatingSet::CopyFrom(const GatingSet& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:pb.GatingSet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GatingSet::IsInitialized() const { + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(gtrans_)) return false; + return true; +} + +void GatingSet::InternalSwap(GatingSet* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + samplename_.InternalSwap(&other->samplename_); + trans_tbl_.InternalSwap(&other->trans_tbl_); + gtrans_.InternalSwap(&other->gtrans_); + guid_.Swap(&other->guid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + cytolib_verion_.Swap(&other->cytolib_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + pb_verion_.Swap(&other->pb_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + h5_verion_.Swap(&other->h5_verion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(GatingSet, globallintrans_) + + sizeof(GatingSet::globallintrans_) + - PROTOBUF_FIELD_OFFSET(GatingSet, globalbiexptrans_)>( + reinterpret_cast(&globalbiexptrans_), + reinterpret_cast(&other->globalbiexptrans_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GatingSet::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace pb +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::pb::paramRange* Arena::CreateMaybeMessage< ::pb::paramRange >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::paramRange >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::rangeGate* Arena::CreateMaybeMessage< ::pb::rangeGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::rangeGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::paramPoly* Arena::CreateMaybeMessage< ::pb::paramPoly >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::paramPoly >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::polygonGate* Arena::CreateMaybeMessage< ::pb::polygonGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::polygonGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::coordinate* Arena::CreateMaybeMessage< ::pb::coordinate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::coordinate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::ellipseGate* Arena::CreateMaybeMessage< ::pb::ellipseGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::ellipseGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::BOOL_GATE_OP* Arena::CreateMaybeMessage< ::pb::BOOL_GATE_OP >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::BOOL_GATE_OP >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::boolGate* Arena::CreateMaybeMessage< ::pb::boolGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::boolGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::clusterGate* Arena::CreateMaybeMessage< ::pb::clusterGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::clusterGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::quadGate* Arena::CreateMaybeMessage< ::pb::quadGate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::quadGate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::gate* Arena::CreateMaybeMessage< ::pb::gate >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::gate >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::POPSTATS* Arena::CreateMaybeMessage< ::pb::POPSTATS >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::POPSTATS >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::calibrationTable* Arena::CreateMaybeMessage< ::pb::calibrationTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::calibrationTable >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::biexpTrans* Arena::CreateMaybeMessage< ::pb::biexpTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::biexpTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::fasinhTrans* Arena::CreateMaybeMessage< ::pb::fasinhTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::fasinhTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::scaleTrans* Arena::CreateMaybeMessage< ::pb::scaleTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::scaleTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::flinTrans* Arena::CreateMaybeMessage< ::pb::flinTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::flinTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::logTrans* Arena::CreateMaybeMessage< ::pb::logTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::logTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::logGML2Trans* Arena::CreateMaybeMessage< ::pb::logGML2Trans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::logGML2Trans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::logicleTrans* Arena::CreateMaybeMessage< ::pb::logicleTrans >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::logicleTrans >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::transformation* Arena::CreateMaybeMessage< ::pb::transformation >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::transformation >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::trans_pair* Arena::CreateMaybeMessage< ::pb::trans_pair >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::trans_pair >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::trans_local* Arena::CreateMaybeMessage< ::pb::trans_local >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::trans_local >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::POPINDICES* Arena::CreateMaybeMessage< ::pb::POPINDICES >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::POPINDICES >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::nodeProperties* Arena::CreateMaybeMessage< ::pb::nodeProperties >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::nodeProperties >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::treeNodes* Arena::CreateMaybeMessage< ::pb::treeNodes >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::treeNodes >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::populationTree* Arena::CreateMaybeMessage< ::pb::populationTree >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::populationTree >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::COMP* Arena::CreateMaybeMessage< ::pb::COMP >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::COMP >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::PARAM* Arena::CreateMaybeMessage< ::pb::PARAM >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::PARAM >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::GatingHierarchy* Arena::CreateMaybeMessage< ::pb::GatingHierarchy >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::GatingHierarchy >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::CytoFrame* Arena::CreateMaybeMessage< ::pb::CytoFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::CytoFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::TRANS_TBL* Arena::CreateMaybeMessage< ::pb::TRANS_TBL >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::TRANS_TBL >(arena); +} +template<> PROTOBUF_NOINLINE ::pb::GatingSet* Arena::CreateMaybeMessage< ::pb::GatingSet >(Arena* arena) { + return Arena::CreateMessageInternal< ::pb::GatingSet >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/src/Makevars.in b/src/Makevars.in index b690a05..55c71a5 100644 --- a/src/Makevars.in +++ b/src/Makevars.in @@ -3,13 +3,22 @@ PKG_CPPFLAGS =-I../inst/include/ -I@PBBUILD@/include/ USER_INCLUDE = ${R_PACKAGE_DIR}/include USER_LIB_DIR = ${R_PACKAGE_DIR}/lib${R_ARCH}/ + +#expose compiled object of GatingSet pb API for cytolib to link to +GS_LIB=libGatingSet.pb${DYLIB_EXT} +GS_LIB_DIR = GatingSet_pb_lib + all: copying +$(GS_LIB): + ${SHLIB_CXXLD} ${SHLIB_CXXLDFLAGS} ${CXXPICFLAGS} ${PKG_CPPFLAGS} -o ${GS_LIB_DIR}/${GS_LIB} ${GS_LIB_DIR}/GatingSet.pb.cc + #copy hdf5 library headers to package include -copying: +copying: $(GS_LIB) mkdir -p "${USER_INCLUDE}" cp -r @PBBUILD@/include/google ${USER_INCLUDE} mkdir -p "${USER_LIB_DIR}" cp @PBBUILD@/lib/libprotobuf* ${USER_LIB_DIR} + cp ${GS_LIB_DIR}/$(GS_LIB) ${USER_LIB_DIR}/${GS_LIB} diff --git a/src/Makevars.win b/src/Makevars.win index adb2b72..79d83db 100644 --- a/src/Makevars.win +++ b/src/Makevars.win @@ -5,10 +5,19 @@ RWINLIB=../windows/protobuf-$(VERSION) USER_INCLUDE="${R_PACKAGE_DIR}/include" USER_LIB_DIR=${R_PACKAGE_DIR}/lib$(R_ARCH) +#expose compiled object of GatingSet pb API for cytolib to link to +GS_LIB=libGatingSet.pb${DYLIB_EXT} +GS_LIB_DIR = GatingSet_pb_lib + all: copying + +$(GS_LIB): winlibs + ${SHLIB_CXXLD} ${SHLIB_CXXLDFLAGS} ${CXXPICFLAGS} ${PKG_CPPFLAGS} -o ${GS_LIB_DIR}/${GS_LIB} ${GS_LIB_DIR}/GatingSet.pb.cc + + #copy pb library headers to package include -copying: winlibs +copying: $(GS_LIB) mkdir -p ${USER_INCLUDE} cp -r $(RWINLIB)/include/google ${USER_INCLUDE} mkdir -p "${USER_LIB_DIR}"