feature

type CEnv interface {
	Raw
	Constructors
	Features
	Components
	Entities
	Apply([]string, *data.Vector, ...MapFn) error
}

type Component interface {
	Tagger
	Defines() []string
	Features() []string
}

type Components interface {
	SetRawComponent(...*RawComponent) error
	SetComponent(...Component) error
	GetComponent(float64, string, ...string) []*data.Vector
	MustGetComponent(float64, string, ...string) []*data.Vector
	ListComponents() []Component
}

type Constructor interface {
	Tagger
	Order() int
	Construct(string, *RawFeature, CEnv) Feature
}

type ConstructorFn func(string, *RawFeature, CEnv) (Informer, Emitter, Mapper)

type Constructors interface {
	SetConstructor(...Constructor) error
	GetConstructor(string) (Constructor, bool)
	ListConstructors() []Constructor
}

type Detailer interface {
	Grouper
	Tagger
	Parenter
}

type EmitFn func() data.Item

type Emitter interface {
	Emit() data.Item
	EmitString() (data.StringItem, error)
	EmitStrings() (data.StringsItem, error)
	EmitBool() (data.BoolItem, error)
	EmitInt() (data.IntItem, error)
	EmitFloat() (data.Float64Item, error)
	EmitVector() (data.VectorItem, error)
}

type Entities interface {
	SetRawEntity(...*RawEntity) error
	SetEntity(...Entity) error
	GetEntity(float64, string) []*data.Vector
	MustGetEntity(float64, string) []*data.Vector
	ListEntities() []Entity
}

type Entity interface {
	Tagger
	Defines() []string
	Components() []string
}

type Feature interface {
	Informer
	Emitter
	Mapper
}

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

type Features interface {
	AddFeature(...Feature)
	SetFeature(*RawFeature) error
	GetFeature(string) Feature
	MustGetFeature(string) Feature
	GetGroup(string) *FeatureGroup
	List(string) []RawFeature
	Remove(...string) error
}

type Grouper interface {
	Group() []string
	IsGroup(string) bool
}

type Informer interface {
	Detailer
	Valuer
	Transmitter
}

type MapFn func(*data.Vector)

type Mapper interface {
	Map(*data.Vector)
}

type Parenter interface {
	From() string
}

type Raw interface {
	Queue([]byte) error
	Dequeue(...string)
	//DeqComponent([]*RawComponent) error
	//DeqEntity([]*RawEntity) error
	AddRaw(...*RawFeature) error
}

type RawComponent struct {
	Tag      string
	Defines  []*RawFeature
	Features []*RawFeature
}

type RawEntity struct {
	Tag        string
	Defines    []*RawFeature
	Components []*RawComponent
}

type RawFeature struct {
	Group       []string
	Tag         string
	Apply       string
	Values      []string
	Constructor Constructor
}

type Tagger interface {
	Tag() string
}

type Transmitter interface {
	RawFeature() RawFeature
}

type Valuer interface {
	Raw() string
	Values() []string
	Length() int
}