merge of the e2ap-v2.0 branch
[ric-plt/nodeb-rnib.git] / entities / cell.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: cell.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 Cell_Type int32
49
50 const (
51         Cell_UNKNOWN_CELL Cell_Type = 0
52         Cell_LTE_CELL     Cell_Type = 1
53         Cell_NR_CELL      Cell_Type = 2
54 )
55
56 // Enum value maps for Cell_Type.
57 var (
58         Cell_Type_name = map[int32]string{
59                 0: "UNKNOWN_CELL",
60                 1: "LTE_CELL",
61                 2: "NR_CELL",
62         }
63         Cell_Type_value = map[string]int32{
64                 "UNKNOWN_CELL": 0,
65                 "LTE_CELL":     1,
66                 "NR_CELL":      2,
67         }
68 )
69
70 func (x Cell_Type) Enum() *Cell_Type {
71         p := new(Cell_Type)
72         *p = x
73         return p
74 }
75
76 func (x Cell_Type) String() string {
77         return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
78 }
79
80 func (Cell_Type) Descriptor() protoreflect.EnumDescriptor {
81         return file_cell_proto_enumTypes[0].Descriptor()
82 }
83
84 func (Cell_Type) Type() protoreflect.EnumType {
85         return &file_cell_proto_enumTypes[0]
86 }
87
88 func (x Cell_Type) Number() protoreflect.EnumNumber {
89         return protoreflect.EnumNumber(x)
90 }
91
92 // Deprecated: Use Cell_Type.Descriptor instead.
93 func (Cell_Type) EnumDescriptor() ([]byte, []int) {
94         return file_cell_proto_rawDescGZIP(), []int{0, 0}
95 }
96
97 type Cell struct {
98         state         protoimpl.MessageState
99         sizeCache     protoimpl.SizeCache
100         unknownFields protoimpl.UnknownFields
101
102         Type Cell_Type `protobuf:"varint,1,opt,name=type,proto3,enum=entities.Cell_Type" json:"type,omitempty"`
103         // Types that are assignable to Cell:
104         //      *Cell_ServedCellInfo
105         //      *Cell_ServedNrCell
106         Cell isCell_Cell `protobuf_oneof:"cell"`
107 }
108
109 func (x *Cell) Reset() {
110         *x = Cell{}
111         if protoimpl.UnsafeEnabled {
112                 mi := &file_cell_proto_msgTypes[0]
113                 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
114                 ms.StoreMessageInfo(mi)
115         }
116 }
117
118 func (x *Cell) String() string {
119         return protoimpl.X.MessageStringOf(x)
120 }
121
122 func (*Cell) ProtoMessage() {}
123
124 func (x *Cell) ProtoReflect() protoreflect.Message {
125         mi := &file_cell_proto_msgTypes[0]
126         if protoimpl.UnsafeEnabled && x != nil {
127                 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
128                 if ms.LoadMessageInfo() == nil {
129                         ms.StoreMessageInfo(mi)
130                 }
131                 return ms
132         }
133         return mi.MessageOf(x)
134 }
135
136 // Deprecated: Use Cell.ProtoReflect.Descriptor instead.
137 func (*Cell) Descriptor() ([]byte, []int) {
138         return file_cell_proto_rawDescGZIP(), []int{0}
139 }
140
141 func (x *Cell) GetType() Cell_Type {
142         if x != nil {
143                 return x.Type
144         }
145         return Cell_UNKNOWN_CELL
146 }
147
148 func (m *Cell) GetCell() isCell_Cell {
149         if m != nil {
150                 return m.Cell
151         }
152         return nil
153 }
154
155 func (x *Cell) GetServedCellInfo() *ServedCellInfo {
156         if x, ok := x.GetCell().(*Cell_ServedCellInfo); ok {
157                 return x.ServedCellInfo
158         }
159         return nil
160 }
161
162 func (x *Cell) GetServedNrCell() *ServedNRCell {
163         if x, ok := x.GetCell().(*Cell_ServedNrCell); ok {
164                 return x.ServedNrCell
165         }
166         return nil
167 }
168
169 type isCell_Cell interface {
170         isCell_Cell()
171 }
172
173 type Cell_ServedCellInfo struct {
174         ServedCellInfo *ServedCellInfo `protobuf:"bytes,2,opt,name=served_cell_info,json=servedCellInfo,proto3,oneof"`
175 }
176
177 type Cell_ServedNrCell struct {
178         ServedNrCell *ServedNRCell `protobuf:"bytes,3,opt,name=served_nr_cell,json=servedNrCell,proto3,oneof"`
179 }
180
181 func (*Cell_ServedCellInfo) isCell_Cell() {}
182
183 func (*Cell_ServedNrCell) isCell_Cell() {}
184
185 var File_cell_proto protoreflect.FileDescriptor
186
187 var file_cell_proto_rawDesc = []byte{
188         0x0a, 0x0a, 0x63, 0x65, 0x6c, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x65, 0x6e,
189         0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x09, 0x67, 0x6e, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74,
190         0x6f, 0x1a, 0x09, 0x65, 0x6e, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xf2, 0x01, 0x0a,
191         0x04, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x27, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20,
192         0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x43,
193         0x65, 0x6c, 0x6c, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x44,
194         0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x5f, 0x69, 0x6e,
195         0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x65, 0x6e, 0x74, 0x69, 0x74,
196         0x69, 0x65, 0x73, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e,
197         0x66, 0x6f, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x43, 0x65, 0x6c, 0x6c,
198         0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3e, 0x0a, 0x0e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e,
199         0x72, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x65,
200         0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x52,
201         0x43, 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x72,
202         0x43, 0x65, 0x6c, 0x6c, 0x22, 0x33, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c,
203         0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x43, 0x45, 0x4c, 0x4c, 0x10, 0x00, 0x12, 0x0c,
204         0x0a, 0x08, 0x4c, 0x54, 0x45, 0x5f, 0x43, 0x45, 0x4c, 0x4c, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07,
205         0x4e, 0x52, 0x5f, 0x43, 0x45, 0x4c, 0x4c, 0x10, 0x02, 0x42, 0x06, 0x0a, 0x04, 0x63, 0x65, 0x6c,
206         0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
207 }
208
209 var (
210         file_cell_proto_rawDescOnce sync.Once
211         file_cell_proto_rawDescData = file_cell_proto_rawDesc
212 )
213
214 func file_cell_proto_rawDescGZIP() []byte {
215         file_cell_proto_rawDescOnce.Do(func() {
216                 file_cell_proto_rawDescData = protoimpl.X.CompressGZIP(file_cell_proto_rawDescData)
217         })
218         return file_cell_proto_rawDescData
219 }
220
221 var file_cell_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
222 var file_cell_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
223 var file_cell_proto_goTypes = []interface{}{
224         (Cell_Type)(0),         // 0: entities.Cell.Type
225         (*Cell)(nil),           // 1: entities.Cell
226         (*ServedCellInfo)(nil), // 2: entities.ServedCellInfo
227         (*ServedNRCell)(nil),   // 3: entities.ServedNRCell
228 }
229 var file_cell_proto_depIdxs = []int32{
230         0, // 0: entities.Cell.type:type_name -> entities.Cell.Type
231         2, // 1: entities.Cell.served_cell_info:type_name -> entities.ServedCellInfo
232         3, // 2: entities.Cell.served_nr_cell:type_name -> entities.ServedNRCell
233         3, // [3:3] is the sub-list for method output_type
234         3, // [3:3] is the sub-list for method input_type
235         3, // [3:3] is the sub-list for extension type_name
236         3, // [3:3] is the sub-list for extension extendee
237         0, // [0:3] is the sub-list for field type_name
238 }
239
240 func init() { file_cell_proto_init() }
241 func file_cell_proto_init() {
242         if File_cell_proto != nil {
243                 return
244         }
245         file_gnb_proto_init()
246         file_enb_proto_init()
247         if !protoimpl.UnsafeEnabled {
248                 file_cell_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
249                         switch v := v.(*Cell); i {
250                         case 0:
251                                 return &v.state
252                         case 1:
253                                 return &v.sizeCache
254                         case 2:
255                                 return &v.unknownFields
256                         default:
257                                 return nil
258                         }
259                 }
260         }
261         file_cell_proto_msgTypes[0].OneofWrappers = []interface{}{
262                 (*Cell_ServedCellInfo)(nil),
263                 (*Cell_ServedNrCell)(nil),
264         }
265         type x struct{}
266         out := protoimpl.TypeBuilder{
267                 File: protoimpl.DescBuilder{
268                         GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
269                         RawDescriptor: file_cell_proto_rawDesc,
270                         NumEnums:      1,
271                         NumMessages:   1,
272                         NumExtensions: 0,
273                         NumServices:   0,
274                 },
275                 GoTypes:           file_cell_proto_goTypes,
276                 DependencyIndexes: file_cell_proto_depIdxs,
277                 EnumInfos:         file_cell_proto_enumTypes,
278                 MessageInfos:      file_cell_proto_msgTypes,
279         }.Build()
280         File_cell_proto = out.File
281         file_cell_proto_rawDesc = nil
282         file_cell_proto_goTypes = nil
283         file_cell_proto_depIdxs = nil
284 }