sample_message.go

// Copyright 2021 The gVisor 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.

package lisafs

import (
"fmt"
"math/rand"

"gvisor.dev/gvisor/pkg/marshal/primitive"
)

// MsgSimple is a sample packed struct which can be used to test message passing.
//
// +marshal slice:Msg1Slice
typeMsgSimplestruct {
Auint16
Buint16
Cuint32
Duint64
}

// Randomize randomizes the contents of m.
func (m*MsgSimple) Randomize() {
m.A=uint16(rand.Uint32())
m.B=uint16(rand.Uint32())
m.C=rand.Uint32()
m.D=rand.Uint64()
}

// MsgDynamic is a sample dynamic struct which can be used to test message passing.
//
// +marshal dynamic
typeMsgDynamicstruct {
N primitive.Uint32
Arr []MsgSimple
}

// String implements fmt.Stringer.String.
func (m*MsgDynamic) String() string {
returnfmt.Sprintf("MsgDynamic{N: %d, Arr: %v}", m.N, m.Arr)
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (m*MsgDynamic) SizeBytes() int {
returnm.N.SizeBytes() +
 (int(m.N) * (*MsgSimple)(nil).SizeBytes())
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (m*MsgDynamic) MarshalBytes(dst []byte) []byte {
dst=m.N.MarshalUnsafe(dst)
returnMarshalUnsafeMsg1Slice(m.Arr, dst)
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (m*MsgDynamic) UnmarshalBytes(src []byte) []byte {
src=m.N.UnmarshalUnsafe(src)
m.Arr=make([]MsgSimple, m.N)
returnUnmarshalUnsafeMsg1Slice(m.Arr, src)
}

// CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.
func (m*MsgDynamic) CheckedUnmarshal(src []byte) ([]byte, bool) {
m.Arr=m.Arr[:0]
ifm.SizeBytes() >len(src) {
returnnil, false
 }
src=m.N.UnmarshalUnsafe(src)
ifint(m.N) >cap(m.Arr) {
m.Arr=make([]MsgSimple, m.N)
 } else {
m.Arr=m.Arr[:m.N]
 }
ifint(m.N)*(*MsgSimple)(nil).SizeBytes() >len(src) {
returnnil, false
 }
returnUnmarshalUnsafeMsg1Slice(m.Arr, src), true
}

// Randomize randomizes the contents of m.
func (m*MsgDynamic) Randomize(arrLenint) {
m.N=primitive.Uint32(arrLen)
m.Arr=make([]MsgSimple, arrLen)
fori:=0; i<arrLen; i++ {
m.Arr[i].Randomize()
 }
}

// P9Version mimics p9.TVersion and p9.Rversion.
typeP9Versionstruct {
MSize primitive.Uint32
Versionstring
}

// String implements fmt.Stringer.String.
func (v*P9Version) String() string {
returnfmt.Sprintf("P9Version{MSize: %d, Version: %s}", v.MSize, v.Version)
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (v*P9Version) SizeBytes() int {
return (*primitive.Uint32)(nil).SizeBytes() + (*primitive.Uint16)(nil).SizeBytes() +len(v.Version)
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (v*P9Version) MarshalBytes(dst []byte) []byte {
dst=v.MSize.MarshalUnsafe(dst)
versionLen:=primitive.Uint16(len(v.Version))
dst=versionLen.MarshalUnsafe(dst)
returndst[copy(dst, v.Version):]
}

// CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.
func (v*P9Version) CheckedUnmarshal(src []byte) ([]byte, bool) {
v.Version=""
ifv.SizeBytes() >len(src) {
returnnil, false
 }
src=v.MSize.UnmarshalUnsafe(src)
varversionLen primitive.Uint16
src=versionLen.UnmarshalUnsafe(src)
ifint(versionLen) >len(src) {
returnnil, false
 }
v.Version=string(src[:versionLen])
returnsrc[versionLen:], true
}