codec

package
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 18, 2024 License: BSD-3-Clause Imports: 10 Imported by: 0

Documentation

Overview

Package codec is a generated GoMock package.

Index

Constants

View Source 
const UpgradePrefix = uint64(0xFFFFFFFFFFFF0000)

Variables

View Source 
var MultipleTagsTests = []func(c GeneralCodec, t testing.TB){
	TestMultipleTags,
}
View Source 
var Tests = []func(c GeneralCodec, t testing.TB){
	TestStruct,
	TestRegisterStructTwice,
	TestUInt32,
	TestUIntPtr,
	TestSlice,
	TestMaxSizeSlice,
	TestBool,
	TestArray,
	TestBigArray,
	TestPointerToStruct,
	TestSliceOfStruct,
	TestInterface,
	TestSliceOfInterface,
	TestArrayOfInterface,
	TestPointerToInterface,
	TestString,
	TestNilSlice,
	TestSerializeUnexportedField,
	TestSerializeOfNoSerializeField,
	TestNilSliceSerialization,
	TestEmptySliceSerialization,
	TestSliceWithEmptySerialization,
	TestSliceWithEmptySerializationOutOfMemory,
	TestSliceTooLarge,
	TestNegativeNumbers,
	TestTooLargeUnmarshal,
	TestUnmarshalInvalidInterface,
	TestRestrictedSlice,
	TestExtraSpace,
	TestSliceLengthOverflow,
}
View Source 
var VersionTests = []func(c GeneralCodec, t testing.TB){
	TestUpgrade,
}

Functions

func TestArray 

func TestArray(codec GeneralCodec, t testing.TB)

Test marshalling an array

func TestArrayOfInterface 

func TestArrayOfInterface(codec GeneralCodec, t testing.TB)

Test marshalling an array of interfaces

func TestBigArray 

func TestBigArray(codec GeneralCodec, t testing.TB)

Test marshalling a really big array

func TestBool 

func TestBool(codec GeneralCodec, t testing.TB)

Test marshalling a bool

func TestEmptySliceSerialization 

func TestEmptySliceSerialization(codec GeneralCodec, t testing.TB)

Test marshaling a slice that has 0 elements (but isn't nil)

func TestExtraSpace 

func TestExtraSpace(codec GeneralCodec, t testing.TB)

Test unmarshaling something with extra data

func TestInterface 

func TestInterface(codec GeneralCodec, t testing.TB)

Test marshalling an interface

func TestMaxSizeSlice 

func TestMaxSizeSlice(codec GeneralCodec, t testing.TB)

Test marshalling/unmarshalling largest possible slice

func TestMultipleTags 

func TestMultipleTags(codec GeneralCodec, t testing.TB)

func TestNegativeNumbers 

func TestNegativeNumbers(codec GeneralCodec, t testing.TB)

Ensure serializing structs with negative number members works

func TestNilSlice 

func TestNilSlice(codec GeneralCodec, t testing.TB)

Ensure a nil slice is unmarshaled to slice with length 0

func TestNilSliceSerialization 

func TestNilSliceSerialization(codec GeneralCodec, t testing.TB)

Test marshalling of nil slice

func TestPointerToInterface 

func TestPointerToInterface(codec GeneralCodec, t testing.TB)

Test marshalling a pointer to an interface

func TestPointerToStruct 

func TestPointerToStruct(codec GeneralCodec, t testing.TB)

Test marshalling a pointer to a struct

func TestRegisterStructTwice 

func TestRegisterStructTwice(codec GeneralCodec, t testing.TB)

func TestRestrictedSlice 

func TestRestrictedSlice(codec GeneralCodec, t testing.TB)

Ensure deserializing slices that have been length restricted errors correctly

func TestSerializeOfNoSerializeField 

func TestSerializeOfNoSerializeField(codec GeneralCodec, t testing.TB)

func TestSerializeUnexportedField 

func TestSerializeUnexportedField(codec GeneralCodec, t testing.TB)

Ensure that trying to serialize a struct with an unexported member that has `serialize:"true"` returns error

func TestSlice 

func TestSlice(codec GeneralCodec, t testing.TB)

func TestSliceLengthOverflow 

func TestSliceLengthOverflow(codec GeneralCodec, t testing.TB)

Ensure deserializing slices that have been length restricted errors correctly

func TestSliceOfInterface 

func TestSliceOfInterface(codec GeneralCodec, t testing.TB)

Test marshalling a slice of interfaces

func TestSliceOfStruct 

func TestSliceOfStruct(codec GeneralCodec, t testing.TB)

Test marshalling a slice of structs

func TestSliceTooLarge 

func TestSliceTooLarge(codec GeneralCodec, t testing.TB)

func TestSliceWithEmptySerialization 

func TestSliceWithEmptySerialization(codec GeneralCodec, t testing.TB)

Test marshaling slice that is not nil and not empty

func TestSliceWithEmptySerializationOutOfMemory 

func TestSliceWithEmptySerializationOutOfMemory(codec GeneralCodec, t testing.TB)

func TestString 

func TestString(codec GeneralCodec, t testing.TB)

Test marshalling a string

func TestStruct 

func TestStruct(codec GeneralCodec, t testing.TB)

Test marshaling/unmarshaling a complicated struct

func TestTooLargeUnmarshal 

func TestTooLargeUnmarshal(codec GeneralCodec, t testing.TB)

Ensure deserializing structs with too many bytes errors correctly

func TestUInt32 

func TestUInt32(codec GeneralCodec, t testing.TB)

func TestUIntPtr 

func TestUIntPtr(codec GeneralCodec, t testing.TB)

func TestUnmarshalInvalidInterface 

func TestUnmarshalInvalidInterface(codec GeneralCodec, t testing.TB)

Ensure deserializing structs into the wrong interface errors gracefully

func TestUpgrade 

func TestUpgrade(codec GeneralCodec, t testing.TB)

Test version upgrade. Optional UpgradeVersionID field is only marshalled if it matches the UpgradePrefix pattern defined in codec. If the struct bytes start with 48 set bits, and if the struct has the first member called UpgradeVersionID, it is treated as 48 bit magic and 16 bit version (low 16 bits). Refer to codec.BuildUpgradeVersionID()

Types

type CaminoRegistry 

type CaminoRegistry interface {
	RegisterType(interface{}) error
	RegisterCustomType(interface{}) error
}

Registry registers new types that can be marshaled into

type Codec 

type Codec interface {
	MarshalInto(interface{}, *wrappers.Packer) error
	Unmarshal([]byte, interface{}) error

	// Returns the size, in bytes, of [value] when it's marshaled
	Size(value interface{}) (int, error)
}

Codec marshals and unmarshals

type Foo 

type Foo interface {
	Foo() int
}

type GeneralCodec 

type GeneralCodec interface {
	Codec
	Registry
}

GeneralCodec marshals and unmarshals structs including interfaces

type Manager 

type Manager interface {
	// Associate the given codec with the given version ID
	RegisterCodec(version uint16, codec Codec) error

	// Define the maximum size, in bytes, of something serialized/deserialized
	// by this codec manager
	SetMaxSize(int)

	// Size returns the size, in bytes, of [value] when it's marshaled
	// using the codec with the given version.
	// RegisterCodec must have been called with that version.
	// If [value] is nil, returns [errMarshalNil]
	Size(version uint16, value interface{}) (int, error)

	// Marshal the given value using the codec with the given version.
	// RegisterCodec must have been called with that version.
	Marshal(version uint16, source interface{}) (destination []byte, err error)

	// Unmarshal the given bytes into the given destination. [destination] must
	// be a pointer or an interface. Returns the version of the codec that
	// produces the given bytes.
	Unmarshal(source []byte, destination interface{}) (version uint16, err error)
}

Manager describes the functionality for managing codec versions.

func NewDefaultManager 

func NewDefaultManager() Manager

NewDefaultManager returns a new codec manager.

func NewManager 

func NewManager(maxSize int) Manager

NewManager returns a new codec manager.

type MockManager 

type MockManager struct {
	// contains filtered or unexported fields
}

MockManager is a mock of Manager interface.

func NewMockManager 

func NewMockManager(ctrl *gomock.Controller) *MockManager

NewMockManager creates a new mock instance.

func (*MockManager) EXPECT 

func (m *MockManager) EXPECT() *MockManagerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockManager) Marshal 

func (m *MockManager) Marshal(arg0 uint16, arg1 interface{}) ([]byte, error)

Marshal mocks base method.

func (*MockManager) RegisterCodec 

func (m *MockManager) RegisterCodec(arg0 uint16, arg1 Codec) error

RegisterCodec mocks base method.

func (*MockManager) SetMaxSize 

func (m *MockManager) SetMaxSize(arg0 int)

SetMaxSize mocks base method.

func (*MockManager) Size 

func (m *MockManager) Size(arg0 uint16, arg1 interface{}) (int, error)

Size mocks base method.

func (*MockManager) Unmarshal 

func (m *MockManager) Unmarshal(arg0 []byte, arg1 interface{}) (uint16, error)

Unmarshal mocks base method.

type MockManagerMockRecorder 

type MockManagerMockRecorder struct {
	// contains filtered or unexported fields
}

MockManagerMockRecorder is the mock recorder for MockManager.

func (*MockManagerMockRecorder) Marshal 

func (mr *MockManagerMockRecorder) Marshal(arg0, arg1 interface{}) *gomock.Call

Marshal indicates an expected call of Marshal.

func (*MockManagerMockRecorder) RegisterCodec 

func (mr *MockManagerMockRecorder) RegisterCodec(arg0, arg1 interface{}) *gomock.Call

RegisterCodec indicates an expected call of RegisterCodec.

func (*MockManagerMockRecorder) SetMaxSize 

func (mr *MockManagerMockRecorder) SetMaxSize(arg0 interface{}) *gomock.Call

SetMaxSize indicates an expected call of SetMaxSize.

func (*MockManagerMockRecorder) Size 

func (mr *MockManagerMockRecorder) Size(arg0, arg1 interface{}) *gomock.Call

Size indicates an expected call of Size.

func (*MockManagerMockRecorder) Unmarshal 

func (mr *MockManagerMockRecorder) Unmarshal(arg0, arg1 interface{}) *gomock.Call

Unmarshal indicates an expected call of Unmarshal.

type MultipleVersionsStruct 

type MultipleVersionsStruct struct {
	BothTags    string `tag1:"true" tag2:"true"`
	SingleTag1  string `tag1:"true"`
	SingleTag2  string `tag2:"true"`
	EitherTags1 string `tag1:"false" tag2:"true"`
	EitherTags2 string `tag1:"true" tag2:"false"`
	NoTags      string `tag1:"false" tag2:"false"`
}

type MyInnerStruct 

type MyInnerStruct struct {
	Str string `serialize:"true"`
}

func (*MyInnerStruct) Foo 

func (*MyInnerStruct) Foo() int

type MyInnerStruct2 

type MyInnerStruct2 struct {
	Bool bool `serialize:"true"`
}

func (*MyInnerStruct2) Foo 

func (*MyInnerStruct2) Foo() int

type MyInnerStruct3 

type MyInnerStruct3 struct {
	Str string        `serialize:"true"`
	M1  MyInnerStruct `serialize:"true"`
	F   Foo           `serialize:"true"`
}

MyInnerStruct3 embeds Foo, an interface, so it has to implement TypeID and ConcreteInstance

type Registry 

type Registry interface {
	RegisterType(interface{}) error
}

Registry registers new types that can be marshaled into

type UpgradeStruct 

type UpgradeStruct struct {
	UpgradeVersionID UpgradeVersionID
	Field1           uint32 `serialize:"true"`
	Field2           uint32 `serialize:"true"`
	Version1         uint32 `serialize:"true" upgradeVersion:"1"`
	Version2         uint32 `serialize:"true" upgradeVersion:"2"`
}

type UpgradeStructOld 

type UpgradeStructOld struct {
	UpgradeVersionID UpgradeVersionID
	Field1           uint32 `serialize:"true"`
	Field2           uint32 `serialize:"true"`
	Version1         uint32 `serialize:"true" upgradeVersion:"1"`
}

type UpgradeVersionID 

type UpgradeVersionID uint64
const (
	UpgradeVersion0 UpgradeVersionID = UpgradeVersionID(UpgradePrefix)
	UpgradeVersion1 UpgradeVersionID = UpgradeVersionID(UpgradePrefix | uint64(1))
)

func BuildUpgradeVersionID 

func BuildUpgradeVersionID(version uint16) UpgradeVersionID

func (UpgradeVersionID) Version 

func (id UpgradeVersionID) Version() uint16

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.