entities/nb_types.pb.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16
  17 //
  18 // This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19 // platform project (RICP).
  20
  21 // Code generated by protoc-gen-go. DO NOT EDIT.
  22 // versions:
  23 //      protoc-gen-go v1.25.0
  24 //      protoc        v3.6.1
  25 // source: nb_types.proto
  26
  27 package entities
  28
  29 import (
  30         proto "github.com/golang/protobuf/proto"
  31         protoreflect "google.golang.org/protobuf/reflect/protoreflect"
  32         protoimpl "google.golang.org/protobuf/runtime/protoimpl"
  33         reflect "reflect"
  34         sync "sync"
  35 )
  36
  37 const (
  38         // Verify that this generated code is sufficiently up-to-date.
  39         _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
  40         // Verify that runtime/protoimpl is sufficiently up-to-date.
  41         _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
  42 )
  43
  44 // This is a compile-time assertion that a sufficiently up-to-date version
  45 // of the legacy proto package is being used.
  46 const _ = proto.ProtoPackageIsVersion4
  47
  48 type EnbType int32
  49
  50 const (
  51         EnbType_UNKNOWN_ENB_TYPE   EnbType = 0
  52         EnbType_MACRO_ENB          EnbType = 1
  53         EnbType_HOME_ENB           EnbType = 2
  54         EnbType_SHORT_MACRO_ENB    EnbType = 3
  55         EnbType_LONG_MACRO_ENB     EnbType = 4
  56         EnbType_MACRO_NG_ENB       EnbType = 5
  57         EnbType_SHORT_MACRO_NG_ENB EnbType = 6
  58         EnbType_LONG_MACRO_NG_ENB  EnbType = 7
  59 )
  60
  61 // Enum value maps for EnbType.
  62 var (
  63         EnbType_name = map[int32]string{
  64                 0: "UNKNOWN_ENB_TYPE",
  65                 1: "MACRO_ENB",
  66                 2: "HOME_ENB",
  67                 3: "SHORT_MACRO_ENB",
  68                 4: "LONG_MACRO_ENB",
  69                 5: "MACRO_NG_ENB",
  70                 6: "SHORT_MACRO_NG_ENB",
  71                 7: "LONG_MACRO_NG_ENB",
  72         }
  73         EnbType_value = map[string]int32{
  74                 "UNKNOWN_ENB_TYPE":   0,
  75                 "MACRO_ENB":          1,
  76                 "HOME_ENB":           2,
  77                 "SHORT_MACRO_ENB":    3,
  78                 "LONG_MACRO_ENB":     4,
  79                 "MACRO_NG_ENB":       5,
  80                 "SHORT_MACRO_NG_ENB": 6,
  81                 "LONG_MACRO_NG_ENB":  7,
  82         }
  83 )
  84
  85 func (x EnbType) Enum() *EnbType {
  86         p := new(EnbType)
  87         *p = x
  88         return p
  89 }
  90
  91 func (x EnbType) String() string {
  92         return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
  93 }
  94
  95 func (EnbType) Descriptor() protoreflect.EnumDescriptor {
  96         return file_nb_types_proto_enumTypes[0].Descriptor()
  97 }
  98
  99 func (EnbType) Type() protoreflect.EnumType {
 100         return &file_nb_types_proto_enumTypes[0]
 101 }
 102
 103 func (x EnbType) Number() protoreflect.EnumNumber {
 104         return protoreflect.EnumNumber(x)
 105 }
 106
 107 // Deprecated: Use EnbType.Descriptor instead.
 108 func (EnbType) EnumDescriptor() ([]byte, []int) {
 109         return file_nb_types_proto_rawDescGZIP(), []int{0}
 110 }
 111
 112 type GnbType int32
 113
 114 const (
 115         GnbType_UNKNOWN_GNB_TYPE GnbType = 0
 116         GnbType_GNB              GnbType = 1
 117         GnbType_EN_GNB           GnbType = 2
 118 )
 119
 120 // Enum value maps for GnbType.
 121 var (
 122         GnbType_name = map[int32]string{
 123                 0: "UNKNOWN_GNB_TYPE",
 124                 1: "GNB",
 125                 2: "EN_GNB",
 126         }
 127         GnbType_value = map[string]int32{
 128                 "UNKNOWN_GNB_TYPE": 0,
 129                 "GNB":              1,
 130                 "EN_GNB":           2,
 131         }
 132 )
 133
 134 func (x GnbType) Enum() *GnbType {
 135         p := new(GnbType)
 136         *p = x
 137         return p
 138 }
 139
 140 func (x GnbType) String() string {
 141         return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
 142 }
 143
 144 func (GnbType) Descriptor() protoreflect.EnumDescriptor {
 145         return file_nb_types_proto_enumTypes[1].Descriptor()
 146 }
 147
 148 func (GnbType) Type() protoreflect.EnumType {
 149         return &file_nb_types_proto_enumTypes[1]
 150 }
 151
 152 func (x GnbType) Number() protoreflect.EnumNumber {
 153         return protoreflect.EnumNumber(x)
 154 }
 155
 156 // Deprecated: Use GnbType.Descriptor instead.
 157 func (GnbType) EnumDescriptor() ([]byte, []int) {
 158         return file_nb_types_proto_rawDescGZIP(), []int{1}
 159 }
 160
 161 var File_nb_types_proto protoreflect.FileDescriptor
 162
 163 var file_nb_types_proto_rawDesc = []byte{
 164         0x0a, 0x0e, 0x6e, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 165         0x12, 0x08, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2a, 0xa6, 0x01, 0x0a, 0x07, 0x45,
 166         0x6e, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x10, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57,
 167         0x4e, 0x5f, 0x45, 0x4e, 0x42, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09,
 168         0x4d, 0x41, 0x43, 0x52, 0x4f, 0x5f, 0x45, 0x4e, 0x42, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x48,
 169         0x4f, 0x4d, 0x45, 0x5f, 0x45, 0x4e, 0x42, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x53, 0x48, 0x4f,
 170         0x52, 0x54, 0x5f, 0x4d, 0x41, 0x43, 0x52, 0x4f, 0x5f, 0x45, 0x4e, 0x42, 0x10, 0x03, 0x12, 0x12,
 171         0x0a, 0x0e, 0x4c, 0x4f, 0x4e, 0x47, 0x5f, 0x4d, 0x41, 0x43, 0x52, 0x4f, 0x5f, 0x45, 0x4e, 0x42,
 172         0x10, 0x04, 0x12, 0x10, 0x0a, 0x0c, 0x4d, 0x41, 0x43, 0x52, 0x4f, 0x5f, 0x4e, 0x47, 0x5f, 0x45,
 173         0x4e, 0x42, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x48, 0x4f, 0x52, 0x54, 0x5f, 0x4d, 0x41,
 174         0x43, 0x52, 0x4f, 0x5f, 0x4e, 0x47, 0x5f, 0x45, 0x4e, 0x42, 0x10, 0x06, 0x12, 0x15, 0x0a, 0x11,
 175         0x4c, 0x4f, 0x4e, 0x47, 0x5f, 0x4d, 0x41, 0x43, 0x52, 0x4f, 0x5f, 0x4e, 0x47, 0x5f, 0x45, 0x4e,
 176         0x42, 0x10, 0x07, 0x2a, 0x34, 0x0a, 0x07, 0x47, 0x6e, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14,
 177         0x0a, 0x10, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x47, 0x4e, 0x42, 0x5f, 0x54, 0x59,
 178         0x50, 0x45, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x47, 0x4e, 0x42, 0x10, 0x01, 0x12, 0x0a, 0x0a,
 179         0x06, 0x45, 0x4e, 0x5f, 0x47, 0x4e, 0x42, 0x10, 0x02, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 180         0x33,
 181 }
 182
 183 var (
 184         file_nb_types_proto_rawDescOnce sync.Once
 185         file_nb_types_proto_rawDescData = file_nb_types_proto_rawDesc
 186 )
 187
 188 func file_nb_types_proto_rawDescGZIP() []byte {
 189         file_nb_types_proto_rawDescOnce.Do(func() {
 190                 file_nb_types_proto_rawDescData = protoimpl.X.CompressGZIP(file_nb_types_proto_rawDescData)
 191         })
 192         return file_nb_types_proto_rawDescData
 193 }
 194
 195 var file_nb_types_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
 196 var file_nb_types_proto_goTypes = []interface{}{
 197         (EnbType)(0), // 0: entities.EnbType
 198         (GnbType)(0), // 1: entities.GnbType
 199 }
 200 var file_nb_types_proto_depIdxs = []int32{
 201         0, // [0:0] is the sub-list for method output_type
 202         0, // [0:0] is the sub-list for method input_type
 203         0, // [0:0] is the sub-list for extension type_name
 204         0, // [0:0] is the sub-list for extension extendee
 205         0, // [0:0] is the sub-list for field type_name
 206 }
 207
 208 func init() { file_nb_types_proto_init() }
 209 func file_nb_types_proto_init() {
 210         if File_nb_types_proto != nil {
 211                 return
 212         }
 213         type x struct{}
 214         out := protoimpl.TypeBuilder{
 215                 File: protoimpl.DescBuilder{
 216                         GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 217                         RawDescriptor: file_nb_types_proto_rawDesc,
 218                         NumEnums:      2,
 219                         NumMessages:   0,
 220                         NumExtensions: 0,
 221                         NumServices:   0,
 222                 },
 223                 GoTypes:           file_nb_types_proto_goTypes,
 224                 DependencyIndexes: file_nb_types_proto_depIdxs,
 225                 EnumInfos:         file_nb_types_proto_enumTypes,
 226         }.Build()
 227         File_nb_types_proto = out.File
 228         file_nb_types_proto_rawDesc = nil
 229         file_nb_types_proto_goTypes = nil
 230         file_nb_types_proto_depIdxs = nil
 231 }