spinix

type AfterDetectFunc func(device *Device, rule *Rule, match bool, events []Event)

type BaseLit struct {
	Kind Token
	Expr Expr
	Pos  Pos
}

type BeforeDetectFunc func(device *Device, rule *Rule) bool

type BinaryExpr struct {
	LHS Expr  // left operand
	Op  Token // operator
	RHS Expr  // right operand
}

type BooleanLit struct {
	Value bool
	Pos   Pos
}

type Decl struct {
	Keyword Token
	Refs    []xid.ID
}

type Detector interface {
	Detect(ctx context.Context, device *Device) ([]Event, bool, error)
}

type Device struct {
	ID            DeviceID `json:"id"`
	Layer         LayerID  `json:"layerId"`
	IMEI          string   `json:"imei"`
	Owner         string   `json:"owner"`
	Brand         string   `json:"brand"`
	Model         string   `json:"model"`
	Latitude      float64  `json:"lat"`
	Longitude     float64  `json:"lon"`
	Altitude      float64  `json:"alt"`
	Speed         float64  `json:"speed"`
	DateTime      int64    `json:"dateTime"`
	Status        int      `json:"status"`
	BatteryCharge float64  `json:"batteryCharge"`
	Temperature   float64  `json:"temperature"`
	Humidity      float64  `json:"humidity"`
	Luminosity    float64  `json:"luminosity"`
	Pressure      float64  `json:"pressure"`
	FuelLevel     float64  `json:"fuelLevel"`
	// contains filtered or unexported fields
}

type DeviceID = xid.ID

type DeviceIterFunc func(ctx context.Context, d *Device) error

type DeviceLit struct {
	Unit  DistanceUnit
	Kind  Token
	Value float64
	Pos   Pos
}

type Devices interface {
	Lookup(ctx context.Context, id DeviceID) (*Device, error)
	InsertOrReplace(ctx context.Context, device *Device) (bool, error)
	Delete(ctx context.Context, id DeviceID) error
	Each(ctx context.Context, rid RegionID, size RegionSize, fn DeviceIterFunc) error
	Near(ctx context.Context, lat, lon, meters float64, fn DeviceIterFunc) error
}

type DevicesLit struct {
	All   bool
	Unit  DistanceUnit
	Kind  Token
	Value float64
	Pos   Pos
	Ref   []xid.ID
}

type DistanceLit struct {
	Unit  DistanceUnit
	Value float64
	Pos   Pos
}

type DistanceUnit int

type DurationLit struct {
	Kind  Token
	Value time.Duration
	Pos   Pos
}

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

type Event struct {
	ID       string       `json:"ID"`
	Device   Device       `json:"device"`
	DateTime int64        `json:"dateTime"`
	Rule     RuleSnapshot `json:"rule"`
	Match    []Match      `json:"match"`
}

type Expr interface {
	String() string
	// contains filtered or unexported methods
}

type FloatLit struct {
	Value float64
	Pos   Pos
}

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

type IDLit struct {
	Kind  Token
	Value xid.ID
	Pos   Pos
}

type IdentLit struct {
	Name string
	Pos  Pos
	Kind Token
}

type IntLit struct {
	Value int
	Pos   Pos
}

type InvalidExprError struct {
	Left  Expr
	Right Expr
	Op    Token
	Msg   string
	Pos   Pos
}

type LayerID = xid.ID

type ListLit struct {
	Items []Expr
	Pos   Pos
	Kind  Token
	Typ   Token
}

type Match struct {
	Ok       bool  `json:"ok"`
	Left     Decl  `json:"left"`
	Right    Decl  `json:"right"`
	Operator Token `json:"operator"`
	Pos      Pos   `json:"pos"`
}

type Object struct {
	ID   string
	Data geojson.Object
}

type ObjectID = xid.ID

type ObjectIterFunc func(ctx context.Context, o *GeoObject) error

type ObjectLit struct {
	All    bool
	Kind   Token
	Ref    []xid.ID
	DurVal time.Duration
	DurTyp Token
	Pos    Pos
}

type Objects interface {
	Lookup(ctx context.Context, oid ObjectID) (*GeoObject, error)
	Add(ctx context.Context, o *GeoObject) error
	Delete(ctx context.Context, oid ObjectID) error
	Each(ctx context.Context, lid LayerID, rid RegionID, fn ObjectIterFunc) error
	Near(ctx context.Context, lid LayerID, lat, lon, meters float64, fn ObjectIterFunc) error
}

type Option func(*Engine)

type ParenExpr struct {
	Expr Expr // parenthesized expression
}

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

type ParserError struct {
	Tok Token
	Lit string
	Pos Pos
	Msg string
}

type PointLit struct {
	Lat, Lon float64
	Pos      Pos
	Kind     Token
}

type Pos int

type PropExpr struct {
	Expr Expr
	List []Expr
}

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

type RegionID uint64

type RegionSize int

type RepeatMode int

type ResetLit struct {
	Kind  Token
	Pos   Pos
	After time.Duration
}

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

type RuleID = xid.ID

type RuleIterFunc func(ctx context.Context, rule *Rule, err error) error

type RuleSnapshot struct {
	RuleID     string   `json:"ID"`
	Spec       string   `json:"spec"`
	RegionIDs  []string `json:"RegionIDs"`
	RegionSize int      `json:"regionSize"`
}

type Rules interface {
	Walk(ctx context.Context, lat float64, lon float64, fn RuleIterFunc) error
	Insert(ctx context.Context, r *Rule) error
	Delete(ctx context.Context, id RuleID) error
	Lookup(ctx context.Context, id RuleID) (*Rule, error)
}

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

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

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

type StateSnapshot struct {
	ID            StateID          `json:"ID"`
	Now           int64            `json:"now"`
	LastSeenTime  int64            `json:"lastSeenTime"`
	LastResetTime int64            `json:"lastResetTime"`
	Hits          int              `json:"hits"`
	ObjectsVisits map[string]int64 `json:"objectsVisits"`
}

type States interface {
	Lookup(ctx context.Context, id StateID) (*State, error)
	Update(ctx context.Context, s *State) error
	Make(ctx context.Context, id StateID) (*State, error)
	Remove(ctx context.Context, id StateID) error
	RemoveByRule(ctx context.Context, rid RuleID) error
	RemoveByDevice(ctx context.Context, did DeviceID) error
}

type StringLit struct {
	Value string
	Pos   Pos
}

type TimeLit struct {
	Hour   int
	Minute int
	Pos    Pos
}

type Token int

type TriggerLit struct {
	Repeat   RepeatMode
	Interval time.Duration
	Value    time.Duration
	Times    int
	Pos      Pos
}

type VarLit struct {
	Value Token
	Pos   Pos
}

type Visitor interface {
	Visit(Expr) Visitor
}