mirror of
https://github.com/rocky-linux/peridot.git
synced 2024-10-19 07:55:07 +00:00
301 lines
7.2 KiB
Go
301 lines
7.2 KiB
Go
|
// Protocol Buffers for Go with Gadgets
|
||
|
//
|
||
|
// Copyright (c) 2018, The GoGo Authors. All rights reserved.
|
||
|
// http://github.com/gogo/protobuf
|
||
|
//
|
||
|
// Redistribution and use in source and binary forms, with or without
|
||
|
// modification, are permitted provided that the following conditions are
|
||
|
// met:
|
||
|
//
|
||
|
// * Redistributions of source code must retain the above copyright
|
||
|
// notice, this list of conditions and the following disclaimer.
|
||
|
// * Redistributions in binary form must reproduce the above
|
||
|
// copyright notice, this list of conditions and the following disclaimer
|
||
|
// in the documentation and/or other materials provided with the
|
||
|
// distribution.
|
||
|
//
|
||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
||
|
package types
|
||
|
|
||
|
func NewPopulatedStdDouble(r randyWrappers, easy bool) *float64 {
|
||
|
v := NewPopulatedDoubleValue(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdDouble(v float64) int {
|
||
|
pv := &DoubleValue{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdDoubleMarshal(v float64) ([]byte, error) {
|
||
|
size := SizeOfStdDouble(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdDoubleMarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdDoubleMarshalTo(v float64, data []byte) (int, error) {
|
||
|
pv := &DoubleValue{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdDoubleUnmarshal(v *float64, data []byte) error {
|
||
|
pv := &DoubleValue{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdFloat(r randyWrappers, easy bool) *float32 {
|
||
|
v := NewPopulatedFloatValue(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdFloat(v float32) int {
|
||
|
pv := &FloatValue{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdFloatMarshal(v float32) ([]byte, error) {
|
||
|
size := SizeOfStdFloat(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdFloatMarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdFloatMarshalTo(v float32, data []byte) (int, error) {
|
||
|
pv := &FloatValue{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdFloatUnmarshal(v *float32, data []byte) error {
|
||
|
pv := &FloatValue{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdInt64(r randyWrappers, easy bool) *int64 {
|
||
|
v := NewPopulatedInt64Value(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdInt64(v int64) int {
|
||
|
pv := &Int64Value{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdInt64Marshal(v int64) ([]byte, error) {
|
||
|
size := SizeOfStdInt64(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdInt64MarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdInt64MarshalTo(v int64, data []byte) (int, error) {
|
||
|
pv := &Int64Value{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdInt64Unmarshal(v *int64, data []byte) error {
|
||
|
pv := &Int64Value{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdUInt64(r randyWrappers, easy bool) *uint64 {
|
||
|
v := NewPopulatedUInt64Value(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdUInt64(v uint64) int {
|
||
|
pv := &UInt64Value{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdUInt64Marshal(v uint64) ([]byte, error) {
|
||
|
size := SizeOfStdUInt64(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdUInt64MarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdUInt64MarshalTo(v uint64, data []byte) (int, error) {
|
||
|
pv := &UInt64Value{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdUInt64Unmarshal(v *uint64, data []byte) error {
|
||
|
pv := &UInt64Value{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdInt32(r randyWrappers, easy bool) *int32 {
|
||
|
v := NewPopulatedInt32Value(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdInt32(v int32) int {
|
||
|
pv := &Int32Value{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdInt32Marshal(v int32) ([]byte, error) {
|
||
|
size := SizeOfStdInt32(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdInt32MarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdInt32MarshalTo(v int32, data []byte) (int, error) {
|
||
|
pv := &Int32Value{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdInt32Unmarshal(v *int32, data []byte) error {
|
||
|
pv := &Int32Value{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdUInt32(r randyWrappers, easy bool) *uint32 {
|
||
|
v := NewPopulatedUInt32Value(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdUInt32(v uint32) int {
|
||
|
pv := &UInt32Value{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdUInt32Marshal(v uint32) ([]byte, error) {
|
||
|
size := SizeOfStdUInt32(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdUInt32MarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdUInt32MarshalTo(v uint32, data []byte) (int, error) {
|
||
|
pv := &UInt32Value{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdUInt32Unmarshal(v *uint32, data []byte) error {
|
||
|
pv := &UInt32Value{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdBool(r randyWrappers, easy bool) *bool {
|
||
|
v := NewPopulatedBoolValue(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdBool(v bool) int {
|
||
|
pv := &BoolValue{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdBoolMarshal(v bool) ([]byte, error) {
|
||
|
size := SizeOfStdBool(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdBoolMarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdBoolMarshalTo(v bool, data []byte) (int, error) {
|
||
|
pv := &BoolValue{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdBoolUnmarshal(v *bool, data []byte) error {
|
||
|
pv := &BoolValue{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdString(r randyWrappers, easy bool) *string {
|
||
|
v := NewPopulatedStringValue(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdString(v string) int {
|
||
|
pv := &StringValue{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdStringMarshal(v string) ([]byte, error) {
|
||
|
size := SizeOfStdString(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdStringMarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdStringMarshalTo(v string, data []byte) (int, error) {
|
||
|
pv := &StringValue{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdStringUnmarshal(v *string, data []byte) error {
|
||
|
pv := &StringValue{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|
||
|
func NewPopulatedStdBytes(r randyWrappers, easy bool) *[]byte {
|
||
|
v := NewPopulatedBytesValue(r, easy)
|
||
|
return &v.Value
|
||
|
}
|
||
|
|
||
|
func SizeOfStdBytes(v []byte) int {
|
||
|
pv := &BytesValue{Value: v}
|
||
|
return pv.Size()
|
||
|
}
|
||
|
|
||
|
func StdBytesMarshal(v []byte) ([]byte, error) {
|
||
|
size := SizeOfStdBytes(v)
|
||
|
buf := make([]byte, size)
|
||
|
_, err := StdBytesMarshalTo(v, buf)
|
||
|
return buf, err
|
||
|
}
|
||
|
|
||
|
func StdBytesMarshalTo(v []byte, data []byte) (int, error) {
|
||
|
pv := &BytesValue{Value: v}
|
||
|
return pv.MarshalTo(data)
|
||
|
}
|
||
|
|
||
|
func StdBytesUnmarshal(v *[]byte, data []byte) error {
|
||
|
pv := &BytesValue{}
|
||
|
if err := pv.Unmarshal(data); err != nil {
|
||
|
return err
|
||
|
}
|
||
|
*v = pv.Value
|
||
|
return nil
|
||
|
}
|