From 05b943879d8e01e5edf28db6ae1e2a8dceb9c46b Mon Sep 17 00:00:00 2001 From: Alexandre Huff Date: Thu, 9 Dec 2021 00:29:05 -0300 Subject: [PATCH] Update TS xApp for Release E use case Issue-ID: RICAPP-182 Signed-off-by: Alexandre Huff Change-Id: I9226eed4e830f497ca5e45f49819d0e882f71308 --- CMakeLists.txt | 3 + Dockerfile | 26 +- container-tag.yaml | 2 +- docs/rel-notes.rst | 4 + ext/protobuf/CMakeLists.txt | 22 + ext/protobuf/api.grpc.pb.cc | 70 ++ ext/protobuf/api.grpc.pb.h | 182 ++++ ext/protobuf/api.pb.cc | 2016 +++++++++++++++++++++++++++++++++++++++++++ ext/protobuf/api.pb.h | 1420 ++++++++++++++++++++++++++++++ ext/protobuf/api.proto | 60 ++ src/ts_xapp/CMakeLists.txt | 4 +- src/ts_xapp/ts_xapp.cpp | 107 ++- test/app/CMakeLists.txt | 18 +- test/app/rc_xapp.cpp | 76 ++ xapp-descriptor/config.json | 13 +- xapp-descriptor/schema.json | 28 + 16 files changed, 4011 insertions(+), 40 deletions(-) create mode 100644 ext/protobuf/CMakeLists.txt create mode 100644 ext/protobuf/api.grpc.pb.cc create mode 100644 ext/protobuf/api.grpc.pb.h create mode 100644 ext/protobuf/api.pb.cc create mode 100644 ext/protobuf/api.pb.h create mode 100644 ext/protobuf/api.proto create mode 100644 test/app/rc_xapp.cpp create mode 100644 xapp-descriptor/schema.json diff --git a/CMakeLists.txt b/CMakeLists.txt index d11c6af..90d5eff 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -93,6 +93,9 @@ else() endif() unset( GPROF CACHE ) # ensure this does not persist +# protobuf and grpc stufs +add_subdirectory( ext/protobuf ) + # each binary is built from a subset add_subdirectory( src/ts_xapp ) diff --git a/Dockerfile b/Dockerfile index f443bbb..c684466 100644 --- a/Dockerfile +++ b/Dockerfile @@ -31,7 +31,7 @@ # the builder has: git, wget, cmake, gcc/g++, make, python2/3. v7 dropped nng support # -FROM nexus3.o-ran-sc.org:10002/o-ran-sc/bldr-ubuntu18-c-go:1.9.0 as buildenv +FROM nexus3.o-ran-sc.org:10002/o-ran-sc/bldr-ubuntu20-c-go:1.0.0 as buildenv # spaces to save things in the build image to copy to final image RUN mkdir -p /playpen/assets /playpen/src /playpen/bin @@ -74,9 +74,11 @@ RUN git clone https://github.com/Tencent/rapidjson && \ cd ${STAGE_DIR} && \ rm -rf rapidjson -# install TS curl dependencies -RUN apt-get update && \ - apt-get install -y libcurl4-openssl-dev +# install curl and gRPC dependencies +RUN apt-get update && apt-get install -y \ + libcurl4-openssl-dev \ + libprotobuf-dev \ + libgrpc++-dev # # build and install the application(s) @@ -99,7 +101,7 @@ COPY assets/bootstrap.rt /playpen/assets # ----- create final, smaller, image ---------------------------------- -FROM ubuntu:18.04 +FROM ubuntu:20.04 # # package cloud urls for wget # ARG PC_REL_URL=https://packagecloud.io/o-ran-sc/release/packages/debian/stretch @@ -116,10 +118,13 @@ FROM ubuntu:18.04 # RUN rm -fr /var/lib/apt/lists -# install TS curl dependencies in the final image -RUN apt-get update && \ - apt-get install -y libcurl4-openssl-dev && \ - apt-get clean +# install curl and gRPC dependencies in the final image +RUN apt-get update && apt-get install -y \ + libcurl4-openssl-dev \ + libprotobuf-dev \ + libgrpc++-dev && \ + rm -rf /var/lib/apt/lists/* + # snarf the various sdl, rmr, and cpp-framework libraries as well as any binaries # created (e.g. rmr_rprobe) and the application binary itself @@ -143,7 +148,4 @@ ENV RMR_SRC_ID=service-ricxapp-trafficxapp-rmr.ricxapp:4560 ENV RMR_VCTL_FILE=/tmp/rmr.v RUN echo "2" >/tmp/rmr.v -# set TS env vars -ENV TS_CONTROL_URL=http://localhost:5000/api/echo - CMD [ "/usr/local/bin/ts_xapp" ] diff --git a/container-tag.yaml b/container-tag.yaml index 5963b56..145646b 100644 --- a/container-tag.yaml +++ b/container-tag.yaml @@ -1,3 +1,3 @@ # this is used by CI jobs to apply a tag when it builds the image --- -tag: '1.1.1' +tag: '1.2.0' diff --git a/docs/rel-notes.rst b/docs/rel-notes.rst index 8f5e27b..ec78ea2 100644 --- a/docs/rel-notes.rst +++ b/docs/rel-notes.rst @@ -9,6 +9,10 @@ Traffic Steering xAPP ===================== +2021 Dec 8 Version 1.2.0 +-------------------------- + Update TS xApp for Release E use case and changes to integrate with RC xApp + 2021 June 24 Version 1.1.1 -------------------------- Fixes the extra nil character sent in RMR payload and other potential bugs diff --git a/ext/protobuf/CMakeLists.txt b/ext/protobuf/CMakeLists.txt new file mode 100644 index 0000000..79f9c59 --- /dev/null +++ b/ext/protobuf/CMakeLists.txt @@ -0,0 +1,22 @@ +# ================================================================================== +# Copyright (c) 2021 AT&T Intellectual Property. +# Copyright (c) 2021 Alexandre Huff. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ================================================================================== +# +# Date: 07 Dec 2021 +# Author: Alexandre Huff + +add_library( rc-api STATIC api.pb.h api.pb.cc api.grpc.pb.h api.grpc.pb.cc ) +target_include_directories( rc-api PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}") diff --git a/ext/protobuf/api.grpc.pb.cc b/ext/protobuf/api.grpc.pb.cc new file mode 100644 index 0000000..ac1f186 --- /dev/null +++ b/ext/protobuf/api.grpc.pb.cc @@ -0,0 +1,70 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: api.proto + +#include "api.pb.h" +#include "api.grpc.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace api { + +static const char* MsgComm_method_names[] = { + "/api.MsgComm/SendRICControlReqServiceGrpc", +}; + +std::unique_ptr< MsgComm::Stub> MsgComm::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { + (void)options; + std::unique_ptr< MsgComm::Stub> stub(new MsgComm::Stub(channel)); + return stub; +} + +MsgComm::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) + : channel_(channel), rpcmethod_SendRICControlReqServiceGrpc_(MsgComm_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + {} + +::grpc::Status MsgComm::Stub::SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::api::RicControlGrpcRsp* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_SendRICControlReqServiceGrpc_, context, request, response); +} + +void MsgComm::Stub::experimental_async::SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response, std::function f) { + return ::grpc::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SendRICControlReqServiceGrpc_, context, request, response, std::move(f)); +} + +::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>* MsgComm::Stub::AsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< ::api::RicControlGrpcRsp>::Create(channel_.get(), cq, rpcmethod_SendRICControlReqServiceGrpc_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>* MsgComm::Stub::PrepareAsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< ::api::RicControlGrpcRsp>::Create(channel_.get(), cq, rpcmethod_SendRICControlReqServiceGrpc_, context, request, false); +} + +MsgComm::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + MsgComm_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MsgComm::Service, ::api::RicControlGrpcReq, ::api::RicControlGrpcRsp>( + std::mem_fn(&MsgComm::Service::SendRICControlReqServiceGrpc), this))); +} + +MsgComm::Service::~Service() { +} + +::grpc::Status MsgComm::Service::SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace api + diff --git a/ext/protobuf/api.grpc.pb.h b/ext/protobuf/api.grpc.pb.h new file mode 100644 index 0000000..d27749e --- /dev/null +++ b/ext/protobuf/api.grpc.pb.h @@ -0,0 +1,182 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: api.proto +#ifndef GRPC_api_2eproto__INCLUDED +#define GRPC_api_2eproto__INCLUDED + +#include "api.pb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc { +class CompletionQueue; +class Channel; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc + +namespace api { + +// Services to send gRPC +class MsgComm final { + public: + static constexpr char const* service_full_name() { + return "api.MsgComm"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + // gRPC call to Send RICControlReqServiceGrpc + virtual ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::api::RicControlGrpcRsp* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>> AsyncSendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>>(AsyncSendRICControlReqServiceGrpcRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>> PrepareAsyncSendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>>(PrepareAsyncSendRICControlReqServiceGrpcRaw(context, request, cq)); + } + class experimental_async_interface { + public: + virtual ~experimental_async_interface() {} + // gRPC call to Send RICControlReqServiceGrpc + virtual void SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response, std::function) = 0; + }; + virtual class experimental_async_interface* experimental_async() { return nullptr; } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>* AsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::api::RicControlGrpcRsp>* PrepareAsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::api::RicControlGrpcRsp* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>> AsyncSendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>>(AsyncSendRICControlReqServiceGrpcRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>> PrepareAsyncSendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>>(PrepareAsyncSendRICControlReqServiceGrpcRaw(context, request, cq)); + } + class experimental_async final : + public StubInterface::experimental_async_interface { + public: + void SendRICControlReqServiceGrpc(::grpc::ClientContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response, std::function) override; + private: + friend class Stub; + explicit experimental_async(Stub* stub): stub_(stub) { } + Stub* stub() { return stub_; } + Stub* stub_; + }; + class experimental_async_interface* experimental_async() override { return &async_stub_; } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + class experimental_async async_stub_{this}; + ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>* AsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::api::RicControlGrpcRsp>* PrepareAsyncSendRICControlReqServiceGrpcRaw(::grpc::ClientContext* context, const ::api::RicControlGrpcReq& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_SendRICControlReqServiceGrpc_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + // gRPC call to Send RICControlReqServiceGrpc + virtual ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response); + }; + template + class WithAsyncMethod_SendRICControlReqServiceGrpc : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service *service) {} + public: + WithAsyncMethod_SendRICControlReqServiceGrpc() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_SendRICControlReqServiceGrpc() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSendRICControlReqServiceGrpc(::grpc::ServerContext* context, ::api::RicControlGrpcReq* request, ::grpc::ServerAsyncResponseWriter< ::api::RicControlGrpcRsp>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_SendRICControlReqServiceGrpc AsyncService; + template + class WithGenericMethod_SendRICControlReqServiceGrpc : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service *service) {} + public: + WithGenericMethod_SendRICControlReqServiceGrpc() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_SendRICControlReqServiceGrpc() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithRawMethod_SendRICControlReqServiceGrpc : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service *service) {} + public: + WithRawMethod_SendRICControlReqServiceGrpc() { + ::grpc::Service::MarkMethodRaw(0); + } + ~WithRawMethod_SendRICControlReqServiceGrpc() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestSendRICControlReqServiceGrpc(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithStreamedUnaryMethod_SendRICControlReqServiceGrpc : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service *service) {} + public: + WithStreamedUnaryMethod_SendRICControlReqServiceGrpc() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< ::api::RicControlGrpcReq, ::api::RicControlGrpcRsp>(std::bind(&WithStreamedUnaryMethod_SendRICControlReqServiceGrpc::StreamedSendRICControlReqServiceGrpc, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_SendRICControlReqServiceGrpc() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, ::api::RicControlGrpcRsp* response) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedSendRICControlReqServiceGrpc(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::api::RicControlGrpcReq,::api::RicControlGrpcRsp>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_SendRICControlReqServiceGrpc StreamedUnaryService; + typedef Service SplitStreamedService; + typedef WithStreamedUnaryMethod_SendRICControlReqServiceGrpc StreamedService; +}; + +} // namespace api + + +#endif // GRPC_api_2eproto__INCLUDED diff --git a/ext/protobuf/api.pb.cc b/ext/protobuf/api.pb.cc new file mode 100644 index 0000000..67f9f11 --- /dev/null +++ b/ext/protobuf/api.pb.cc @@ -0,0 +1,2016 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: api.proto + +#include "api.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +// This is a temporary google only hack +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS +#include "third_party/protobuf/version.h" +#endif +// @@protoc_insertion_point(includes) + +namespace protobuf_api_2eproto { +extern PROTOBUF_INTERNAL_EXPORT_protobuf_api_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_RICControlHeader; +extern PROTOBUF_INTERNAL_EXPORT_protobuf_api_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_RICControlMessage; +extern PROTOBUF_INTERNAL_EXPORT_protobuf_api_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_RICE2APHeader; +} // namespace protobuf_api_2eproto +namespace api { +class RICE2APHeaderDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RICE2APHeader_default_instance_; +class RICControlHeaderDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RICControlHeader_default_instance_; +class RICControlMessageDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RICControlMessage_default_instance_; +class RicControlGrpcReqDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RicControlGrpcReq_default_instance_; +class RicControlGrpcRspDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _RicControlGrpcRsp_default_instance_; +} // namespace api +namespace protobuf_api_2eproto { +static void InitDefaultsRICE2APHeader() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::api::_RICE2APHeader_default_instance_; + new (ptr) ::api::RICE2APHeader(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::api::RICE2APHeader::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_RICE2APHeader = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRICE2APHeader}, {}}; + +static void InitDefaultsRICControlHeader() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::api::_RICControlHeader_default_instance_; + new (ptr) ::api::RICControlHeader(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::api::RICControlHeader::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_RICControlHeader = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRICControlHeader}, {}}; + +static void InitDefaultsRICControlMessage() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::api::_RICControlMessage_default_instance_; + new (ptr) ::api::RICControlMessage(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::api::RICControlMessage::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_RICControlMessage = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRICControlMessage}, {}}; + +static void InitDefaultsRicControlGrpcReq() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::api::_RicControlGrpcReq_default_instance_; + new (ptr) ::api::RicControlGrpcReq(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::api::RicControlGrpcReq::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<3> scc_info_RicControlGrpcReq = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsRicControlGrpcReq}, { + &protobuf_api_2eproto::scc_info_RICE2APHeader.base, + &protobuf_api_2eproto::scc_info_RICControlHeader.base, + &protobuf_api_2eproto::scc_info_RICControlMessage.base,}}; + +static void InitDefaultsRicControlGrpcRsp() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::api::_RicControlGrpcRsp_default_instance_; + new (ptr) ::api::RicControlGrpcRsp(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::api::RicControlGrpcRsp::InitAsDefaultInstance(); +} + +::google::protobuf::internal::SCCInfo<0> scc_info_RicControlGrpcRsp = + {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRicControlGrpcRsp}, {}}; + +void InitDefaults() { + ::google::protobuf::internal::InitSCC(&scc_info_RICE2APHeader.base); + ::google::protobuf::internal::InitSCC(&scc_info_RICControlHeader.base); + ::google::protobuf::internal::InitSCC(&scc_info_RICControlMessage.base); + ::google::protobuf::internal::InitSCC(&scc_info_RicControlGrpcReq.base); + ::google::protobuf::internal::InitSCC(&scc_info_RicControlGrpcRsp.base); +} + +::google::protobuf::Metadata file_level_metadata[5]; +const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[2]; + +const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICE2APHeader, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICE2APHeader, ranfuncid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICE2APHeader, ricrequestorid_), + ~0u, // no _has_bits_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlHeader, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlHeader, controlstyle_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlHeader, controlactionid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlHeader, ueid_), + ~0u, // no _has_bits_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlMessage, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlMessage, riccontrolcelltypeval_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RICControlMessage, targetcellid_), + ~0u, // no _has_bits_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, e2nodeid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, plmnid_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, ranname_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, rice2apheaderdata_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, riccontrolheaderdata_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, riccontrolmessagedata_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcReq, riccontrolackreqval_), + ~0u, // no _has_bits_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcRsp, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcRsp, rspcode_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::api::RicControlGrpcRsp, description_), +}; +static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::api::RICE2APHeader)}, + { 7, -1, sizeof(::api::RICControlHeader)}, + { 15, -1, sizeof(::api::RICControlMessage)}, + { 22, -1, sizeof(::api::RicControlGrpcReq)}, + { 34, -1, sizeof(::api::RicControlGrpcRsp)}, +}; + +static ::google::protobuf::Message const * const file_default_instances[] = { + reinterpret_cast(&::api::_RICE2APHeader_default_instance_), + reinterpret_cast(&::api::_RICControlHeader_default_instance_), + reinterpret_cast(&::api::_RICControlMessage_default_instance_), + reinterpret_cast(&::api::_RicControlGrpcReq_default_instance_), + reinterpret_cast(&::api::_RicControlGrpcRsp_default_instance_), +}; + +void protobuf_AssignDescriptors() { + AddDescriptors(); + AssignDescriptors( + "api.proto", schemas, file_default_instances, TableStruct::offsets, + file_level_metadata, file_level_enum_descriptors, NULL); +} + +void protobuf_AssignDescriptorsOnce() { + static ::google::protobuf::internal::once_flag once; + ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 5); +} + +void AddDescriptorsImpl() { + InitDefaults(); + static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + "\n\tapi.proto\022\003api\":\n\rRICE2APHeader\022\021\n\tRan" + "FuncId\030\001 \001(\003\022\026\n\016RICRequestorID\030\002 \001(\003\"O\n\020" + "RICControlHeader\022\024\n\014ControlStyle\030\001 \001(\003\022\027" + "\n\017ControlActionId\030\002 \001(\003\022\014\n\004UEID\030\003 \001(\t\"e\n" + "\021RICControlMessage\022:\n\025RICControlCellType" + "Val\030\001 \001(\0162\033.api.RICControlCellTypeEnum\022\024" + "\n\014TargetCellID\030\002 \001(\t\"\226\002\n\021RicControlGrpcR" + "eq\022\020\n\010e2NodeID\030\001 \001(\t\022\016\n\006plmnID\030\002 \001(\t\022\017\n\007" + "ranName\030\003 \001(\t\022-\n\021RICE2APHeaderData\030\004 \001(\013" + "2\022.api.RICE2APHeader\0223\n\024RICControlHeader" + "Data\030\005 \001(\0132\025.api.RICControlHeader\0225\n\025RIC" + "ControlMessageData\030\006 \001(\0132\026.api.RICContro" + "lMessage\0223\n\023RICControlAckReqVal\030\007 \001(\0162\026." + "api.RICControlAckEnum\"9\n\021RicControlGrpcR" + "sp\022\017\n\007rspCode\030\001 \001(\005\022\023\n\013description\030\002 \001(\t" + "*k\n\026RICControlCellTypeEnum\022\033\n\027RIC_CONTRO" + "L_CELL_UNKWON\020\000\022\027\n\023RIC_CONTROL_NR_CELL\020\001" + "\022\033\n\027RIC_CONTROL_EUTRAN_CELL\020\002*r\n\021RICCont" + "rolAckEnum\022\032\n\026RIC_CONTROL_ACK_UNKWON\020\000\022\026" + "\n\022RIC_CONTROL_NO_ACK\020\001\022\023\n\017RIC_CONTROL_AC" + "K\020\002\022\024\n\020RIC_CONTROL_NACK\020\0032Y\n\007MsgComm\022N\n\034" + "SendRICControlReqServiceGrpc\022\026.api.RicCo" + "ntrolGrpcReq\032\026.api.RicControlGrpcRspb\006pr" + "oto3" + }; + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + descriptor, 924); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "api.proto", &protobuf_RegisterTypes); +} + +void AddDescriptors() { + static ::google::protobuf::internal::once_flag once; + ::google::protobuf::internal::call_once(once, AddDescriptorsImpl); +} +// Force AddDescriptors() to be called at dynamic initialization time. +struct StaticDescriptorInitializer { + StaticDescriptorInitializer() { + AddDescriptors(); + } +} static_descriptor_initializer; +} // namespace protobuf_api_2eproto +namespace api { +const ::google::protobuf::EnumDescriptor* RICControlCellTypeEnum_descriptor() { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return protobuf_api_2eproto::file_level_enum_descriptors[0]; +} +bool RICControlCellTypeEnum_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* RICControlAckEnum_descriptor() { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return protobuf_api_2eproto::file_level_enum_descriptors[1]; +} +bool RICControlAckEnum_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + + +// =================================================================== + +void RICE2APHeader::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RICE2APHeader::kRanFuncIdFieldNumber; +const int RICE2APHeader::kRICRequestorIDFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RICE2APHeader::RICE2APHeader() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_api_2eproto::scc_info_RICE2APHeader.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:api.RICE2APHeader) +} +RICE2APHeader::RICE2APHeader(const RICE2APHeader& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&ranfuncid_, &from.ranfuncid_, + static_cast(reinterpret_cast(&ricrequestorid_) - + reinterpret_cast(&ranfuncid_)) + sizeof(ricrequestorid_)); + // @@protoc_insertion_point(copy_constructor:api.RICE2APHeader) +} + +void RICE2APHeader::SharedCtor() { + ::memset(&ranfuncid_, 0, static_cast( + reinterpret_cast(&ricrequestorid_) - + reinterpret_cast(&ranfuncid_)) + sizeof(ricrequestorid_)); +} + +RICE2APHeader::~RICE2APHeader() { + // @@protoc_insertion_point(destructor:api.RICE2APHeader) + SharedDtor(); +} + +void RICE2APHeader::SharedDtor() { +} + +void RICE2APHeader::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ::google::protobuf::Descriptor* RICE2APHeader::descriptor() { + ::protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const RICE2APHeader& RICE2APHeader::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_api_2eproto::scc_info_RICE2APHeader.base); + return *internal_default_instance(); +} + + +void RICE2APHeader::Clear() { +// @@protoc_insertion_point(message_clear_start:api.RICE2APHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&ranfuncid_, 0, static_cast( + reinterpret_cast(&ricrequestorid_) - + reinterpret_cast(&ranfuncid_)) + sizeof(ricrequestorid_)); + _internal_metadata_.Clear(); +} + +bool RICE2APHeader::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:api.RICE2APHeader) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 RanFuncId = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &ranfuncid_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 RICRequestorID = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &ricrequestorid_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:api.RICE2APHeader) + return true; +failure: + // @@protoc_insertion_point(parse_failure:api.RICE2APHeader) + return false; +#undef DO_ +} + +void RICE2APHeader::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:api.RICE2APHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 RanFuncId = 1; + if (this->ranfuncid() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->ranfuncid(), output); + } + + // int64 RICRequestorID = 2; + if (this->ricrequestorid() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->ricrequestorid(), output); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); + } + // @@protoc_insertion_point(serialize_end:api.RICE2APHeader) +} + +::google::protobuf::uint8* RICE2APHeader::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:api.RICE2APHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 RanFuncId = 1; + if (this->ranfuncid() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->ranfuncid(), target); + } + + // int64 RICRequestorID = 2; + if (this->ricrequestorid() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->ricrequestorid(), target); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:api.RICE2APHeader) + return target; +} + +size_t RICE2APHeader::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:api.RICE2APHeader) + size_t total_size = 0; + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); + } + // int64 RanFuncId = 1; + if (this->ranfuncid() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->ranfuncid()); + } + + // int64 RICRequestorID = 2; + if (this->ricrequestorid() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->ricrequestorid()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RICE2APHeader::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:api.RICE2APHeader) + GOOGLE_DCHECK_NE(&from, this); + const RICE2APHeader* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:api.RICE2APHeader) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:api.RICE2APHeader) + MergeFrom(*source); + } +} + +void RICE2APHeader::MergeFrom(const RICE2APHeader& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:api.RICE2APHeader) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.ranfuncid() != 0) { + set_ranfuncid(from.ranfuncid()); + } + if (from.ricrequestorid() != 0) { + set_ricrequestorid(from.ricrequestorid()); + } +} + +void RICE2APHeader::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:api.RICE2APHeader) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RICE2APHeader::CopyFrom(const RICE2APHeader& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:api.RICE2APHeader) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RICE2APHeader::IsInitialized() const { + return true; +} + +void RICE2APHeader::Swap(RICE2APHeader* other) { + if (other == this) return; + InternalSwap(other); +} +void RICE2APHeader::InternalSwap(RICE2APHeader* other) { + using std::swap; + swap(ranfuncid_, other->ranfuncid_); + swap(ricrequestorid_, other->ricrequestorid_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::google::protobuf::Metadata RICE2APHeader::GetMetadata() const { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void RICControlHeader::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RICControlHeader::kControlStyleFieldNumber; +const int RICControlHeader::kControlActionIdFieldNumber; +const int RICControlHeader::kUEIDFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RICControlHeader::RICControlHeader() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_api_2eproto::scc_info_RICControlHeader.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:api.RICControlHeader) +} +RICControlHeader::RICControlHeader(const RICControlHeader& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ueid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.ueid().size() > 0) { + ueid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ueid_); + } + ::memcpy(&controlstyle_, &from.controlstyle_, + static_cast(reinterpret_cast(&controlactionid_) - + reinterpret_cast(&controlstyle_)) + sizeof(controlactionid_)); + // @@protoc_insertion_point(copy_constructor:api.RICControlHeader) +} + +void RICControlHeader::SharedCtor() { + ueid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&controlstyle_, 0, static_cast( + reinterpret_cast(&controlactionid_) - + reinterpret_cast(&controlstyle_)) + sizeof(controlactionid_)); +} + +RICControlHeader::~RICControlHeader() { + // @@protoc_insertion_point(destructor:api.RICControlHeader) + SharedDtor(); +} + +void RICControlHeader::SharedDtor() { + ueid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void RICControlHeader::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ::google::protobuf::Descriptor* RICControlHeader::descriptor() { + ::protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const RICControlHeader& RICControlHeader::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_api_2eproto::scc_info_RICControlHeader.base); + return *internal_default_instance(); +} + + +void RICControlHeader::Clear() { +// @@protoc_insertion_point(message_clear_start:api.RICControlHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ueid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&controlstyle_, 0, static_cast( + reinterpret_cast(&controlactionid_) - + reinterpret_cast(&controlstyle_)) + sizeof(controlactionid_)); + _internal_metadata_.Clear(); +} + +bool RICControlHeader::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:api.RICControlHeader) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 ControlStyle = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &controlstyle_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 ControlActionId = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &controlactionid_))); + } else { + goto handle_unusual; + } + break; + } + + // string UEID = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_ueid())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ueid().data(), static_cast(this->ueid().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RICControlHeader.UEID")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:api.RICControlHeader) + return true; +failure: + // @@protoc_insertion_point(parse_failure:api.RICControlHeader) + return false; +#undef DO_ +} + +void RICControlHeader::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:api.RICControlHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 ControlStyle = 1; + if (this->controlstyle() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->controlstyle(), output); + } + + // int64 ControlActionId = 2; + if (this->controlactionid() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->controlactionid(), output); + } + + // string UEID = 3; + if (this->ueid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ueid().data(), static_cast(this->ueid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RICControlHeader.UEID"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->ueid(), output); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); + } + // @@protoc_insertion_point(serialize_end:api.RICControlHeader) +} + +::google::protobuf::uint8* RICControlHeader::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:api.RICControlHeader) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 ControlStyle = 1; + if (this->controlstyle() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->controlstyle(), target); + } + + // int64 ControlActionId = 2; + if (this->controlactionid() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->controlactionid(), target); + } + + // string UEID = 3; + if (this->ueid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ueid().data(), static_cast(this->ueid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RICControlHeader.UEID"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->ueid(), target); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:api.RICControlHeader) + return target; +} + +size_t RICControlHeader::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:api.RICControlHeader) + size_t total_size = 0; + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); + } + // string UEID = 3; + if (this->ueid().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->ueid()); + } + + // int64 ControlStyle = 1; + if (this->controlstyle() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->controlstyle()); + } + + // int64 ControlActionId = 2; + if (this->controlactionid() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->controlactionid()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RICControlHeader::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:api.RICControlHeader) + GOOGLE_DCHECK_NE(&from, this); + const RICControlHeader* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:api.RICControlHeader) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:api.RICControlHeader) + MergeFrom(*source); + } +} + +void RICControlHeader::MergeFrom(const RICControlHeader& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:api.RICControlHeader) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.ueid().size() > 0) { + + ueid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ueid_); + } + if (from.controlstyle() != 0) { + set_controlstyle(from.controlstyle()); + } + if (from.controlactionid() != 0) { + set_controlactionid(from.controlactionid()); + } +} + +void RICControlHeader::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:api.RICControlHeader) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RICControlHeader::CopyFrom(const RICControlHeader& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:api.RICControlHeader) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RICControlHeader::IsInitialized() const { + return true; +} + +void RICControlHeader::Swap(RICControlHeader* other) { + if (other == this) return; + InternalSwap(other); +} +void RICControlHeader::InternalSwap(RICControlHeader* other) { + using std::swap; + ueid_.Swap(&other->ueid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(controlstyle_, other->controlstyle_); + swap(controlactionid_, other->controlactionid_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::google::protobuf::Metadata RICControlHeader::GetMetadata() const { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void RICControlMessage::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RICControlMessage::kRICControlCellTypeValFieldNumber; +const int RICControlMessage::kTargetCellIDFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RICControlMessage::RICControlMessage() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_api_2eproto::scc_info_RICControlMessage.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:api.RICControlMessage) +} +RICControlMessage::RICControlMessage(const RICControlMessage& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + targetcellid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.targetcellid().size() > 0) { + targetcellid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.targetcellid_); + } + riccontrolcelltypeval_ = from.riccontrolcelltypeval_; + // @@protoc_insertion_point(copy_constructor:api.RICControlMessage) +} + +void RICControlMessage::SharedCtor() { + targetcellid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + riccontrolcelltypeval_ = 0; +} + +RICControlMessage::~RICControlMessage() { + // @@protoc_insertion_point(destructor:api.RICControlMessage) + SharedDtor(); +} + +void RICControlMessage::SharedDtor() { + targetcellid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void RICControlMessage::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ::google::protobuf::Descriptor* RICControlMessage::descriptor() { + ::protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const RICControlMessage& RICControlMessage::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_api_2eproto::scc_info_RICControlMessage.base); + return *internal_default_instance(); +} + + +void RICControlMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:api.RICControlMessage) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + targetcellid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + riccontrolcelltypeval_ = 0; + _internal_metadata_.Clear(); +} + +bool RICControlMessage::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:api.RICControlMessage) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_riccontrolcelltypeval(static_cast< ::api::RICControlCellTypeEnum >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string TargetCellID = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_targetcellid())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->targetcellid().data(), static_cast(this->targetcellid().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RICControlMessage.TargetCellID")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:api.RICControlMessage) + return true; +failure: + // @@protoc_insertion_point(parse_failure:api.RICControlMessage) + return false; +#undef DO_ +} + +void RICControlMessage::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:api.RICControlMessage) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; + if (this->riccontrolcelltypeval() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->riccontrolcelltypeval(), output); + } + + // string TargetCellID = 2; + if (this->targetcellid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->targetcellid().data(), static_cast(this->targetcellid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RICControlMessage.TargetCellID"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->targetcellid(), output); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); + } + // @@protoc_insertion_point(serialize_end:api.RICControlMessage) +} + +::google::protobuf::uint8* RICControlMessage::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:api.RICControlMessage) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; + if (this->riccontrolcelltypeval() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->riccontrolcelltypeval(), target); + } + + // string TargetCellID = 2; + if (this->targetcellid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->targetcellid().data(), static_cast(this->targetcellid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RICControlMessage.TargetCellID"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->targetcellid(), target); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:api.RICControlMessage) + return target; +} + +size_t RICControlMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:api.RICControlMessage) + size_t total_size = 0; + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); + } + // string TargetCellID = 2; + if (this->targetcellid().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->targetcellid()); + } + + // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; + if (this->riccontrolcelltypeval() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->riccontrolcelltypeval()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RICControlMessage::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:api.RICControlMessage) + GOOGLE_DCHECK_NE(&from, this); + const RICControlMessage* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:api.RICControlMessage) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:api.RICControlMessage) + MergeFrom(*source); + } +} + +void RICControlMessage::MergeFrom(const RICControlMessage& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:api.RICControlMessage) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.targetcellid().size() > 0) { + + targetcellid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.targetcellid_); + } + if (from.riccontrolcelltypeval() != 0) { + set_riccontrolcelltypeval(from.riccontrolcelltypeval()); + } +} + +void RICControlMessage::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:api.RICControlMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RICControlMessage::CopyFrom(const RICControlMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:api.RICControlMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RICControlMessage::IsInitialized() const { + return true; +} + +void RICControlMessage::Swap(RICControlMessage* other) { + if (other == this) return; + InternalSwap(other); +} +void RICControlMessage::InternalSwap(RICControlMessage* other) { + using std::swap; + targetcellid_.Swap(&other->targetcellid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(riccontrolcelltypeval_, other->riccontrolcelltypeval_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::google::protobuf::Metadata RICControlMessage::GetMetadata() const { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void RicControlGrpcReq::InitAsDefaultInstance() { + ::api::_RicControlGrpcReq_default_instance_._instance.get_mutable()->rice2apheaderdata_ = const_cast< ::api::RICE2APHeader*>( + ::api::RICE2APHeader::internal_default_instance()); + ::api::_RicControlGrpcReq_default_instance_._instance.get_mutable()->riccontrolheaderdata_ = const_cast< ::api::RICControlHeader*>( + ::api::RICControlHeader::internal_default_instance()); + ::api::_RicControlGrpcReq_default_instance_._instance.get_mutable()->riccontrolmessagedata_ = const_cast< ::api::RICControlMessage*>( + ::api::RICControlMessage::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RicControlGrpcReq::kE2NodeIDFieldNumber; +const int RicControlGrpcReq::kPlmnIDFieldNumber; +const int RicControlGrpcReq::kRanNameFieldNumber; +const int RicControlGrpcReq::kRICE2APHeaderDataFieldNumber; +const int RicControlGrpcReq::kRICControlHeaderDataFieldNumber; +const int RicControlGrpcReq::kRICControlMessageDataFieldNumber; +const int RicControlGrpcReq::kRICControlAckReqValFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RicControlGrpcReq::RicControlGrpcReq() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_api_2eproto::scc_info_RicControlGrpcReq.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:api.RicControlGrpcReq) +} +RicControlGrpcReq::RicControlGrpcReq(const RicControlGrpcReq& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + e2nodeid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.e2nodeid().size() > 0) { + e2nodeid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.e2nodeid_); + } + plmnid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.plmnid().size() > 0) { + plmnid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.plmnid_); + } + ranname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.ranname().size() > 0) { + ranname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ranname_); + } + if (from.has_rice2apheaderdata()) { + rice2apheaderdata_ = new ::api::RICE2APHeader(*from.rice2apheaderdata_); + } else { + rice2apheaderdata_ = NULL; + } + if (from.has_riccontrolheaderdata()) { + riccontrolheaderdata_ = new ::api::RICControlHeader(*from.riccontrolheaderdata_); + } else { + riccontrolheaderdata_ = NULL; + } + if (from.has_riccontrolmessagedata()) { + riccontrolmessagedata_ = new ::api::RICControlMessage(*from.riccontrolmessagedata_); + } else { + riccontrolmessagedata_ = NULL; + } + riccontrolackreqval_ = from.riccontrolackreqval_; + // @@protoc_insertion_point(copy_constructor:api.RicControlGrpcReq) +} + +void RicControlGrpcReq::SharedCtor() { + e2nodeid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + plmnid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ranname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&rice2apheaderdata_, 0, static_cast( + reinterpret_cast(&riccontrolackreqval_) - + reinterpret_cast(&rice2apheaderdata_)) + sizeof(riccontrolackreqval_)); +} + +RicControlGrpcReq::~RicControlGrpcReq() { + // @@protoc_insertion_point(destructor:api.RicControlGrpcReq) + SharedDtor(); +} + +void RicControlGrpcReq::SharedDtor() { + e2nodeid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + plmnid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ranname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete rice2apheaderdata_; + if (this != internal_default_instance()) delete riccontrolheaderdata_; + if (this != internal_default_instance()) delete riccontrolmessagedata_; +} + +void RicControlGrpcReq::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ::google::protobuf::Descriptor* RicControlGrpcReq::descriptor() { + ::protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const RicControlGrpcReq& RicControlGrpcReq::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_api_2eproto::scc_info_RicControlGrpcReq.base); + return *internal_default_instance(); +} + + +void RicControlGrpcReq::Clear() { +// @@protoc_insertion_point(message_clear_start:api.RicControlGrpcReq) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + e2nodeid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + plmnid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ranname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == NULL && rice2apheaderdata_ != NULL) { + delete rice2apheaderdata_; + } + rice2apheaderdata_ = NULL; + if (GetArenaNoVirtual() == NULL && riccontrolheaderdata_ != NULL) { + delete riccontrolheaderdata_; + } + riccontrolheaderdata_ = NULL; + if (GetArenaNoVirtual() == NULL && riccontrolmessagedata_ != NULL) { + delete riccontrolmessagedata_; + } + riccontrolmessagedata_ = NULL; + riccontrolackreqval_ = 0; + _internal_metadata_.Clear(); +} + +bool RicControlGrpcReq::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:api.RicControlGrpcReq) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string e2NodeID = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_e2nodeid())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->e2nodeid().data(), static_cast(this->e2nodeid().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RicControlGrpcReq.e2NodeID")); + } else { + goto handle_unusual; + } + break; + } + + // string plmnID = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_plmnid())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->plmnid().data(), static_cast(this->plmnid().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RicControlGrpcReq.plmnID")); + } else { + goto handle_unusual; + } + break; + } + + // string ranName = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_ranname())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ranname().data(), static_cast(this->ranname().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RicControlGrpcReq.ranName")); + } else { + goto handle_unusual; + } + break; + } + + // .api.RICE2APHeader RICE2APHeaderData = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_rice2apheaderdata())); + } else { + goto handle_unusual; + } + break; + } + + // .api.RICControlHeader RICControlHeaderData = 5; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_riccontrolheaderdata())); + } else { + goto handle_unusual; + } + break; + } + + // .api.RICControlMessage RICControlMessageData = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_riccontrolmessagedata())); + } else { + goto handle_unusual; + } + break; + } + + // .api.RICControlAckEnum RICControlAckReqVal = 7; + case 7: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_riccontrolackreqval(static_cast< ::api::RICControlAckEnum >(value)); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:api.RicControlGrpcReq) + return true; +failure: + // @@protoc_insertion_point(parse_failure:api.RicControlGrpcReq) + return false; +#undef DO_ +} + +void RicControlGrpcReq::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:api.RicControlGrpcReq) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string e2NodeID = 1; + if (this->e2nodeid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->e2nodeid().data(), static_cast(this->e2nodeid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.e2NodeID"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->e2nodeid(), output); + } + + // string plmnID = 2; + if (this->plmnid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->plmnid().data(), static_cast(this->plmnid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.plmnID"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->plmnid(), output); + } + + // string ranName = 3; + if (this->ranname().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ranname().data(), static_cast(this->ranname().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.ranName"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->ranname(), output); + } + + // .api.RICE2APHeader RICE2APHeaderData = 4; + if (this->has_rice2apheaderdata()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->_internal_rice2apheaderdata(), output); + } + + // .api.RICControlHeader RICControlHeaderData = 5; + if (this->has_riccontrolheaderdata()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->_internal_riccontrolheaderdata(), output); + } + + // .api.RICControlMessage RICControlMessageData = 6; + if (this->has_riccontrolmessagedata()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, this->_internal_riccontrolmessagedata(), output); + } + + // .api.RICControlAckEnum RICControlAckReqVal = 7; + if (this->riccontrolackreqval() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->riccontrolackreqval(), output); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); + } + // @@protoc_insertion_point(serialize_end:api.RicControlGrpcReq) +} + +::google::protobuf::uint8* RicControlGrpcReq::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:api.RicControlGrpcReq) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string e2NodeID = 1; + if (this->e2nodeid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->e2nodeid().data(), static_cast(this->e2nodeid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.e2NodeID"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->e2nodeid(), target); + } + + // string plmnID = 2; + if (this->plmnid().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->plmnid().data(), static_cast(this->plmnid().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.plmnID"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->plmnid(), target); + } + + // string ranName = 3; + if (this->ranname().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->ranname().data(), static_cast(this->ranname().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcReq.ranName"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->ranname(), target); + } + + // .api.RICE2APHeader RICE2APHeaderData = 4; + if (this->has_rice2apheaderdata()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->_internal_rice2apheaderdata(), deterministic, target); + } + + // .api.RICControlHeader RICControlHeaderData = 5; + if (this->has_riccontrolheaderdata()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->_internal_riccontrolheaderdata(), deterministic, target); + } + + // .api.RICControlMessage RICControlMessageData = 6; + if (this->has_riccontrolmessagedata()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->_internal_riccontrolmessagedata(), deterministic, target); + } + + // .api.RICControlAckEnum RICControlAckReqVal = 7; + if (this->riccontrolackreqval() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 7, this->riccontrolackreqval(), target); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:api.RicControlGrpcReq) + return target; +} + +size_t RicControlGrpcReq::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:api.RicControlGrpcReq) + size_t total_size = 0; + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); + } + // string e2NodeID = 1; + if (this->e2nodeid().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->e2nodeid()); + } + + // string plmnID = 2; + if (this->plmnid().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->plmnid()); + } + + // string ranName = 3; + if (this->ranname().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->ranname()); + } + + // .api.RICE2APHeader RICE2APHeaderData = 4; + if (this->has_rice2apheaderdata()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *rice2apheaderdata_); + } + + // .api.RICControlHeader RICControlHeaderData = 5; + if (this->has_riccontrolheaderdata()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *riccontrolheaderdata_); + } + + // .api.RICControlMessage RICControlMessageData = 6; + if (this->has_riccontrolmessagedata()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *riccontrolmessagedata_); + } + + // .api.RICControlAckEnum RICControlAckReqVal = 7; + if (this->riccontrolackreqval() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->riccontrolackreqval()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RicControlGrpcReq::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:api.RicControlGrpcReq) + GOOGLE_DCHECK_NE(&from, this); + const RicControlGrpcReq* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:api.RicControlGrpcReq) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:api.RicControlGrpcReq) + MergeFrom(*source); + } +} + +void RicControlGrpcReq::MergeFrom(const RicControlGrpcReq& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:api.RicControlGrpcReq) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.e2nodeid().size() > 0) { + + e2nodeid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.e2nodeid_); + } + if (from.plmnid().size() > 0) { + + plmnid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.plmnid_); + } + if (from.ranname().size() > 0) { + + ranname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ranname_); + } + if (from.has_rice2apheaderdata()) { + mutable_rice2apheaderdata()->::api::RICE2APHeader::MergeFrom(from.rice2apheaderdata()); + } + if (from.has_riccontrolheaderdata()) { + mutable_riccontrolheaderdata()->::api::RICControlHeader::MergeFrom(from.riccontrolheaderdata()); + } + if (from.has_riccontrolmessagedata()) { + mutable_riccontrolmessagedata()->::api::RICControlMessage::MergeFrom(from.riccontrolmessagedata()); + } + if (from.riccontrolackreqval() != 0) { + set_riccontrolackreqval(from.riccontrolackreqval()); + } +} + +void RicControlGrpcReq::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:api.RicControlGrpcReq) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RicControlGrpcReq::CopyFrom(const RicControlGrpcReq& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:api.RicControlGrpcReq) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RicControlGrpcReq::IsInitialized() const { + return true; +} + +void RicControlGrpcReq::Swap(RicControlGrpcReq* other) { + if (other == this) return; + InternalSwap(other); +} +void RicControlGrpcReq::InternalSwap(RicControlGrpcReq* other) { + using std::swap; + e2nodeid_.Swap(&other->e2nodeid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + plmnid_.Swap(&other->plmnid_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + ranname_.Swap(&other->ranname_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(rice2apheaderdata_, other->rice2apheaderdata_); + swap(riccontrolheaderdata_, other->riccontrolheaderdata_); + swap(riccontrolmessagedata_, other->riccontrolmessagedata_); + swap(riccontrolackreqval_, other->riccontrolackreqval_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::google::protobuf::Metadata RicControlGrpcReq::GetMetadata() const { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void RicControlGrpcRsp::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int RicControlGrpcRsp::kRspCodeFieldNumber; +const int RicControlGrpcRsp::kDescriptionFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +RicControlGrpcRsp::RicControlGrpcRsp() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + ::google::protobuf::internal::InitSCC( + &protobuf_api_2eproto::scc_info_RicControlGrpcRsp.base); + SharedCtor(); + // @@protoc_insertion_point(constructor:api.RicControlGrpcRsp) +} +RicControlGrpcRsp::RicControlGrpcRsp(const RicControlGrpcRsp& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.description().size() > 0) { + description_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.description_); + } + rspcode_ = from.rspcode_; + // @@protoc_insertion_point(copy_constructor:api.RicControlGrpcRsp) +} + +void RicControlGrpcRsp::SharedCtor() { + description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + rspcode_ = 0; +} + +RicControlGrpcRsp::~RicControlGrpcRsp() { + // @@protoc_insertion_point(destructor:api.RicControlGrpcRsp) + SharedDtor(); +} + +void RicControlGrpcRsp::SharedDtor() { + description_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void RicControlGrpcRsp::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ::google::protobuf::Descriptor* RicControlGrpcRsp::descriptor() { + ::protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const RicControlGrpcRsp& RicControlGrpcRsp::default_instance() { + ::google::protobuf::internal::InitSCC(&protobuf_api_2eproto::scc_info_RicControlGrpcRsp.base); + return *internal_default_instance(); +} + + +void RicControlGrpcRsp::Clear() { +// @@protoc_insertion_point(message_clear_start:api.RicControlGrpcRsp) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + rspcode_ = 0; + _internal_metadata_.Clear(); +} + +bool RicControlGrpcRsp::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:api.RicControlGrpcRsp) + for (;;) { + ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int32 rspCode = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &rspcode_))); + } else { + goto handle_unusual; + } + break; + } + + // string description = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_description())); + DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), static_cast(this->description().length()), + ::google::protobuf::internal::WireFormatLite::PARSE, + "api.RicControlGrpcRsp.description")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:api.RicControlGrpcRsp) + return true; +failure: + // @@protoc_insertion_point(parse_failure:api.RicControlGrpcRsp) + return false; +#undef DO_ +} + +void RicControlGrpcRsp::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:api.RicControlGrpcRsp) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 rspCode = 1; + if (this->rspcode() != 0) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->rspcode(), output); + } + + // string description = 2; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), static_cast(this->description().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcRsp.description"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->description(), output); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); + } + // @@protoc_insertion_point(serialize_end:api.RicControlGrpcRsp) +} + +::google::protobuf::uint8* RicControlGrpcRsp::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:api.RicControlGrpcRsp) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 rspCode = 1; + if (this->rspcode() != 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->rspcode(), target); + } + + // string description = 2; + if (this->description().size() > 0) { + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + this->description().data(), static_cast(this->description().length()), + ::google::protobuf::internal::WireFormatLite::SERIALIZE, + "api.RicControlGrpcRsp.description"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->description(), target); + } + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:api.RicControlGrpcRsp) + return target; +} + +size_t RicControlGrpcRsp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:api.RicControlGrpcRsp) + size_t total_size = 0; + + if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); + } + // string description = 2; + if (this->description().size() > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->description()); + } + + // int32 rspCode = 1; + if (this->rspcode() != 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->rspcode()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RicControlGrpcRsp::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:api.RicControlGrpcRsp) + GOOGLE_DCHECK_NE(&from, this); + const RicControlGrpcRsp* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:api.RicControlGrpcRsp) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:api.RicControlGrpcRsp) + MergeFrom(*source); + } +} + +void RicControlGrpcRsp::MergeFrom(const RicControlGrpcRsp& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:api.RicControlGrpcRsp) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.description().size() > 0) { + + description_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.description_); + } + if (from.rspcode() != 0) { + set_rspcode(from.rspcode()); + } +} + +void RicControlGrpcRsp::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:api.RicControlGrpcRsp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RicControlGrpcRsp::CopyFrom(const RicControlGrpcRsp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:api.RicControlGrpcRsp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RicControlGrpcRsp::IsInitialized() const { + return true; +} + +void RicControlGrpcRsp::Swap(RicControlGrpcRsp* other) { + if (other == this) return; + InternalSwap(other); +} +void RicControlGrpcRsp::InternalSwap(RicControlGrpcRsp* other) { + using std::swap; + description_.Swap(&other->description_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(rspcode_, other->rspcode_); + _internal_metadata_.Swap(&other->_internal_metadata_); +} + +::google::protobuf::Metadata RicControlGrpcRsp::GetMetadata() const { + protobuf_api_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_api_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace api +namespace google { +namespace protobuf { +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::api::RICE2APHeader* Arena::CreateMaybeMessage< ::api::RICE2APHeader >(Arena* arena) { + return Arena::CreateInternal< ::api::RICE2APHeader >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::api::RICControlHeader* Arena::CreateMaybeMessage< ::api::RICControlHeader >(Arena* arena) { + return Arena::CreateInternal< ::api::RICControlHeader >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::api::RICControlMessage* Arena::CreateMaybeMessage< ::api::RICControlMessage >(Arena* arena) { + return Arena::CreateInternal< ::api::RICControlMessage >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::api::RicControlGrpcReq* Arena::CreateMaybeMessage< ::api::RicControlGrpcReq >(Arena* arena) { + return Arena::CreateInternal< ::api::RicControlGrpcReq >(arena); +} +template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::api::RicControlGrpcRsp* Arena::CreateMaybeMessage< ::api::RicControlGrpcRsp >(Arena* arena) { + return Arena::CreateInternal< ::api::RicControlGrpcRsp >(arena); +} +} // namespace protobuf +} // namespace google + +// @@protoc_insertion_point(global_scope) diff --git a/ext/protobuf/api.pb.h b/ext/protobuf/api.pb.h new file mode 100644 index 0000000..c176270 --- /dev/null +++ b/ext/protobuf/api.pb.h @@ -0,0 +1,1420 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: api.proto + +#ifndef PROTOBUF_INCLUDED_api_2eproto +#define PROTOBUF_INCLUDED_api_2eproto + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 3006001 +#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 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#define PROTOBUF_INTERNAL_EXPORT_protobuf_api_2eproto + +namespace protobuf_api_2eproto { +// Internal implementation detail -- do not use these members. +struct TableStruct { + static const ::google::protobuf::internal::ParseTableField entries[]; + static const ::google::protobuf::internal::AuxillaryParseTableField aux[]; + static const ::google::protobuf::internal::ParseTable schema[5]; + static const ::google::protobuf::internal::FieldMetadata field_metadata[]; + static const ::google::protobuf::internal::SerializationTable serialization_table[]; + static const ::google::protobuf::uint32 offsets[]; +}; +void AddDescriptors(); +} // namespace protobuf_api_2eproto +namespace api { +class RICControlHeader; +class RICControlHeaderDefaultTypeInternal; +extern RICControlHeaderDefaultTypeInternal _RICControlHeader_default_instance_; +class RICControlMessage; +class RICControlMessageDefaultTypeInternal; +extern RICControlMessageDefaultTypeInternal _RICControlMessage_default_instance_; +class RICE2APHeader; +class RICE2APHeaderDefaultTypeInternal; +extern RICE2APHeaderDefaultTypeInternal _RICE2APHeader_default_instance_; +class RicControlGrpcReq; +class RicControlGrpcReqDefaultTypeInternal; +extern RicControlGrpcReqDefaultTypeInternal _RicControlGrpcReq_default_instance_; +class RicControlGrpcRsp; +class RicControlGrpcRspDefaultTypeInternal; +extern RicControlGrpcRspDefaultTypeInternal _RicControlGrpcRsp_default_instance_; +} // namespace api +namespace google { +namespace protobuf { +template<> ::api::RICControlHeader* Arena::CreateMaybeMessage<::api::RICControlHeader>(Arena*); +template<> ::api::RICControlMessage* Arena::CreateMaybeMessage<::api::RICControlMessage>(Arena*); +template<> ::api::RICE2APHeader* Arena::CreateMaybeMessage<::api::RICE2APHeader>(Arena*); +template<> ::api::RicControlGrpcReq* Arena::CreateMaybeMessage<::api::RicControlGrpcReq>(Arena*); +template<> ::api::RicControlGrpcRsp* Arena::CreateMaybeMessage<::api::RicControlGrpcRsp>(Arena*); +} // namespace protobuf +} // namespace google +namespace api { + +enum RICControlCellTypeEnum { + RIC_CONTROL_CELL_UNKWON = 0, + RIC_CONTROL_NR_CELL = 1, + RIC_CONTROL_EUTRAN_CELL = 2, + RICControlCellTypeEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min, + RICControlCellTypeEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max +}; +bool RICControlCellTypeEnum_IsValid(int value); +const RICControlCellTypeEnum RICControlCellTypeEnum_MIN = RIC_CONTROL_CELL_UNKWON; +const RICControlCellTypeEnum RICControlCellTypeEnum_MAX = RIC_CONTROL_EUTRAN_CELL; +const int RICControlCellTypeEnum_ARRAYSIZE = RICControlCellTypeEnum_MAX + 1; + +const ::google::protobuf::EnumDescriptor* RICControlCellTypeEnum_descriptor(); +inline const ::std::string& RICControlCellTypeEnum_Name(RICControlCellTypeEnum value) { + return ::google::protobuf::internal::NameOfEnum( + RICControlCellTypeEnum_descriptor(), value); +} +inline bool RICControlCellTypeEnum_Parse( + const ::std::string& name, RICControlCellTypeEnum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + RICControlCellTypeEnum_descriptor(), name, value); +} +enum RICControlAckEnum { + RIC_CONTROL_ACK_UNKWON = 0, + RIC_CONTROL_NO_ACK = 1, + RIC_CONTROL_ACK = 2, + RIC_CONTROL_NACK = 3, + RICControlAckEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min, + RICControlAckEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max +}; +bool RICControlAckEnum_IsValid(int value); +const RICControlAckEnum RICControlAckEnum_MIN = RIC_CONTROL_ACK_UNKWON; +const RICControlAckEnum RICControlAckEnum_MAX = RIC_CONTROL_NACK; +const int RICControlAckEnum_ARRAYSIZE = RICControlAckEnum_MAX + 1; + +const ::google::protobuf::EnumDescriptor* RICControlAckEnum_descriptor(); +inline const ::std::string& RICControlAckEnum_Name(RICControlAckEnum value) { + return ::google::protobuf::internal::NameOfEnum( + RICControlAckEnum_descriptor(), value); +} +inline bool RICControlAckEnum_Parse( + const ::std::string& name, RICControlAckEnum* value) { + return ::google::protobuf::internal::ParseNamedEnum( + RICControlAckEnum_descriptor(), name, value); +} +// =================================================================== + +class RICE2APHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICE2APHeader) */ { + public: + RICE2APHeader(); + virtual ~RICE2APHeader(); + + RICE2APHeader(const RICE2APHeader& from); + + inline RICE2APHeader& operator=(const RICE2APHeader& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RICE2APHeader(RICE2APHeader&& from) noexcept + : RICE2APHeader() { + *this = ::std::move(from); + } + + inline RICE2APHeader& operator=(RICE2APHeader&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const ::google::protobuf::Descriptor* descriptor(); + static const RICE2APHeader& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RICE2APHeader* internal_default_instance() { + return reinterpret_cast( + &_RICE2APHeader_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + void Swap(RICE2APHeader* other); + friend void swap(RICE2APHeader& a, RICE2APHeader& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RICE2APHeader* New() const final { + return CreateMaybeMessage(NULL); + } + + RICE2APHeader* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::google::protobuf::Message& from) final; + void MergeFrom(const ::google::protobuf::Message& from) final; + void CopyFrom(const RICE2APHeader& from); + void MergeFrom(const RICE2APHeader& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RICE2APHeader* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // int64 RanFuncId = 1; + void clear_ranfuncid(); + static const int kRanFuncIdFieldNumber = 1; + ::google::protobuf::int64 ranfuncid() const; + void set_ranfuncid(::google::protobuf::int64 value); + + // int64 RICRequestorID = 2; + void clear_ricrequestorid(); + static const int kRICRequestorIDFieldNumber = 2; + ::google::protobuf::int64 ricrequestorid() const; + void set_ricrequestorid(::google::protobuf::int64 value); + + // @@protoc_insertion_point(class_scope:api.RICE2APHeader) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::int64 ranfuncid_; + ::google::protobuf::int64 ricrequestorid_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_api_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class RICControlHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICControlHeader) */ { + public: + RICControlHeader(); + virtual ~RICControlHeader(); + + RICControlHeader(const RICControlHeader& from); + + inline RICControlHeader& operator=(const RICControlHeader& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RICControlHeader(RICControlHeader&& from) noexcept + : RICControlHeader() { + *this = ::std::move(from); + } + + inline RICControlHeader& operator=(RICControlHeader&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const ::google::protobuf::Descriptor* descriptor(); + static const RICControlHeader& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RICControlHeader* internal_default_instance() { + return reinterpret_cast( + &_RICControlHeader_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + void Swap(RICControlHeader* other); + friend void swap(RICControlHeader& a, RICControlHeader& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RICControlHeader* New() const final { + return CreateMaybeMessage(NULL); + } + + RICControlHeader* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::google::protobuf::Message& from) final; + void MergeFrom(const ::google::protobuf::Message& from) final; + void CopyFrom(const RICControlHeader& from); + void MergeFrom(const RICControlHeader& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RICControlHeader* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // string UEID = 3; + void clear_ueid(); + static const int kUEIDFieldNumber = 3; + const ::std::string& ueid() const; + void set_ueid(const ::std::string& value); + #if LANG_CXX11 + void set_ueid(::std::string&& value); + #endif + void set_ueid(const char* value); + void set_ueid(const char* value, size_t size); + ::std::string* mutable_ueid(); + ::std::string* release_ueid(); + void set_allocated_ueid(::std::string* ueid); + + // int64 ControlStyle = 1; + void clear_controlstyle(); + static const int kControlStyleFieldNumber = 1; + ::google::protobuf::int64 controlstyle() const; + void set_controlstyle(::google::protobuf::int64 value); + + // int64 ControlActionId = 2; + void clear_controlactionid(); + static const int kControlActionIdFieldNumber = 2; + ::google::protobuf::int64 controlactionid() const; + void set_controlactionid(::google::protobuf::int64 value); + + // @@protoc_insertion_point(class_scope:api.RICControlHeader) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr ueid_; + ::google::protobuf::int64 controlstyle_; + ::google::protobuf::int64 controlactionid_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_api_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class RICControlMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RICControlMessage) */ { + public: + RICControlMessage(); + virtual ~RICControlMessage(); + + RICControlMessage(const RICControlMessage& from); + + inline RICControlMessage& operator=(const RICControlMessage& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RICControlMessage(RICControlMessage&& from) noexcept + : RICControlMessage() { + *this = ::std::move(from); + } + + inline RICControlMessage& operator=(RICControlMessage&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const ::google::protobuf::Descriptor* descriptor(); + static const RICControlMessage& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RICControlMessage* internal_default_instance() { + return reinterpret_cast( + &_RICControlMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + void Swap(RICControlMessage* other); + friend void swap(RICControlMessage& a, RICControlMessage& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RICControlMessage* New() const final { + return CreateMaybeMessage(NULL); + } + + RICControlMessage* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::google::protobuf::Message& from) final; + void MergeFrom(const ::google::protobuf::Message& from) final; + void CopyFrom(const RICControlMessage& from); + void MergeFrom(const RICControlMessage& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RICControlMessage* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // string TargetCellID = 2; + void clear_targetcellid(); + static const int kTargetCellIDFieldNumber = 2; + const ::std::string& targetcellid() const; + void set_targetcellid(const ::std::string& value); + #if LANG_CXX11 + void set_targetcellid(::std::string&& value); + #endif + void set_targetcellid(const char* value); + void set_targetcellid(const char* value, size_t size); + ::std::string* mutable_targetcellid(); + ::std::string* release_targetcellid(); + void set_allocated_targetcellid(::std::string* targetcellid); + + // .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; + void clear_riccontrolcelltypeval(); + static const int kRICControlCellTypeValFieldNumber = 1; + ::api::RICControlCellTypeEnum riccontrolcelltypeval() const; + void set_riccontrolcelltypeval(::api::RICControlCellTypeEnum value); + + // @@protoc_insertion_point(class_scope:api.RICControlMessage) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr targetcellid_; + int riccontrolcelltypeval_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_api_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class RicControlGrpcReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RicControlGrpcReq) */ { + public: + RicControlGrpcReq(); + virtual ~RicControlGrpcReq(); + + RicControlGrpcReq(const RicControlGrpcReq& from); + + inline RicControlGrpcReq& operator=(const RicControlGrpcReq& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RicControlGrpcReq(RicControlGrpcReq&& from) noexcept + : RicControlGrpcReq() { + *this = ::std::move(from); + } + + inline RicControlGrpcReq& operator=(RicControlGrpcReq&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const ::google::protobuf::Descriptor* descriptor(); + static const RicControlGrpcReq& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RicControlGrpcReq* internal_default_instance() { + return reinterpret_cast( + &_RicControlGrpcReq_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + void Swap(RicControlGrpcReq* other); + friend void swap(RicControlGrpcReq& a, RicControlGrpcReq& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RicControlGrpcReq* New() const final { + return CreateMaybeMessage(NULL); + } + + RicControlGrpcReq* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::google::protobuf::Message& from) final; + void MergeFrom(const ::google::protobuf::Message& from) final; + void CopyFrom(const RicControlGrpcReq& from); + void MergeFrom(const RicControlGrpcReq& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RicControlGrpcReq* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // string e2NodeID = 1; + void clear_e2nodeid(); + static const int kE2NodeIDFieldNumber = 1; + const ::std::string& e2nodeid() const; + void set_e2nodeid(const ::std::string& value); + #if LANG_CXX11 + void set_e2nodeid(::std::string&& value); + #endif + void set_e2nodeid(const char* value); + void set_e2nodeid(const char* value, size_t size); + ::std::string* mutable_e2nodeid(); + ::std::string* release_e2nodeid(); + void set_allocated_e2nodeid(::std::string* e2nodeid); + + // string plmnID = 2; + void clear_plmnid(); + static const int kPlmnIDFieldNumber = 2; + const ::std::string& plmnid() const; + void set_plmnid(const ::std::string& value); + #if LANG_CXX11 + void set_plmnid(::std::string&& value); + #endif + void set_plmnid(const char* value); + void set_plmnid(const char* value, size_t size); + ::std::string* mutable_plmnid(); + ::std::string* release_plmnid(); + void set_allocated_plmnid(::std::string* plmnid); + + // string ranName = 3; + void clear_ranname(); + static const int kRanNameFieldNumber = 3; + const ::std::string& ranname() const; + void set_ranname(const ::std::string& value); + #if LANG_CXX11 + void set_ranname(::std::string&& value); + #endif + void set_ranname(const char* value); + void set_ranname(const char* value, size_t size); + ::std::string* mutable_ranname(); + ::std::string* release_ranname(); + void set_allocated_ranname(::std::string* ranname); + + // .api.RICE2APHeader RICE2APHeaderData = 4; + bool has_rice2apheaderdata() const; + void clear_rice2apheaderdata(); + static const int kRICE2APHeaderDataFieldNumber = 4; + private: + const ::api::RICE2APHeader& _internal_rice2apheaderdata() const; + public: + const ::api::RICE2APHeader& rice2apheaderdata() const; + ::api::RICE2APHeader* release_rice2apheaderdata(); + ::api::RICE2APHeader* mutable_rice2apheaderdata(); + void set_allocated_rice2apheaderdata(::api::RICE2APHeader* rice2apheaderdata); + + // .api.RICControlHeader RICControlHeaderData = 5; + bool has_riccontrolheaderdata() const; + void clear_riccontrolheaderdata(); + static const int kRICControlHeaderDataFieldNumber = 5; + private: + const ::api::RICControlHeader& _internal_riccontrolheaderdata() const; + public: + const ::api::RICControlHeader& riccontrolheaderdata() const; + ::api::RICControlHeader* release_riccontrolheaderdata(); + ::api::RICControlHeader* mutable_riccontrolheaderdata(); + void set_allocated_riccontrolheaderdata(::api::RICControlHeader* riccontrolheaderdata); + + // .api.RICControlMessage RICControlMessageData = 6; + bool has_riccontrolmessagedata() const; + void clear_riccontrolmessagedata(); + static const int kRICControlMessageDataFieldNumber = 6; + private: + const ::api::RICControlMessage& _internal_riccontrolmessagedata() const; + public: + const ::api::RICControlMessage& riccontrolmessagedata() const; + ::api::RICControlMessage* release_riccontrolmessagedata(); + ::api::RICControlMessage* mutable_riccontrolmessagedata(); + void set_allocated_riccontrolmessagedata(::api::RICControlMessage* riccontrolmessagedata); + + // .api.RICControlAckEnum RICControlAckReqVal = 7; + void clear_riccontrolackreqval(); + static const int kRICControlAckReqValFieldNumber = 7; + ::api::RICControlAckEnum riccontrolackreqval() const; + void set_riccontrolackreqval(::api::RICControlAckEnum value); + + // @@protoc_insertion_point(class_scope:api.RicControlGrpcReq) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr e2nodeid_; + ::google::protobuf::internal::ArenaStringPtr plmnid_; + ::google::protobuf::internal::ArenaStringPtr ranname_; + ::api::RICE2APHeader* rice2apheaderdata_; + ::api::RICControlHeader* riccontrolheaderdata_; + ::api::RICControlMessage* riccontrolmessagedata_; + int riccontrolackreqval_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_api_2eproto::TableStruct; +}; +// ------------------------------------------------------------------- + +class RicControlGrpcRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:api.RicControlGrpcRsp) */ { + public: + RicControlGrpcRsp(); + virtual ~RicControlGrpcRsp(); + + RicControlGrpcRsp(const RicControlGrpcRsp& from); + + inline RicControlGrpcRsp& operator=(const RicControlGrpcRsp& from) { + CopyFrom(from); + return *this; + } + #if LANG_CXX11 + RicControlGrpcRsp(RicControlGrpcRsp&& from) noexcept + : RicControlGrpcRsp() { + *this = ::std::move(from); + } + + inline RicControlGrpcRsp& operator=(RicControlGrpcRsp&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + #endif + static const ::google::protobuf::Descriptor* descriptor(); + static const RicControlGrpcRsp& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RicControlGrpcRsp* internal_default_instance() { + return reinterpret_cast( + &_RicControlGrpcRsp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + void Swap(RicControlGrpcRsp* other); + friend void swap(RicControlGrpcRsp& a, RicControlGrpcRsp& b) { + a.Swap(&b); + } + + // implements Message ---------------------------------------------- + + inline RicControlGrpcRsp* New() const final { + return CreateMaybeMessage(NULL); + } + + RicControlGrpcRsp* New(::google::protobuf::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::google::protobuf::Message& from) final; + void MergeFrom(const ::google::protobuf::Message& from) final; + void CopyFrom(const RicControlGrpcRsp& from); + void MergeFrom(const RicControlGrpcRsp& from); + void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) final; + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const final; + ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RicControlGrpcRsp* other); + private: + inline ::google::protobuf::Arena* GetArenaNoVirtual() const { + return NULL; + } + inline void* MaybeArenaPtr() const { + return NULL; + } + public: + + ::google::protobuf::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // string description = 2; + void clear_description(); + static const int kDescriptionFieldNumber = 2; + const ::std::string& description() const; + void set_description(const ::std::string& value); + #if LANG_CXX11 + void set_description(::std::string&& value); + #endif + void set_description(const char* value); + void set_description(const char* value, size_t size); + ::std::string* mutable_description(); + ::std::string* release_description(); + void set_allocated_description(::std::string* description); + + // int32 rspCode = 1; + void clear_rspcode(); + static const int kRspCodeFieldNumber = 1; + ::google::protobuf::int32 rspcode() const; + void set_rspcode(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:api.RicControlGrpcRsp) + private: + + ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; + ::google::protobuf::internal::ArenaStringPtr description_; + ::google::protobuf::int32 rspcode_; + mutable ::google::protobuf::internal::CachedSize _cached_size_; + friend struct ::protobuf_api_2eproto::TableStruct; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// RICE2APHeader + +// int64 RanFuncId = 1; +inline void RICE2APHeader::clear_ranfuncid() { + ranfuncid_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 RICE2APHeader::ranfuncid() const { + // @@protoc_insertion_point(field_get:api.RICE2APHeader.RanFuncId) + return ranfuncid_; +} +inline void RICE2APHeader::set_ranfuncid(::google::protobuf::int64 value) { + + ranfuncid_ = value; + // @@protoc_insertion_point(field_set:api.RICE2APHeader.RanFuncId) +} + +// int64 RICRequestorID = 2; +inline void RICE2APHeader::clear_ricrequestorid() { + ricrequestorid_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 RICE2APHeader::ricrequestorid() const { + // @@protoc_insertion_point(field_get:api.RICE2APHeader.RICRequestorID) + return ricrequestorid_; +} +inline void RICE2APHeader::set_ricrequestorid(::google::protobuf::int64 value) { + + ricrequestorid_ = value; + // @@protoc_insertion_point(field_set:api.RICE2APHeader.RICRequestorID) +} + +// ------------------------------------------------------------------- + +// RICControlHeader + +// int64 ControlStyle = 1; +inline void RICControlHeader::clear_controlstyle() { + controlstyle_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 RICControlHeader::controlstyle() const { + // @@protoc_insertion_point(field_get:api.RICControlHeader.ControlStyle) + return controlstyle_; +} +inline void RICControlHeader::set_controlstyle(::google::protobuf::int64 value) { + + controlstyle_ = value; + // @@protoc_insertion_point(field_set:api.RICControlHeader.ControlStyle) +} + +// int64 ControlActionId = 2; +inline void RICControlHeader::clear_controlactionid() { + controlactionid_ = GOOGLE_LONGLONG(0); +} +inline ::google::protobuf::int64 RICControlHeader::controlactionid() const { + // @@protoc_insertion_point(field_get:api.RICControlHeader.ControlActionId) + return controlactionid_; +} +inline void RICControlHeader::set_controlactionid(::google::protobuf::int64 value) { + + controlactionid_ = value; + // @@protoc_insertion_point(field_set:api.RICControlHeader.ControlActionId) +} + +// string UEID = 3; +inline void RICControlHeader::clear_ueid() { + ueid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RICControlHeader::ueid() const { + // @@protoc_insertion_point(field_get:api.RICControlHeader.UEID) + return ueid_.GetNoArena(); +} +inline void RICControlHeader::set_ueid(const ::std::string& value) { + + ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RICControlHeader.UEID) +} +#if LANG_CXX11 +inline void RICControlHeader::set_ueid(::std::string&& value) { + + ueid_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RICControlHeader.UEID) +} +#endif +inline void RICControlHeader::set_ueid(const char* value) { + GOOGLE_DCHECK(value != NULL); + + ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RICControlHeader.UEID) +} +inline void RICControlHeader::set_ueid(const char* value, size_t size) { + + ueid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RICControlHeader.UEID) +} +inline ::std::string* RICControlHeader::mutable_ueid() { + + // @@protoc_insertion_point(field_mutable:api.RICControlHeader.UEID) + return ueid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RICControlHeader::release_ueid() { + // @@protoc_insertion_point(field_release:api.RICControlHeader.UEID) + + return ueid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RICControlHeader::set_allocated_ueid(::std::string* ueid) { + if (ueid != NULL) { + + } else { + + } + ueid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ueid); + // @@protoc_insertion_point(field_set_allocated:api.RICControlHeader.UEID) +} + +// ------------------------------------------------------------------- + +// RICControlMessage + +// .api.RICControlCellTypeEnum RICControlCellTypeVal = 1; +inline void RICControlMessage::clear_riccontrolcelltypeval() { + riccontrolcelltypeval_ = 0; +} +inline ::api::RICControlCellTypeEnum RICControlMessage::riccontrolcelltypeval() const { + // @@protoc_insertion_point(field_get:api.RICControlMessage.RICControlCellTypeVal) + return static_cast< ::api::RICControlCellTypeEnum >(riccontrolcelltypeval_); +} +inline void RICControlMessage::set_riccontrolcelltypeval(::api::RICControlCellTypeEnum value) { + + riccontrolcelltypeval_ = value; + // @@protoc_insertion_point(field_set:api.RICControlMessage.RICControlCellTypeVal) +} + +// string TargetCellID = 2; +inline void RICControlMessage::clear_targetcellid() { + targetcellid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RICControlMessage::targetcellid() const { + // @@protoc_insertion_point(field_get:api.RICControlMessage.TargetCellID) + return targetcellid_.GetNoArena(); +} +inline void RICControlMessage::set_targetcellid(const ::std::string& value) { + + targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RICControlMessage.TargetCellID) +} +#if LANG_CXX11 +inline void RICControlMessage::set_targetcellid(::std::string&& value) { + + targetcellid_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RICControlMessage.TargetCellID) +} +#endif +inline void RICControlMessage::set_targetcellid(const char* value) { + GOOGLE_DCHECK(value != NULL); + + targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RICControlMessage.TargetCellID) +} +inline void RICControlMessage::set_targetcellid(const char* value, size_t size) { + + targetcellid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RICControlMessage.TargetCellID) +} +inline ::std::string* RICControlMessage::mutable_targetcellid() { + + // @@protoc_insertion_point(field_mutable:api.RICControlMessage.TargetCellID) + return targetcellid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RICControlMessage::release_targetcellid() { + // @@protoc_insertion_point(field_release:api.RICControlMessage.TargetCellID) + + return targetcellid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RICControlMessage::set_allocated_targetcellid(::std::string* targetcellid) { + if (targetcellid != NULL) { + + } else { + + } + targetcellid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), targetcellid); + // @@protoc_insertion_point(field_set_allocated:api.RICControlMessage.TargetCellID) +} + +// ------------------------------------------------------------------- + +// RicControlGrpcReq + +// string e2NodeID = 1; +inline void RicControlGrpcReq::clear_e2nodeid() { + e2nodeid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RicControlGrpcReq::e2nodeid() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.e2NodeID) + return e2nodeid_.GetNoArena(); +} +inline void RicControlGrpcReq::set_e2nodeid(const ::std::string& value) { + + e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.e2NodeID) +} +#if LANG_CXX11 +inline void RicControlGrpcReq::set_e2nodeid(::std::string&& value) { + + e2nodeid_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.e2NodeID) +} +#endif +inline void RicControlGrpcReq::set_e2nodeid(const char* value) { + GOOGLE_DCHECK(value != NULL); + + e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.e2NodeID) +} +inline void RicControlGrpcReq::set_e2nodeid(const char* value, size_t size) { + + e2nodeid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.e2NodeID) +} +inline ::std::string* RicControlGrpcReq::mutable_e2nodeid() { + + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.e2NodeID) + return e2nodeid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RicControlGrpcReq::release_e2nodeid() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.e2NodeID) + + return e2nodeid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RicControlGrpcReq::set_allocated_e2nodeid(::std::string* e2nodeid) { + if (e2nodeid != NULL) { + + } else { + + } + e2nodeid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), e2nodeid); + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.e2NodeID) +} + +// string plmnID = 2; +inline void RicControlGrpcReq::clear_plmnid() { + plmnid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RicControlGrpcReq::plmnid() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.plmnID) + return plmnid_.GetNoArena(); +} +inline void RicControlGrpcReq::set_plmnid(const ::std::string& value) { + + plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.plmnID) +} +#if LANG_CXX11 +inline void RicControlGrpcReq::set_plmnid(::std::string&& value) { + + plmnid_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.plmnID) +} +#endif +inline void RicControlGrpcReq::set_plmnid(const char* value) { + GOOGLE_DCHECK(value != NULL); + + plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.plmnID) +} +inline void RicControlGrpcReq::set_plmnid(const char* value, size_t size) { + + plmnid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.plmnID) +} +inline ::std::string* RicControlGrpcReq::mutable_plmnid() { + + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.plmnID) + return plmnid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RicControlGrpcReq::release_plmnid() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.plmnID) + + return plmnid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RicControlGrpcReq::set_allocated_plmnid(::std::string* plmnid) { + if (plmnid != NULL) { + + } else { + + } + plmnid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), plmnid); + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.plmnID) +} + +// string ranName = 3; +inline void RicControlGrpcReq::clear_ranname() { + ranname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RicControlGrpcReq::ranname() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.ranName) + return ranname_.GetNoArena(); +} +inline void RicControlGrpcReq::set_ranname(const ::std::string& value) { + + ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.ranName) +} +#if LANG_CXX11 +inline void RicControlGrpcReq::set_ranname(::std::string&& value) { + + ranname_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcReq.ranName) +} +#endif +inline void RicControlGrpcReq::set_ranname(const char* value) { + GOOGLE_DCHECK(value != NULL); + + ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RicControlGrpcReq.ranName) +} +inline void RicControlGrpcReq::set_ranname(const char* value, size_t size) { + + ranname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcReq.ranName) +} +inline ::std::string* RicControlGrpcReq::mutable_ranname() { + + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.ranName) + return ranname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RicControlGrpcReq::release_ranname() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.ranName) + + return ranname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RicControlGrpcReq::set_allocated_ranname(::std::string* ranname) { + if (ranname != NULL) { + + } else { + + } + ranname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ranname); + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.ranName) +} + +// .api.RICE2APHeader RICE2APHeaderData = 4; +inline bool RicControlGrpcReq::has_rice2apheaderdata() const { + return this != internal_default_instance() && rice2apheaderdata_ != NULL; +} +inline void RicControlGrpcReq::clear_rice2apheaderdata() { + if (GetArenaNoVirtual() == NULL && rice2apheaderdata_ != NULL) { + delete rice2apheaderdata_; + } + rice2apheaderdata_ = NULL; +} +inline const ::api::RICE2APHeader& RicControlGrpcReq::_internal_rice2apheaderdata() const { + return *rice2apheaderdata_; +} +inline const ::api::RICE2APHeader& RicControlGrpcReq::rice2apheaderdata() const { + const ::api::RICE2APHeader* p = rice2apheaderdata_; + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICE2APHeaderData) + return p != NULL ? *p : *reinterpret_cast( + &::api::_RICE2APHeader_default_instance_); +} +inline ::api::RICE2APHeader* RicControlGrpcReq::release_rice2apheaderdata() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICE2APHeaderData) + + ::api::RICE2APHeader* temp = rice2apheaderdata_; + rice2apheaderdata_ = NULL; + return temp; +} +inline ::api::RICE2APHeader* RicControlGrpcReq::mutable_rice2apheaderdata() { + + if (rice2apheaderdata_ == NULL) { + auto* p = CreateMaybeMessage<::api::RICE2APHeader>(GetArenaNoVirtual()); + rice2apheaderdata_ = p; + } + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICE2APHeaderData) + return rice2apheaderdata_; +} +inline void RicControlGrpcReq::set_allocated_rice2apheaderdata(::api::RICE2APHeader* rice2apheaderdata) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete rice2apheaderdata_; + } + if (rice2apheaderdata) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + rice2apheaderdata = ::google::protobuf::internal::GetOwnedMessage( + message_arena, rice2apheaderdata, submessage_arena); + } + + } else { + + } + rice2apheaderdata_ = rice2apheaderdata; + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICE2APHeaderData) +} + +// .api.RICControlHeader RICControlHeaderData = 5; +inline bool RicControlGrpcReq::has_riccontrolheaderdata() const { + return this != internal_default_instance() && riccontrolheaderdata_ != NULL; +} +inline void RicControlGrpcReq::clear_riccontrolheaderdata() { + if (GetArenaNoVirtual() == NULL && riccontrolheaderdata_ != NULL) { + delete riccontrolheaderdata_; + } + riccontrolheaderdata_ = NULL; +} +inline const ::api::RICControlHeader& RicControlGrpcReq::_internal_riccontrolheaderdata() const { + return *riccontrolheaderdata_; +} +inline const ::api::RICControlHeader& RicControlGrpcReq::riccontrolheaderdata() const { + const ::api::RICControlHeader* p = riccontrolheaderdata_; + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlHeaderData) + return p != NULL ? *p : *reinterpret_cast( + &::api::_RICControlHeader_default_instance_); +} +inline ::api::RICControlHeader* RicControlGrpcReq::release_riccontrolheaderdata() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICControlHeaderData) + + ::api::RICControlHeader* temp = riccontrolheaderdata_; + riccontrolheaderdata_ = NULL; + return temp; +} +inline ::api::RICControlHeader* RicControlGrpcReq::mutable_riccontrolheaderdata() { + + if (riccontrolheaderdata_ == NULL) { + auto* p = CreateMaybeMessage<::api::RICControlHeader>(GetArenaNoVirtual()); + riccontrolheaderdata_ = p; + } + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICControlHeaderData) + return riccontrolheaderdata_; +} +inline void RicControlGrpcReq::set_allocated_riccontrolheaderdata(::api::RICControlHeader* riccontrolheaderdata) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete riccontrolheaderdata_; + } + if (riccontrolheaderdata) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + riccontrolheaderdata = ::google::protobuf::internal::GetOwnedMessage( + message_arena, riccontrolheaderdata, submessage_arena); + } + + } else { + + } + riccontrolheaderdata_ = riccontrolheaderdata; + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICControlHeaderData) +} + +// .api.RICControlMessage RICControlMessageData = 6; +inline bool RicControlGrpcReq::has_riccontrolmessagedata() const { + return this != internal_default_instance() && riccontrolmessagedata_ != NULL; +} +inline void RicControlGrpcReq::clear_riccontrolmessagedata() { + if (GetArenaNoVirtual() == NULL && riccontrolmessagedata_ != NULL) { + delete riccontrolmessagedata_; + } + riccontrolmessagedata_ = NULL; +} +inline const ::api::RICControlMessage& RicControlGrpcReq::_internal_riccontrolmessagedata() const { + return *riccontrolmessagedata_; +} +inline const ::api::RICControlMessage& RicControlGrpcReq::riccontrolmessagedata() const { + const ::api::RICControlMessage* p = riccontrolmessagedata_; + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlMessageData) + return p != NULL ? *p : *reinterpret_cast( + &::api::_RICControlMessage_default_instance_); +} +inline ::api::RICControlMessage* RicControlGrpcReq::release_riccontrolmessagedata() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcReq.RICControlMessageData) + + ::api::RICControlMessage* temp = riccontrolmessagedata_; + riccontrolmessagedata_ = NULL; + return temp; +} +inline ::api::RICControlMessage* RicControlGrpcReq::mutable_riccontrolmessagedata() { + + if (riccontrolmessagedata_ == NULL) { + auto* p = CreateMaybeMessage<::api::RICControlMessage>(GetArenaNoVirtual()); + riccontrolmessagedata_ = p; + } + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcReq.RICControlMessageData) + return riccontrolmessagedata_; +} +inline void RicControlGrpcReq::set_allocated_riccontrolmessagedata(::api::RICControlMessage* riccontrolmessagedata) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == NULL) { + delete riccontrolmessagedata_; + } + if (riccontrolmessagedata) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + riccontrolmessagedata = ::google::protobuf::internal::GetOwnedMessage( + message_arena, riccontrolmessagedata, submessage_arena); + } + + } else { + + } + riccontrolmessagedata_ = riccontrolmessagedata; + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcReq.RICControlMessageData) +} + +// .api.RICControlAckEnum RICControlAckReqVal = 7; +inline void RicControlGrpcReq::clear_riccontrolackreqval() { + riccontrolackreqval_ = 0; +} +inline ::api::RICControlAckEnum RicControlGrpcReq::riccontrolackreqval() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcReq.RICControlAckReqVal) + return static_cast< ::api::RICControlAckEnum >(riccontrolackreqval_); +} +inline void RicControlGrpcReq::set_riccontrolackreqval(::api::RICControlAckEnum value) { + + riccontrolackreqval_ = value; + // @@protoc_insertion_point(field_set:api.RicControlGrpcReq.RICControlAckReqVal) +} + +// ------------------------------------------------------------------- + +// RicControlGrpcRsp + +// int32 rspCode = 1; +inline void RicControlGrpcRsp::clear_rspcode() { + rspcode_ = 0; +} +inline ::google::protobuf::int32 RicControlGrpcRsp::rspcode() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcRsp.rspCode) + return rspcode_; +} +inline void RicControlGrpcRsp::set_rspcode(::google::protobuf::int32 value) { + + rspcode_ = value; + // @@protoc_insertion_point(field_set:api.RicControlGrpcRsp.rspCode) +} + +// string description = 2; +inline void RicControlGrpcRsp::clear_description() { + description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline const ::std::string& RicControlGrpcRsp::description() const { + // @@protoc_insertion_point(field_get:api.RicControlGrpcRsp.description) + return description_.GetNoArena(); +} +inline void RicControlGrpcRsp::set_description(const ::std::string& value) { + + description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:api.RicControlGrpcRsp.description) +} +#if LANG_CXX11 +inline void RicControlGrpcRsp::set_description(::std::string&& value) { + + description_.SetNoArena( + &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:api.RicControlGrpcRsp.description) +} +#endif +inline void RicControlGrpcRsp::set_description(const char* value) { + GOOGLE_DCHECK(value != NULL); + + description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:api.RicControlGrpcRsp.description) +} +inline void RicControlGrpcRsp::set_description(const char* value, size_t size) { + + description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:api.RicControlGrpcRsp.description) +} +inline ::std::string* RicControlGrpcRsp::mutable_description() { + + // @@protoc_insertion_point(field_mutable:api.RicControlGrpcRsp.description) + return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline ::std::string* RicControlGrpcRsp::release_description() { + // @@protoc_insertion_point(field_release:api.RicControlGrpcRsp.description) + + return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +inline void RicControlGrpcRsp::set_allocated_description(::std::string* description) { + if (description != NULL) { + + } else { + + } + description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description); + // @@protoc_insertion_point(field_set_allocated:api.RicControlGrpcRsp.description) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace api + +namespace google { +namespace protobuf { + +template <> struct is_proto_enum< ::api::RICControlCellTypeEnum> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::api::RICControlCellTypeEnum>() { + return ::api::RICControlCellTypeEnum_descriptor(); +} +template <> struct is_proto_enum< ::api::RICControlAckEnum> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::api::RICControlAckEnum>() { + return ::api::RICControlAckEnum_descriptor(); +} + +} // namespace protobuf +} // namespace google + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_INCLUDED_api_2eproto diff --git a/ext/protobuf/api.proto b/ext/protobuf/api.proto new file mode 100644 index 0000000..bb51275 --- /dev/null +++ b/ext/protobuf/api.proto @@ -0,0 +1,60 @@ +syntax = "proto3"; +package api; + +enum RICControlCellTypeEnum { + + RIC_CONTROL_CELL_UNKWON = 0; + RIC_CONTROL_NR_CELL = 1; // Indicates RIC Controls should be set for NR CELL + RIC_CONTROL_EUTRAN_CELL = 2; // Indicates RIC Controls should be set for E_UTRAN CELL +} + +enum RICControlAckEnum { + + RIC_CONTROL_ACK_UNKWON = 0; + RIC_CONTROL_NO_ACK = 1; // Optional RIC Control Acknowledgement is not required + RIC_CONTROL_ACK = 2; // Optional RIC Control Acknowledgement is required + RIC_CONTROL_NACK = 3; // Optional RIC Control Acknowledgement is only required to report failure +} + +message RICE2APHeader { + int64 RanFuncId = 1; + int64 RICRequestorID = 2; +} + +message RICControlHeader { + int64 ControlStyle = 1; + int64 ControlActionId = 2; + string UEID = 3; +} + + +message RICControlMessage { + RICControlCellTypeEnum RICControlCellTypeVal = 1; + string TargetCellID = 2; + +} + +//RicControl GRPC Req +message RicControlGrpcReq { + string e2NodeID = 1; + string plmnID = 2; + string ranName = 3; + RICE2APHeader RICE2APHeaderData = 4; + RICControlHeader RICControlHeaderData = 5; + RICControlMessage RICControlMessageData = 6; + RICControlAckEnum RICControlAckReqVal = 7; //Currently this Parameter is not Encoded as Part of RIC Control message +} + +//RicControlGrpc Rsp +message RicControlGrpcRsp { + int32 rspCode = 1; //Set rspCode to 0. Acknowledging the receipt of GRPC request + string description = 2; //Set despcription. +} + +// Services to send gRPC +service MsgComm { + //gRPC call to Send RICControlReqServiceGrpc + rpc SendRICControlReqServiceGrpc(RicControlGrpcReq) returns (RicControlGrpcRsp); +} + + diff --git a/src/ts_xapp/CMakeLists.txt b/src/ts_xapp/CMakeLists.txt index 9fbc412..fe4fb2b 100644 --- a/src/ts_xapp/CMakeLists.txt +++ b/src/ts_xapp/CMakeLists.txt @@ -15,8 +15,10 @@ #================================================================================== # +find_package(Protobuf REQUIRED) + add_executable( ts_xapp ts_xapp.cpp ) -target_link_libraries( ts_xapp ricxfcpp;rmr_si;pthread;curl ) +target_link_libraries( ts_xapp ricxfcpp;rmr_si;pthread;curl;rc-api;grpc++;${Protobuf_LIBRARY} ) install( TARGETS ts_xapp diff --git a/src/ts_xapp/ts_xapp.cpp b/src/ts_xapp/ts_xapp.cpp index a198c32..7b32878 100644 --- a/src/ts_xapp/ts_xapp.cpp +++ b/src/ts_xapp/ts_xapp.cpp @@ -31,6 +31,8 @@ Modified: 21 May 2021 (Alexandre Huff) Update for traffic steering use case in release D. + 07 Dec 2021 (Alexandre Huff) + Update for traffic steering use case in release E. */ #include @@ -57,10 +59,21 @@ #include #include #include "ricxfcpp/xapp.hpp" +#include "ricxfcpp/config.hpp" +/* + FIXME unfortunately this RMR flag has to be disabled + due to name resolution conflicts. + RC xApp defines the same name for gRPC control messages. +*/ +#undef RIC_CONTROL_ACK -// Defines env name for the endpoint to POST handoff control messages -#define ENV_CONTROL_URL "TS_CONTROL_URL" +#include +#include +#include +#include +#include +#include "../../ext/protobuf/api.grpc.pb.h" using namespace rapidjson; @@ -75,14 +88,16 @@ using Keys = std::set; // ---------------------------------------------------------- - -// Stores the the URL to POST handoff control messages -const char *ts_control_url; - std::unique_ptr xfw; +std::unique_ptr rc_stub; int rsrp_threshold = 0; +// scoped enum to identify which API is used to send control messages +enum class TsControlApi { REST, gRPC }; +TsControlApi ts_control_api; // api to send control messages +string ts_control_ep; // api target endpoint + /* struct UEData { string serving_cell; int serving_cell_rsrp; @@ -391,9 +406,9 @@ size_t handoff_reply_callback( const char *in, size_t size, size_t num, string * } // sends a handover message through REST -void send_handoff_request( string msg ) { +void send_rest_control_request( string msg ) { CURL *curl = curl_easy_init(); - curl_easy_setopt( curl, CURLOPT_URL, ts_control_url ); + curl_easy_setopt( curl, CURLOPT_URL, ts_control_ep.c_str() ); curl_easy_setopt( curl, CURLOPT_TIMEOUT, 10 ); curl_easy_setopt( curl, CURLOPT_POST, 1L ); // curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); @@ -411,7 +426,7 @@ void send_handoff_request( string msg ) { headers = curl_slist_append( headers, "Content-Type: application/json" ); curl_easy_setopt( curl, CURLOPT_HTTPHEADER, headers ); - cout << "[INFO] Sending a HandOff CONTROL message to \"" << ts_control_url << "\"\n"; + cout << "[INFO] Sending a HandOff CONTROL message to \"" << ts_control_ep << "\"\n"; cout << "[INFO] HandOff request is " << msg << endl; // sending request @@ -434,9 +449,9 @@ void send_handoff_request( string msg ) { } else if ( httpCode == 404 ) { - cout << "[ERROR] HTTP 404 Not Found: " << ts_control_url << endl; + cout << "[ERROR] HTTP 404 Not Found: " << ts_control_ep << endl; } else { - cout << "[ERROR] Unexpected HTTP code " << httpCode << " from " << ts_control_url << \ + cout << "[ERROR] Unexpected HTTP code " << httpCode << " from " << ts_control_ep << \ "\n[ERROR] HTTP payload is " << httpData.get()->c_str() << endl; } @@ -446,6 +461,47 @@ void send_handoff_request( string msg ) { curl_easy_cleanup( curl ); } +// sends a handover message to RC xApp through gRPC +void send_grpc_control_request() { + grpc::ClientContext context; + api::RicControlGrpcReq *request = api::RicControlGrpcReq().New(); + api::RicControlGrpcRsp response; + + api::RICE2APHeader *apHeader = api::RICE2APHeader().New(); + api::RICControlHeader *ctrlHeader = api::RICControlHeader().New(); + api::RICControlMessage *ctrlMsg = api::RICControlMessage().New(); + + request->set_e2nodeid("e2nodeid"); + request->set_plmnid("plmnid"); + request->set_ranname("ranname"); + request->set_allocated_rice2apheaderdata(apHeader); + request->set_allocated_riccontrolheaderdata(ctrlHeader); + request->set_allocated_riccontrolmessagedata(ctrlMsg); + request->set_riccontrolackreqval(api::RIC_CONTROL_ACK_UNKWON); // not yet used in api.proto + + grpc::Status status = rc_stub->SendRICControlReqServiceGrpc(&context, *request, &response); + + if(status.ok()) { + /* + TODO check if this is related to RICControlAckEnum + if yes, then ACK value should be 2 (RIC_CONTROL_ACK) + api.proto assumes that 0 is an ACK + */ + if(response.rspcode() == 0) { + cout << "[INFO] Control Request succeeded with code=0, description=" << response.description() << endl; + } else { + cout << "[ERROR] Control Request failed with code=" << response.rspcode() + << ", description=" << response.description() << endl; + } + + } else { + cout << "[ERROR] failed to send a RIC Control Request message to RC xApp, error_code=" + << status.error_code() << ", error_msg=" << status.error_message() << endl; + } + + // FIXME needs to check about memory likeage +} + void prediction_callback( Message& mbuf, int mtype, int subid, int len, Msg_component payload, void* data ) { time_t now; @@ -456,7 +512,7 @@ void prediction_callback( Message& mbuf, int mtype, int subid, int len, Msg_comp int send_mtype = 0; int rmtype; // received message type - int delay = 1000000; // mu-sec delay; default 1s + int delay = 1000000; // mu-sec delay; default 1s string json ((char *)payload.get(), len); // RMR payload might not have a nil terminanted char @@ -543,7 +599,11 @@ void prediction_callback( Message& mbuf, int mtype, int subid, int len, Msg_comp } */ // sending a control request message - send_handoff_request( s.GetString() ); + if ( ts_control_api == TsControlApi::REST ) { + send_rest_control_request( s.GetString() ); + } else { + send_grpc_control_request(); + } } else { cout << "[INFO] The current serving cell \"" << handler.serving_cell_id << "\" is the best one" << endl; @@ -624,13 +684,24 @@ extern int main( int argc, char** argv ) { int nthreads = 1; char* port = (char *) "4560"; - - // ts_control_url = "http://127.0.0.1:5000/api/echo"; // echo-server in test/app/ directory - if ( ( ts_control_url = getenv( ENV_CONTROL_URL ) ) == nullptr ) { - cout << "[ERROR] TS_CONTROL_URL is not defined to POST handoff control messages" << endl; - return 1; + shared_ptr channel; + + Config *config = new Config(); + string api = config->Get_control_str("ts_control_api"); + ts_control_ep = config->Get_control_str("ts_control_ep"); + if ( api.empty() ) { + cout << "[ERROR] a control api (rest/grpc) is required in xApp descriptor\n"; + exit(1); + } + if ( api.compare("rest") == 0 ) { + ts_control_api = TsControlApi::REST; + } else { + ts_control_api = TsControlApi::gRPC; } + channel = grpc::CreateChannel(ts_control_ep, grpc::InsecureChannelCredentials()); + rc_stub = api::MsgComm::NewStub(channel, grpc::StubOptions()); + fprintf( stderr, "[TS xApp] listening on port %s\n", port ); xfw = std::unique_ptr( new Xapp( port, true ) ); diff --git a/test/app/CMakeLists.txt b/test/app/CMakeLists.txt index ffd4cee..5d3eac2 100644 --- a/test/app/CMakeLists.txt +++ b/test/app/CMakeLists.txt @@ -15,15 +15,12 @@ # limitations under the License. # ================================================================================== # -# Mnemonic: ad_xapp.cpp -# Abstract: Simulates the AD xApp sending an anomaly dectection message to -# the TS xApp. It sends one message and exits. -# # Date: 20 May 2021 # Author: Alexandre Huff cmake_minimum_required(VERSION 3.14) +project(test_apps) set(CMAKE_CXX_STANDARD 11) add_executable( @@ -49,3 +46,16 @@ target_link_libraries( pthread curl ) + +find_package(Protobuf REQUIRED) +add_subdirectory(${CMAKE_SOURCE_DIR}/../../ext/protobuf EXCLUDED_FROM_ALL) +add_executable( + rc_xapp + rc_xapp.cpp +) +target_link_libraries( + rc_xapp + rc-api + grpc++ + ${Protobuf_LIBRARY} +) diff --git a/test/app/rc_xapp.cpp b/test/app/rc_xapp.cpp new file mode 100644 index 0000000..cdf46a0 --- /dev/null +++ b/test/app/rc_xapp.cpp @@ -0,0 +1,76 @@ +// vi: ts=4 sw=4 noet: +/* +================================================================================== + Copyright (c) 2021 AT&T Intellectual Property. + Copyright (c) 2021 Alexandre Huff. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +================================================================================== +*/ + +/* + Mnemonic: rc_xapp.cpp + Abstract: Implements a simple echo server just for testing gRPC calls + from TS xApp. + + Date: 08 Dec 2021 + Author: Alexandre Huff +*/ + +#include + +#include +#include +#include +#include + +#include "../../ext/protobuf/api.grpc.pb.h" + +using namespace std; + +class ControlServiceImpl : public api::MsgComm::Service { + ::grpc::Status SendRICControlReqServiceGrpc(::grpc::ServerContext* context, const ::api::RicControlGrpcReq* request, + ::api::RicControlGrpcRsp* response) override { + cout << "[RC] Received a new gRPC message\n"; + + /* + TODO check if this is related to RICControlAckEnum + if yes, then ACK value should be 2 (RIC_CONTROL_ACK) + api.proto assumes that 0 is an ACK + */ + response->set_rspcode(0); + response->set_description("ACK"); + + return ::grpc::Status::OK; + } +}; + +void RunServer() { + string server_address("0.0.0.0:50051"); + ControlServiceImpl service; + + grpc::ServerBuilder builder; + builder.AddListeningPort(server_address, grpc::InsecureServerCredentials()); + builder.RegisterService(&service); + + unique_ptr server(builder.BuildAndStart()); + + cout << "[RC] Server listening on " << server_address << std::endl; + server->Wait(); +} + +int main(int argc, char const *argv[]) { + RunServer(); + + return 0; +} \ No newline at end of file diff --git a/xapp-descriptor/config.json b/xapp-descriptor/config.json index 10d10fc..e3c33c8 100644 --- a/xapp-descriptor/config.json +++ b/xapp-descriptor/config.json @@ -1,13 +1,13 @@ { "xapp_name": "trafficxapp", - "version": "1.0.0", + "version": "1.2.0", "containers": [ { "name": "trafficxapp", "image": { "registry": "nexus3.o-ran-sc.org:10002", "name": "o-ran-sc/ric-app-ts", - "tag": "1.1.1" + "tag": "1.2.0" } } ], @@ -24,13 +24,13 @@ ], "txMessages": [ "TS_UE_LIST", "TS_ANOMALY_ACK" ], "policies": [20008], - "description": "rmr receive data port for mcxapp" + "description": "rmr receive data port for trafficxapp" }, { "name": "rmr-route", "container": "trafficxapp", "port": 4561, - "description": "rmr route port for mcxapp" + "description": "rmr route port for trafficxapp" } ] }, @@ -48,5 +48,10 @@ "TS_ANOMALY_UPDATE" ], "policies": [20008] + }, + "controls": { + "ts_control_api": "grpc", + "ts_control_ep": "localhost:50051" } + } diff --git a/xapp-descriptor/schema.json b/xapp-descriptor/schema.json new file mode 100644 index 0000000..0339c18 --- /dev/null +++ b/xapp-descriptor/schema.json @@ -0,0 +1,28 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "#/controls", + "type": "object", + "title": "Controls Section Schema", + "required": [ + "ts_control_api", + "ts_control_ep" + ], + "properties": { + "ts_control_api": { + "$id": "#/properties/controls/items/properties/ts_control_api", + "enum": ["rest", "grpc"], + "title": "The TS API used to send control messages", + "default": "rest" + }, + "ts_control_ep": { + "$id": "#/properties/controls/items/properties/ts_control_ep", + "type": "string", + "title": "The target endpoint of the TS Control API", + "default": "http://127.0.0.1:5000/api/echo", + "examples": [ + "http://127.0.0.1:5000/api/echo", + "localhost:50051" + ] + } + } +} -- 2.16.6