graphvent

type BaseSignal struct {
	FDirection SignalDirection `json:"direction"`
	FSource    NodeID          `json:"source"`
	FType      string          `json:"type"`
}

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

type Context struct {
	// DB is the database connection used to load and write nodes
	DB *badger.DB
	// Log is an interface used to record events happening
	Log Logger
	// A mapping between type hashes and their corresponding node definitions
	Types map[uint64]NodeDef
	// GQL substructure
	GQL GQLContext
}

type DBHeader struct {
	Magic    uint32
	TypeHash uint64
}

type GQLContext struct {
	// Generated GQL schema
	Schema graphql.Schema

	// Interface types to compare against
	NodeType     reflect.Type
	LockableType reflect.Type
	ThreadType   reflect.Type

	// List of GQL types
	TypeList []graphql.Type

	// Interface type maps to map go types of specific interfaces to gql types
	ValidNodes     ObjTypeMap
	ValidLockables ObjTypeMap
	ValidThreads   ObjTypeMap

	Query        *graphql.Object
	Mutation     *graphql.Object
	Subscription *graphql.Object
}

type GQLThread struct {
	SimpleThread

	Listen string
	// contains filtered or unexported fields
}

type GQLThreadInfo struct {
	Start         bool   `json:"start"`
	StartAction   string `json:"start_action"`
	RestoreAction string `json:"restore_action"`
}

type GQLThreadJSON struct {
	SimpleThreadJSON
	Listen string `json:"listen"`
}

type GQLWSMsg struct {
	ID      string       `json:"id,omitempty"`
	Type    string       `json:"type"`
	Payload GQLWSPayload `json:"payload,omitempty"`
}

type GQLWSPayload struct {
	OperationName string                 `json:"operationName,omitempty"`
	Query         string                 `json:"query,omitempty"`
	Variables     map[string]interface{} `json:"variables,omitempty"`
	Extensions    map[string]interface{} `json:"extensions,omitempty"`
	Data          string                 `json:"data,omitempty"`
}

type GraphNode struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type GraphSignal interface {
	// How to propogate the signal
	Direction() SignalDirection
	Source() NodeID
	Type() string
	String() string
}

type Lockable interface {
	// All Lockables are nodes
	Node
	//// State Modification Function
	// Record that lockable was returned to it's owner and is no longer held by this Node
	// Returns the previous owner of the lockable
	RecordUnlock(lockable Lockable) Lockable
	// Record that lockable was locked by this node, and that it should be returned to last_owner
	RecordLock(lockable Lockable, last_owner Lockable)
	// Link a requirement to this Node
	AddRequirement(requirement Lockable)
	// Remove a requirement linked to this Node
	RemoveRequirement(requirement Lockable)
	// Link a dependency to this Node
	AddDependency(dependency Lockable)
	// Remove a dependency linked to this Node
	RemoveDependency(dependency Lockable)
	//
	SetOwner(new_owner Lockable)

	//// State Reading Functions
	Name() string
	// Called when new_owner wants to take lockable's lock but it's owned by this node
	// A true return value means that the lock can be passed
	AllowedToTakeLock(new_owner Lockable, lockable Lockable) bool
	// Get all the linked requirements to this node
	Requirements() []Lockable
	// Get all the linked dependencies to this node
	Dependencies() []Lockable
	// Get the node's Owner
	Owner() Lockable
	// Called during the lock process after locking the state and before updating the Node's state
	// a non-nil return value will abort the lock attempt
	CanLock(new_owner Lockable) error
	// Called during the unlock process after locking the state and before updating the Node's state
	// a non-nil return value will abort the unlock attempt
	CanUnlock(old_owner Lockable) error
}

type Logger interface {
	SetComponents(components []string) error
	// Log a formatted string
	Logf(component string, format string, items ...interface{})
	// Log a map of attributes and a format string
	Logm(component string, fields map[string]interface{}, format string, items ...interface{})
	// Log a structure to a file by marshalling and unmarshalling the json
	Logj(component string, s interface{}, format string, items ...interface{})
}

type Node interface {
	sync.Locker
	RLock()
	RUnlock()
	// Serialize the Node for the database
	Serialize() ([]byte, error)
	ID() NodeID
	Type() NodeType
	// Send a GraphSignal to the node, requires that the node is locked for read so that it can propagate
	Signal(ctx *Context, signal GraphSignal, nodes NodeMap) error
	// Register a channel to receive updates sent to the node
	RegisterChannel(id NodeID, listener chan GraphSignal)
	// Unregister a channel from receiving updates sent to the node
	UnregisterChannel(id NodeID)
}

type NodeDef struct {
	Load    NodeLoadFunc
	Type    NodeType
	GQLType *graphql.Object
	Reflect reflect.Type
}

type NodeID string

type NodeLoadFunc func(*Context, NodeID, []byte, NodeMap) (Node, error)

type NodeMap map[NodeID]Node

type NodeType string

type NodesFn func(nodes NodeMap) error

type ObjTypeMap map[reflect.Type]*graphql.Object

type SignalDirection int

type SimpleLockable struct {
	GraphNode
	// contains filtered or unexported fields
}

type SimpleLockableJSON struct {
	Name         string             `json:"name"`
	Owner        *NodeID            `json:"owner"`
	Dependencies []NodeID           `json:"dependencies"`
	Requirements []NodeID           `json:"requirements"`
	LocksHeld    map[NodeID]*NodeID `json:"locks_held"`
}

type SimpleThread struct {
	SimpleLockable

	InfoType reflect.Type
	// contains filtered or unexported fields
}

type SimpleThreadJSON struct {
	Parent        *NodeID                `json:"parent"`
	Children      map[NodeID]interface{} `json:"children"`
	Timeout       time.Time              `json:"timeout"`
	TimeoutAction string                 `json:"timeout_action"`
	StateName     string                 `json:"state_name"`
	SimpleLockableJSON
}

type Thread interface {
	// All Threads are Lockables
	Lockable
	/// State Modification Functions
	SetParent(parent Thread)
	AddChild(child Thread, info ThreadInfo) error
	RemoveChild(child Thread)
	SetState(new_thread string) error
	SetTimeout(end_time time.Time, action string)
	/// State Reading Functions
	Parent() Thread
	Children() []Thread
	Child(id NodeID) Thread
	ChildInfo(child NodeID) ThreadInfo
	State() string
	TimeoutAction() string

	/// Functions that dont read/write thread
	// Deserialize the attribute map from json.Unmarshal
	DeserializeInfo(ctx *Context, data []byte) (ThreadInfo, error)
	SetActive(active bool) error
	Action(action string) (ThreadAction, bool)
	Handler(signal_type string) (ThreadHandler, bool)

	// Internal timeout channel for thread
	Timeout() <-chan time.Time
	// Internal signal channel for thread
	SignalChannel() <-chan GraphSignal
	ClearTimeout()

	ChildWaits() *sync.WaitGroup
}

type ThreadAbortedError NodeID

type ThreadAction func(*Context, Thread) (string, error)

type ThreadActions map[string]ThreadAction

type ThreadHandler func(*Context, Thread, GraphSignal) (string, error)

type ThreadHandlers map[string]ThreadHandler

type ThreadInfo interface {
}