ranger

type ConfigFormat struct {
	// Package is the name of the package we're generating into.
	Package string `yaml:"package"`
	// Types is the listing of types. Each definition consists of a Type name as
	// map key and properties as values.
	Types map[string]*ConfigType `yaml:"types"`

	// Comment adds a comment to the package declaration.
	Comment string `yaml:"comment"`
	// contains filtered or unexported fields
}

type ConfigInterface struct {
	// Output method. This is a method which is called on the member to determine
	// the type information for embedding into the marshal.
	Output string `yaml:"output"`
	// Input type. This is a type we can unmarshal out of a byte stream to
	// determine what type in cases to use.
	Input string `yaml:"input"`
	// Cases is a list of cases; this is a list of one-key maps that correspond
	// comparisons in case statement, and result in a type marshal of the value.
	// Types specified in this manner must still conform to ranger.Marshaler.
	Cases []map[string]string `yaml:"cases"`
}

type ConfigMatch struct {
	// LengthOfField indicates the field must match the Member field specified in the value.
	LengthOfField string `yaml:"length_of_field"`
}

type ConfigRequire struct {
	// MaxLength means the field must have a length no longer than this.
	MaxLength uint64 `yaml:"max_length"`
	// Length means the field must be exactly this length.
	Length uint64 `yaml:"length"`
}

type ConfigType struct {
	// Fields is a list of fields in serialisation order. This is ordered because byte stability in the
	// serialisation format is a requirement.
	Fields []*ConfigTypeDefinition `yaml:"fields"`
	// Interface is a polymorphic type definition; see ConfigInterface for more. A type defined with an interface
	// configuration must have no fields defined.
	Interface *ConfigInterface `yaml:"interface,omitempty"`

	// Comment is a field to add a comment to the type's declaration.
	Comment string `yaml:"comment"`

	TypeName string `yaml:"-"` // populated by parse
	// contains filtered or unexported fields
}

type ConfigTypeDefinition struct {
	// FieldName is the name of the field in the containing type. While the yaml file can represent multiple fields with
	// the same name this is a semantic error and will produce bad code that won't compile.
	FieldName string `yaml:"name"`
	// StructureType is the type of data structure; this may be "struct" or
	// "array". This determines how the field is marshaled by wrapping length
	// headers over array sections for ease of reading.
	StructureType string `yaml:"structure_type"`
	// ValueType is the type that we'll use for the actual marshaling. The
	// ValueType must conform to ranger.Marshaler or be a built in type (uint,
	// string, etc) that we support marshaling to/from natively.
	ValueType string `yaml:"value_type"`
	// Static ensures that the value is of a fixed size for integer types.
	Static bool `yaml:"static"`
	// Match is a list of matching rules for validations.
	Match ConfigMatch `yaml:"match,omitempty"`
	// Require is a list of requirements for validations.
	Require ConfigRequire `yaml:"require,omitempty"`
	// ItemRequire defines length/maxlength etc for the elements of an array.
	// This is a compromise vs a full type system overhaul that will probably be
	// Ranger v2.
	ItemRequire *ConfigRequire `yaml:"item_require,omitempty"`
	// Marshal if false, will not marshal in or out.
	Marshal *bool `yaml:"marshal,omitempty"`
	// Embedded defines this field as embedded in the struct.
	Embedded bool `yaml:"embedded"`

	// Comment is a field to add a comment to the field's declaration.
	Comment string `yaml:"comment"`

	TypeName string `yaml:"-"` // populated by parse
	// contains filtered or unexported fields
}

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

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

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

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

type Marshaler interface {
	// Allocate storage
	Marshal() ([]byte, error)
	// Marshal into preallocated storage and returned consumed bytes.
	MarshalTo(data []byte) (int, error)
	// Unmarshal the first document in data
	Unmarshal(data []byte) error
	// Unmarshal the first document in data returning consumed bytes
	UnmarshalFrom(data []byte) (int, error)
	// Return the size that the struct will need to Marshal successfully. If the
	// struct cannot be marshalled successfully for some reason, will return a
	// sufficient number of bytes (perhaps even 0) to allow marshalTo to reason
	// the point where that marshalling error will occur, and will itself not
	// panic. MarshalTo will then proceed to attempt to marshal into this space
	// and the marshaling will fail. The failure should still be due to the
	// underlying reason, not due to a shortness of space returned from Size.
	Size() int
}

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

type Type interface {
	// ConstantSize returns true if the type is always the same size
	ConstantSize(TypeInstance) (bool, error)
	// Does the type support len()
	HasLen(TypeInstance) (bool, error)
	// MinimumSize returns the minimum serialized size of the type.
	MinimumSize(TypeInstance) (uint64, error)
	// The name of the type
	Name() string
	// PointerType returns whether the type instance is a value or a pointer to
	// value
	PointerType(TypeInstance) bool
	// Read returns code to deserialise an instance of the type
	Read(TypeInstance) (string, error)
	// Type returns the go code to describe the type - e.g. [32]byte.
	Type(TypeInstance) (string, error)
	// WriteSize returns code to caculate the size of an instance of the type when serialized
	WriteSize(TypeInstance) (string, error)
	// Write returns code to serialise an instance of the
	Write(TypeInstance) (string, error)
}

type TypeInstance interface {
	// Get at the ConfigFormat for e.g. running templates
	ConfigFormat() *ConfigFormat
	// What if any Length is configured for 'instance'.
	// NB: this should move to being part of the type.
	GetLength() (uint64, error)
	// What max length is configured for 'instance'.
	GetMaxLength() (uint64, error)
	// Does the type support len()
	HasLen() (bool, error)
	// Is this a Reference
	IsPointer() bool
	// Whats the fully qualified name (for human errors)
	QualName() string
	// How is this instance address in code when reading in
	ReadSymbolName() string
	// How is this instance addressed in code when writing out
	WriteSymbolName() string
	// Is this instance statically sized? (Separate to static array lengths at
	// least for now)
	Static() bool
}

type UInt8 struct{}