/
generated_common.go
187 lines (164 loc) · 6.01 KB
/
generated_common.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
// Copyright The OpenTelemetry Authors
//
// 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.
// Code generated by "cmd/pdatagen/main.go". DO NOT EDIT.
// To regenerate this file run "go run cmd/pdatagen/main.go".
package pdata
import (
otlpcommon "go.opentelemetry.io/collector/internal/data/protogen/common/v1"
)
// InstrumentationLibrary is a message representing the instrumentation library information.
//
// This is a reference type, if passed by value and callee modifies it the
// caller will see the modification.
//
// Must use NewInstrumentationLibrary function to create new instances.
// Important: zero-initialized instance is not valid for use.
type InstrumentationLibrary struct {
orig *otlpcommon.InstrumentationLibrary
}
func newInstrumentationLibrary(orig *otlpcommon.InstrumentationLibrary) InstrumentationLibrary {
return InstrumentationLibrary{orig: orig}
}
// NewInstrumentationLibrary creates a new empty InstrumentationLibrary.
//
// This must be used only in testing code since no "Set" method available.
func NewInstrumentationLibrary() InstrumentationLibrary {
return newInstrumentationLibrary(&otlpcommon.InstrumentationLibrary{})
}
// Name returns the name associated with this InstrumentationLibrary.
//
// Important: This causes a runtime error if IsNil() returns "true".
func (ms InstrumentationLibrary) Name() string {
return (*ms.orig).Name
}
// SetName replaces the name associated with this InstrumentationLibrary.
//
// Important: This causes a runtime error if IsNil() returns "true".
func (ms InstrumentationLibrary) SetName(v string) {
(*ms.orig).Name = v
}
// Version returns the version associated with this InstrumentationLibrary.
//
// Important: This causes a runtime error if IsNil() returns "true".
func (ms InstrumentationLibrary) Version() string {
return (*ms.orig).Version
}
// SetVersion replaces the version associated with this InstrumentationLibrary.
//
// Important: This causes a runtime error if IsNil() returns "true".
func (ms InstrumentationLibrary) SetVersion(v string) {
(*ms.orig).Version = v
}
// CopyTo copies all properties from the current struct to the dest.
func (ms InstrumentationLibrary) CopyTo(dest InstrumentationLibrary) {
dest.SetName(ms.Name())
dest.SetVersion(ms.Version())
}
// AnyValueArray logically represents a slice of AttributeValue.
//
// This is a reference type, if passed by value and callee modifies it the
// caller will see the modification.
//
// Must use NewAnyValueArray function to create new instances.
// Important: zero-initialized instance is not valid for use.
type AnyValueArray struct {
// orig points to the slice otlpcommon.AnyValue field contained somewhere else.
// We use pointer-to-slice to be able to modify it in functions like Resize.
orig *[]otlpcommon.AnyValue
}
func newAnyValueArray(orig *[]otlpcommon.AnyValue) AnyValueArray {
return AnyValueArray{orig}
}
// NewAnyValueArray creates a AnyValueArray with 0 elements.
// Can use "Resize" to initialize with a given length.
func NewAnyValueArray() AnyValueArray {
orig := []otlpcommon.AnyValue(nil)
return AnyValueArray{&orig}
}
// Len returns the number of elements in the slice.
//
// Returns "0" for a newly instance created with "NewAnyValueArray()".
func (es AnyValueArray) Len() int {
return len(*es.orig)
}
// At returns the element at the given index.
//
// This function is used mostly for iterating over all the values in the slice:
// for i := 0; i < es.Len(); i++ {
// e := es.At(i)
// ... // Do something with the element
// }
func (es AnyValueArray) At(ix int) AttributeValue {
return newAttributeValue(&(*es.orig)[ix])
}
// MoveAndAppendTo moves all elements from the current slice and appends them to the dest.
// The current slice will be cleared.
func (es AnyValueArray) MoveAndAppendTo(dest AnyValueArray) {
if *dest.orig == nil {
// We can simply move the entire vector and avoid any allocations.
*dest.orig = *es.orig
} else {
*dest.orig = append(*dest.orig, *es.orig...)
}
*es.orig = nil
}
// CopyTo copies all elements from the current slice to the dest.
func (es AnyValueArray) CopyTo(dest AnyValueArray) {
srcLen := es.Len()
destCap := cap(*dest.orig)
if srcLen <= destCap {
(*dest.orig) = (*dest.orig)[:srcLen:destCap]
} else {
(*dest.orig) = make([]otlpcommon.AnyValue, srcLen)
}
for i := range *es.orig {
newAttributeValue(&(*es.orig)[i]).CopyTo(newAttributeValue(&(*dest.orig)[i]))
}
}
// Resize is an operation that resizes the slice:
// 1. If the newLen <= len then equivalent with slice[0:newLen:cap].
// 2. If the newLen > len then (newLen - cap) empty elements will be appended to the slice.
//
// Here is how a new AnyValueArray can be initialized:
// es := NewAnyValueArray()
// es.Resize(4)
// for i := 0; i < es.Len(); i++ {
// e := es.At(i)
// // Here should set all the values for e.
// }
func (es AnyValueArray) Resize(newLen int) {
oldLen := len(*es.orig)
oldCap := cap(*es.orig)
if newLen <= oldLen {
*es.orig = (*es.orig)[:newLen:oldCap]
return
}
if newLen > oldCap {
newOrig := make([]otlpcommon.AnyValue, oldLen, newLen)
copy(newOrig, *es.orig)
*es.orig = newOrig
}
// Add extra empty elements to the array.
empty := otlpcommon.AnyValue{}
for i := oldLen; i < newLen; i++ {
*es.orig = append(*es.orig, empty)
}
}
// Append will increase the length of the AnyValueArray by one and set the
// given AttributeValue at that new position. The original AttributeValue
// could still be referenced so do not reuse it after passing it to this
// method.
func (es AnyValueArray) Append(e AttributeValue) {
*es.orig = append(*es.orig, *e.orig)
}