dml

type Behaviour interface {
	Object

	GetBehaviourType() string                                        //returns the type of behaviour, e.g. "Transaction". Needed to allow multiple different structs implement single behaviour
	HandleEvent(Identifier, Identifier, string, []interface{}) error //Entry for any kind of behhaviour handling. Here the event that can be handled according to the relevant Manager are provided
	HandleKeyword(Identifier, string, interface{}) error             //Handle Keywords on WAMP Api call to the object
}

type BehaviourHandler interface {

	//management functions for behaviours:
	//here general behaviour objects are handled, as a object has a defined set of behaviours.
	//This does not provide any database access, only logic
	HasBehaviour(string) bool
	GetBehaviourObject(string) Behaviour
	AddBehaviourObject(Behaviour) error
	Behaviours() []string

	//This function is used to retrieve a behaviour database access Identifier
	GetBehaviourIdentifier(Identifier, string) (Identifier, error)
	SetBehaviourIdentifier(Identifier, string, Identifier) error
	HasBehaviourIdentifier(Identifier, string) (bool, error)

	//convinience function for combined logic and db access
	GetBehaviour(Identifier, string) (dmlSet, error)

	//Forwards event to all behaviours given in list, and returns the ones not available
	//Identifier, source object, eventname, arguments, behaviours to forward, recursive (true) or original object(false).
	HandleBehaviourEvent(Identifier, Identifier, string, []interface{}, []string, bool) ([]string, error)

	//Forwards WAMP keywords to all behaviours given in list, and returns the ones not available
	//Identifier, keyword arguments, behaviours to forward, recursive (true) or original object(false).
	HandleBehaviourKeywords(Identifier, map[string]interface{}, []string, bool) ([]string, error)
	// contains filtered or unexported methods
}

type Boolean bool

type CreatorFunc func(rntm *Runtime) (Object, error)

type DML struct {

	//next to imports only a single object is allowed: root must be unambigious
	Imports []*astImport `{ @@ }`
	Object  *astObject   `{ @@ }`
}

type Data interface {
	Object
	BehaviourHandler

	//Data hirarchy allows childs. Here we add the structure and logic by
	//adding static objects. Database access by identifiers is handled seperatly
	AddChildObject(Data)
	GetChildObjects() []Data

	//Data hirarchy allows childs
	AddChildIdentifier(Identifier, Identifier) error
	GetChildIdentifiers(Identifier) ([]Identifier, error)
	GetChildIdentifierByName(Identifier, string) (Identifier, error)

	//little convinience function for children hirarchy combining objects and IDs
	GetChildren(Identifier) ([]dmlSet, error)
	GetChildByName(Identifier, string) (dmlSet, error)

	GetSubobjects(id Identifier) ([]dmlSet, error) //Convinience function to get all subobjects, including childs, behaviours any any created ones
	Created(id Identifier) error
	ProcessBehaviourKeywords(id Identifier, kwargs map[string]interface{}) error //handles the keyword arguments in the behaviours of this object                                                          //emits onCreated event for this and all subobjects (not behaviours)
	// contains filtered or unexported methods
}

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

type DataType struct {
	Value string
}

type EmmitedEvent struct {
	Path string
	Args []interface{}
}

type Event interface {
	JSObject
	MethodHandler

	GetName() string
	SetNotifyer(EventEmitNotifyer)

	Emit(Identifier, ...interface{}) error
	Enabled(Identifier) (bool, error)
	Enable(Identifier) error
	Disable(Identifier) error

	//DB individual, add to a certain Identifier a callback as function to call from annother identifier
	RegisterCallback(Identifier, Identifier, string) error

	//Object based, add callback functions to all identifiers of the object
	//note: only allowed for callbacks in the same object the event lives in. The reason is the
	//passed identifier: it is always the event parent object that emits the event. Hence if a function
	//to annother object is passed the identifier may have different type than the object called
	//Therefore any JS function registered is handled as it would be a object function.
	RegisterObjectJSCallback(func(goja.FunctionCall) goja.Value) error
	RegisterObjectGoCallback(EventCallback) error
}

type EventCallback func(Identifier, ...interface{}) error

type EventEmitNotifyer interface {
	EventEmitted(Identifier, string, ...interface{}) error
}

type EventHandler interface {
	HasEvent(name string) bool
	AddEvent(evt Event) error
	GetEvent(name string) Event
	Events() []string
	SetupJSEvents(*goja.Object) error
	SetupEventNotifyer(EventEmitNotifyer)
	InitializeEventDB(Identifier) error
}

type EventObjectCallback struct {
	Id       Identifier
	Function string
}

type Identifier struct {
	Parent [32]byte
	Type   string
	Name   string
	Uuid   string
}

type JSObject interface {
	GetJSObject(Identifier) *goja.Object
	GetJSPrototype() *goja.Object
	GetJSRuntime() *goja.Runtime
}

type Key struct {
	Internal interface{}
}

type Method interface {
	Call(args ...interface{}) (interface{}, error)
	CallBoolReturn(args ...interface{}) (bool, error)
	IsConst() bool
	IsIdMethod() bool
}

type MethodHandler interface {
	AddMethod(name string, method Method)
	HasMethod(name string) bool
	GetMethod(name string) Method
	Methods() []string

	SetupJSMethods(vm *Runtime, obj *goja.Object) error
}

type Object interface {
	PropertyHandler
	PropertyChangeNotifyer
	EventHandler
	EventEmitNotifyer
	MethodHandler
	JSObject

	//Object functions
	GetParentIdentifier(Identifier) (Identifier, error)
	SetParentIdentifier(Identifier, Identifier) error
	GetParent(Identifier) (dmlSet, error)

	//Object type handling (full type desciption of this object)
	GetObjectDataType() DataType
	SetObjectDataType(DataType)

	//Identifier type handling. It could be, that a certain object is used to access
	//the database for a object of different DataType
	GetDataType(Identifier) (DataType, error)
	SetDataType(Identifier, DataType) error

	//Let the object know it's path in the dml runtime. This is important for event
	//emitting, as it needs to know what exact uri to use. Note that the path cannot
	//be determined at runtime from an object, as in maps or vectors it is not possible
	//to get the key easily by value (only by iterating, but thats expensive for each
	//event emit)
	GetObjectPath(Identifier) (string, error)
	SetObjectPath(Identifier, string) error //sets the full path including the object name

	//Genertic
	GetRuntime() *Runtime

	//VersionedData interface based on Identifiers (For whole object)
	HasUpdates(Identifier) (bool, error)
	HasVersions(Identifier) (bool, error)
	ResetHead(Identifier) error
	FixStateAsVersion(Identifier) (datastore.VersionID, error)
	LoadVersion(Identifier, datastore.VersionID) error
	GetLatestVersion(Identifier) (datastore.VersionID, error)
	GetCurrentVersion(Identifier) (datastore.VersionID, error)
	RemoveVersionsUpTo(Identifier, datastore.VersionID) error
	RemoveVersionsUpFrom(Identifier, datastore.VersionID) error

	//VersionedData interface based on keys, and subkeys
	BuildVersionedKey(Identifier, datastore.StorageType, ...interface{}) datastore.Key
	KeysAnyHasUpdates([]datastore.Key) (bool, error)   //true if any of the given keys has an update
	KeysAllHaveVersions([]datastore.Key) (bool, error) //true if all of the given keys have updates
	KeysResetHead([]datastore.Key) error
	KeysFixStateAsVersion([]datastore.Key) ([]datastore.VersionID, error)
	KeysLoadVersion([]datastore.Key, []datastore.VersionID) error
	KeysGetLatestVersion([]datastore.Key) ([]datastore.VersionID, error)
	KeysGetCurrentVersion([]datastore.Key) ([]datastore.VersionID, error)
	KeysRemoveVersionsUpTo([]datastore.Key, []datastore.VersionID) error
	KeysRemoveVersionsUpFrom([]datastore.Key, []datastore.VersionID) error

	//Key handling for generic access to Data, events, properties, methods etc.
	GetByKey(Identifier, Key) (interface{}, error) //Returns whatever the key represents in the Dataobject
	HasKey(Identifier, Key) (bool, error)          //Returns true if the provided key exists
	GetKeys(Identifier) ([]Key, error)             //returns all available keys

	//helpers method for getting database access
	GetDBValue(Identifier, []byte) (datastore.Value, error)
	GetDBValueVersioned(Identifier, []byte) (datastore.ValueVersioned, error)
	GetDBMap(Identifier, []byte) (datastore.Map, error)
	GetDBMapVersioned(Identifier, []byte) (datastore.MapVersioned, error)
	GetDBList(Identifier, []byte) (datastore.List, error)
	GetDBListVersioned(Identifier, []byte) (datastore.ListVersioned, error)
	EraseFromDB(Identifier) error

	//initialization function
	InitializeDB(Identifier) error
	// contains filtered or unexported methods
}

type PropGetter func(Identifier) (interface{}, error)

type PropSetter func(Identifier, interface{}) error

type Property interface {
	//	EventHandler
	Type() DataType
	IsConst() bool
	IsReadOnly() bool

	SetValue(id Identifier, value interface{}) error
	GetValue(id Identifier) (interface{}, error)

	//required for startup, sets the initial value
	SetDefaultValue(value interface{}) error
	GetDefaultValue() interface{}
	InitializeDB(id Identifier) error
}

type PropertyChangeNotifyer interface {
	BeforePropertyChange(Identifier, string) error
	PropertyChanged(Identifier, string) error
}

type PropertyHandler interface {
	HasProperty(string) bool
	AddProperty(string, DataType, interface{}, PropertyType) error
	AddFuncProperty(string, PropGetter, PropSetter, bool) error
	GetProperty(string) Property
	GetProperties() []string

	SetupProperties(rntm *Runtime, jsobj *goja.Object, cb PropertyChangeNotifyer) error
	InitializePropertyDB(Identifier) error
}

type PropertyType int

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

type System interface {
	MethodHandler

	ExposedToJS() bool
	GetJSObject() *goja.Object

	CanHandleEvent(string) bool   //events to be handled by the behaviour type
	CanHandleKeyword(string) bool //WAMP call keywords to be handled by the behaviour type

	BeforeOperation() error //called before a WAMP operation is processed
	AfterOperation() error  //called after a WAMP operation is Processed
}

type SystemCreatorFunc func(*Runtime) (System, error)

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

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

type User string