analysis

type Analyser struct {
	// Source is the path of the origin go source file.
	Source string

	// Tables contains the resolved struct definitions, coming from the
	// go source file [Source] and its dependencies.
	Tables map[*types.Named]Struct

	// StandaloneUnions returns the union with an implicit union tag scheme,
	// for which standalone parsing/writing function should be generated
	StandaloneUnions map[*types.Named]*Union

	// ChildTypes contains types that are used in other types.
	// For instance, top-level tables have a [false] value.
	ChildTypes map[*types.Named]bool
	// contains filtered or unexported fields
}

type Argument struct {
	VariableName string
	TypeName     string
}

type Array struct {

	// Len is the length of elements in the array
	Len int

	// Elem is the type of the element
	Elem Type
	// contains filtered or unexported fields
}

type ArrayCount uint8

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

type BinarySize int

type DerivedFromBasic struct {

	// For aliases, it is the Name of the defined (not the "underlying" type)
	// For named types, the Name of the defined type
	// Otherwise, it is the string representation
	Name string

	// Size is the size as read and written in binary files
	Size BinarySize
	// contains filtered or unexported fields
}

type Field struct {
	Type Type
	Name string

	// name of other fields which will be provided
	// to parsing/writing functions
	ArgumentsProvidedByFields []ProvidedArgument

	// Non empty for fields indicating the kind of union
	// (usually the first field)
	UnionTag constant.Value

	// Non zero if the offset must be resolved into
	// the parent (or grand-parent) slice
	OffsetRelativeTo OffsetRelative
}

type Offset struct {
	// Target if the type the offset is pointing at
	Target Type

	// Size if the size of the offset field
	Size BinarySize

	// IsPointer is true if the target type is actually
	// a pointer. In this case, [Target] is a [Struct].
	IsPointer bool
}

type OffsetRelative uint8

type OffsetSize uint8

type Opaque struct {

	// ParserReturnsLength is true if the custom parsing
	// function returns the length read.
	ParserReturnsLength bool

	// How should the slice be passed
	SubsliceStart SubsliceStart
	// contains filtered or unexported fields
}

type ProvidedArgument struct {
	Value string // a go expression of the value
	For   string // the argument name this value is providing
}

type Scope interface {
	// contains filtered or unexported methods
}

type SingleField Field

type Slice struct {

	// Elem is the type of the element
	Elem Type

	// Count indicates how to read/write the length of the array
	Count ArrayCount
	// CountExpr is used when [Count] is [ComputedField] or [ToComputedField]
	CountExpr string

	// SubsliceStart is only used for raw data ([]byte).
	SubsliceStart SubsliceStart
	// contains filtered or unexported fields
}

type StaticSizedFields []Field

type Struct struct {
	Fields []Field

	// Arguments is not empty if the struct parsing/writting function
	// requires data not provided in the input slice
	Arguments []Argument

	// HasParseEnd is non nil if the table has an
	// additional "parseEnd" method which must be called
	// at the end of parsing
	ParseEnd *types.Func
	// contains filtered or unexported fields
}

type SubsliceStart uint8

type Type interface {
	// Origin returns the Go type yielding the type
	Origin() types.Type

	// IsFixedSize returns the number of byte needed to store an element,
	// or false if it is not known at compile time.
	IsFixedSize() (BinarySize, bool)
}

type Union struct {

	// Members stores the possible members
	Members []Struct

	UnionTag UnionTagScheme

	SelfReferential bool
	// contains filtered or unexported fields
}

type UnionTagExplicit struct {
	// Flags are the possible flag values, in the same order as `Members`
	Flags []*types.Const

	// FlagField is the struct field indicating which
	// member is to be read
	FlagField string
}

type UnionTagImplicit struct {
	Tag   Type
	Flags []constant.Value // in the same order as `Members`
}

type UnionTagScheme interface {
	// TagsCode return the tags go code (like a constant name or a valid constant expression)
	TagsCode() []string
}