ki

func (*Deleted) Add ¶

func (dm *Deleted) Add(kis ...Ki)

Add the Ki elements to the deleted list

func (*Deleted) DestroyDeleted ¶

func (dm *Deleted) DestroyDeleted()

DestroyDeleted destroys any deleted items in list

func (Flags) Desc ¶ added in v1.1.16

func (i Flags) Desc() string

func (*Flags) FromString ¶

func (i *Flags) FromString(s string) error

func (Flags) String ¶

func (i Flags) String() string

func (*Node) AddChild ¶

func (n *Node) AddChild(kid Ki) error

AddChild adds given child at end of children list. The kid node is assumed to not be on another tree (see MoveToParent) and the existing name should be unique among children. No UpdateStart / End wrapping is done: do that externally as needed. Can also call SetFlag(ki.ChildAdded) if notification is needed.

func (*Node) AddNewChild ¶

func (n *Node) AddNewChild(typ reflect.Type, name string) Ki

AddNewChild creates a new child of given type and add at end of children list. The name should be unique among children. No UpdateStart / End wrapping is done: do that externally as needed. Can also call SetChildAdded() if notification is needed.

func (*Node) AsNode ¶ added in v0.9.8

func (n *Node) AsNode() *Node

AsNode returns the *ki.Node base type for this node.

func (*Node) BaseIface ¶

func (n *Node) BaseIface() reflect.Type

BaseIface returns the base interface type for all elements within this tree. Use reflect.TypeOf((*<interface_type>)(nil)).Elem(). Used e.g., for determining what types of children can be created (see kit.EmbedImplements for test method)

func (*Node) Child ¶

func (n *Node) Child(idx int) Ki

Child returns the child at given index -- will panic if index is invalid. See methods on ki.Slice for more ways to access.

func (*Node) ChildByName ¶

func (n *Node) ChildByName(name string, startIdx int) Ki

ChildByName returns first element that has given name, nil if not found. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Node) ChildByNameTry ¶

func (n *Node) ChildByNameTry(name string, startIdx int) (Ki, error)

ChildByNameTry returns first element that has given name, error if not found. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Node) ChildByType ¶

func (n *Node) ChildByType(t reflect.Type, embeds bool, startIdx int) Ki

ChildByType returns first element that has given type, nil if not found. If embeds is true, then it looks for any type that embeds the given type at any level of anonymous embedding. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Node) ChildByTypeTry ¶

func (n *Node) ChildByTypeTry(t reflect.Type, embeds bool, startIdx int) (Ki, error)

ChildByTypeTry returns first element that has given name -- Try version returns error message if not found. If embeds is true, then it looks for any type that embeds the given type at any level of anonymous embedding. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Node) ChildTry ¶

func (n *Node) ChildTry(idx int) (Ki, error)

ChildTry returns the child at given index. Try version returns error if index is invalid. See methods on ki.Slice for more ways to acces.

func (*Node) Children ¶

func (n *Node) Children() *Slice

Children returns a pointer to the slice of children (Node.Kids) -- use methods on ki.Slice for further ways to access (ByName, ByType, etc). Slice can be modified directly (e.g., sort, reorder) but Add* / Delete* methods on parent node should be used to ensure proper tracking.

func (*Node) ClearFlag ¶

func (n *Node) ClearFlag(flag ...int)

ClearFlag clears the given flag(s) using atomic, safe for concurrent access

func (*Node) ClearFlagMask ¶

func (n *Node) ClearFlagMask(mask int64)

ClearFlagMask clears the given flags as a bitmask using atomic, safe for concurrent access

func (*Node) Clone ¶

func (n *Node) Clone() Ki

Clone creates and returns a deep copy of the tree from this node down. Any pointers within the cloned tree will correctly point within the new cloned tree (see Copy info).

func (*Node) ConfigChildren ¶

func (n *Node) ConfigChildren(config kit.TypeAndNameList) (mods, updt bool)

ConfigChildren configures children according to given list of type-and-name's -- attempts to have minimal impact relative to existing items that fit the type and name constraints (they are moved into the corresponding positions), and any extra children are removed, and new ones added, to match the specified config. If uniqNm, then names represent UniqueNames (this results in Name == UniqueName for created children).

IMPORTANT: returns whether any modifications were made (mods) AND if that is true, the result from the corresponding UpdateStart call -- UpdateEnd is NOT called, allowing for further subsequent updates before you call UpdateEnd(updt).

func (*Node) CopyFieldsFrom ¶

func (n *Node) CopyFieldsFrom(frm any)

CopyFieldsFrom copies from primary fields of source object, recursively following anonymous embedded structs

func (*Node) CopyFrom ¶

func (n *Node) CopyFrom(frm Ki) error

CopyFrom another Ki node. It is essential that source has Unique names! The Ki copy function recreates the entire tree in the copy, duplicating children etc, copying Props too. It is very efficient by using the ConfigChildren method which attempts to preserve any existing nodes in the destination if they have the same name and type -- so a copy from a source to a target that only differ minimally will be minimally destructive. Only copies to same types are supported. Signal connections are NOT copied. No other Ki pointers are copied, and the field tag copy:"-" can be added for any other fields that should not be copied (unexported, lower-case fields are not copyable).

func (*Node) CopyPropsFrom ¶

func (n *Node) CopyPropsFrom(frm Ki, deep bool) error

CopyPropsFrom copies our properties from another node -- if deep then does a deep copy -- otherwise copied map just points to same values in the original map (and we don't reset our map first -- call DeleteAllProps to do that -- deep copy uses gob encode / decode -- usually not needed).

func (*Node) Delete ¶

func (n *Node) Delete(destroy bool)

Delete deletes this node from its parent children list -- destroy will add removed child to deleted list, to be destroyed later -- otherwise child remains intact but parent is nil -- could be inserted elsewhere.

func (*Node) DeleteChild ¶

func (n *Node) DeleteChild(child Ki, destroy bool) error

DeleteChild deletes child node, returning error if not found in Children. Wraps delete in UpdateStart / End and sets ChildDeleted flag.

func (*Node) DeleteChildAtIndex ¶

func (n *Node) DeleteChildAtIndex(idx int, destroy bool) error

DeleteChildAtIndex deletes child at given index (returns error for invalid index). Wraps delete in UpdateStart / End and sets ChildDeleted flag.

func (*Node) DeleteChildByName ¶

func (n *Node) DeleteChildByName(name string, destroy bool) (Ki, error)

DeleteChildByName deletes child node by name -- returns child, error if not found. Wraps delete in UpdateStart / End and sets ChildDeleted flag.

func (*Node) DeleteChildren ¶

func (n *Node) DeleteChildren(destroy bool)

DeleteChildren deletes all children nodes -- destroy will add removed children to deleted list, to be destroyed later -- otherwise children remain intact but parent is nil -- could be inserted elsewhere, but you better have kept a slice of them before calling this.

func (*Node) DeleteProp ¶

func (n *Node) DeleteProp(key string)

DeleteProp deletes property key on this node.

func (*Node) Destroy ¶

func (n *Node) Destroy()

Destroy calls DisconnectAll to cut all pointers and signal connections, and remove all children and their childrens-children, etc.

func (*Node) Disconnect ¶

func (n *Node) Disconnect()

Disconnect disconnects this node, by calling DisconnectAll() on any Signal fields. Any Node that adds a Signal must define an updated version of this method that calls its embedded parent's version and then calls DisconnectAll() on its Signal fields.

func (*Node) DisconnectAll ¶

func (n *Node) DisconnectAll()

DisconnectAll disconnects all the way from me down the tree.

func (*Node) Embed ¶

func (n *Node) Embed(t reflect.Type) Ki

Embed returns the embedded struct of given type from this node (or nil if it does not embed that type, or the type is not a Ki type -- see kit.Embed for a generic interface{} version.

func (*Node) FindPath ¶ added in v1.1.0

func (n *Node) FindPath(path string) Ki

FindPath returns Ki object at given path, starting from this node (e.g., the root). If this node is not the root, then the path to this node is subtracted from the start of the path if present there. FindPath only works correctly when names are unique. Path has node Names separated by / and fields by . Node names escape any existing / and . characters to \\ and \, There is also support for [idx] index-based access for any given path element, for cases when indexes are more useful than names. Returns nil if not found.

func (*Node) FindPathTry ¶ added in v1.1.0

func (n *Node) FindPathTry(path string) (Ki, error)

FindPathTry returns Ki object at given path, starting from this node (e.g., the root). If this node is not the root, then the path to this node is subtracted from the start of the path if present there. FindPath only works correctly when names are unique. Path has node Names separated by / and fields by . Node names escape any existing / and . characters to \\ and \, There is also support for [idx] index-based access for any given path element, for cases when indexes are more useful than names. Returns error if not found.

func (*Node) Flags ¶

func (n *Node) Flags() int64

Flags returns an atomically safe copy of the bit flags for this node -- can use bitflag package to check lags. See Flags type for standard values used in Ki Node -- can be extended from FlagsN up to 64 bit capacity. Note that we must always use atomic access as *some* things need to be atomic, and with bits, that means that *all* access needs to be atomic, as you cannot atomically update just a single bit.

func (*Node) FuncDownBreadthFirst ¶

func (n *Node) FuncDownBreadthFirst(level int, data any, fun Func)

FuncDownBreadthFirst calls function on all children in breadth-first order using the standard queue strategy. This depends on and updates the Depth parameter of the node. If fun returns false then any further traversal of that branch of the tree is aborted, but other branches continue.

func (*Node) FuncDownMeFirst ¶

func (n *Node) FuncDownMeFirst(level int, data any, fun Func)

FuncDownMeFirst calls function on this node (MeFirst) and then iterates in a depth-first manner over all the children, including Ki Node fields, which are processed first before children. The node traversal is non-recursive and uses locally-allocated state -- safe for concurrent calling (modulo conflict management in function call itself). Function calls are sequential all in current go routine. The level var tracks overall depth in the tree. If fun returns false then any further traversal of that branch of the tree is aborted, but other branches continue -- i.e., if fun on current node returns false, children are not processed further.

func (*Node) FuncDownMeLast ¶ added in v0.9.8

func (n *Node) FuncDownMeLast(level int, data any, doChildTestFunc Func, fun Func)

FuncDownMeLast iterates in a depth-first manner over the children, calling doChildTestFunc on each node to test if processing should proceed (if it returns false then that branch of the tree is not further processed), and then calls given fun function after all of a node's children (including fields) have been iterated over ("Me Last"). The node traversal is non-recursive and uses locally-allocated state -- safe for concurrent calling (modulo conflict management in function call itself). Function calls are sequential all in current go routine. The level var tracks overall depth in the tree.

func (*Node) FuncFields ¶

func (n *Node) FuncFields(level int, data any, fun Func)

FuncFields calls function on all Ki fields within this node.

func (*Node) FuncUp ¶

func (n *Node) FuncUp(level int, data any, fun Func) bool

FuncUp calls function on given node and all the way up to its parents, and so on -- sequentially all in current go routine (generally necessary for going up, which is typically quite fast anyway) -- level is incremented after each step (starts at 0, goes up), and passed to function -- returns false if fun aborts with false, else true.

func (*Node) FuncUpParent ¶

func (n *Node) FuncUpParent(level int, data any, fun Func) bool

FuncUpParent calls function on parent of node and all the way up to its parents, and so on -- sequentially all in current go routine (generally necessary for going up, which is typically quite fast anyway) -- level is incremented after each step (starts at 0, goes up), and passed to function -- returns false if fun aborts with false, else true.

func (*Node) HasChildren ¶

func (n *Node) HasChildren() bool

HasChildren tests whether this node has children (i.e., non-terminal).

func (*Node) HasFlag ¶

func (n *Node) HasFlag(flag int) bool

HasFlag checks if flag is set using atomic, safe for concurrent access

func (*Node) IndexInParent ¶

func (n *Node) IndexInParent() (int, bool)

IndexInParent returns our index within our parent object -- caches the last value and uses that for an optimized search so subsequent calls are typically quite fast. Returns false if we don't have a parent.

func (*Node) InitName ¶

func (n *Node) InitName(k Ki, name string)

InitName initializes this node to given actual object as a Ki interface and sets its name. The names should be unique among children of a node. This is needed for root nodes -- automatically done for other nodes when they are added to the Ki tree. Even though this is a method and gets the method receiver, it needs an "external" version of itself passed as the first arg, from which the proper Ki interface pointer will be obtained. This is the only way to get virtual functional calling to work within the Go framework.

func (*Node) InsertChild ¶

func (n *Node) InsertChild(kid Ki, at int) error

InsertChild adds given child at position in children list. The kid node is assumed to not be on another tree (see MoveToParent) and the existing name should be unique among children. No UpdateStart / End wrapping is done: do that externally as needed. Can also call SetChildAdded() if notification is needed.

func (*Node) InsertNewChild ¶

func (n *Node) InsertNewChild(typ reflect.Type, at int, name string) Ki

InsertNewChild creates a new child of given type and add at position in children list. The name should be unique among children. No UpdateStart / End wrapping is done: do that externally as needed. Can also call SetChildAdded() if notification is needed.

func (*Node) IsDeleted ¶

func (n *Node) IsDeleted() bool

IsDeleted checks if this node has just been deleted (within last update cycle), indicated by the NodeDeleted flag which is set when the node is deleted, and is cleared at next UpdateStart call.

func (*Node) IsDestroyed ¶

func (n *Node) IsDestroyed() bool

IsDestroyed checks if this node has been destroyed -- the NodeDestroyed flag is set at start of Destroy function -- the Signal Emit process checks for destroyed receiver nodes and removes connections to them automatically -- other places where pointers to potentially destroyed nodes may linger should also check this flag and reset those pointers.

func (*Node) IsField ¶

func (n *Node) IsField() bool

IsField checks if this is a field on a parent struct (via IsField Flag), as opposed to a child in Children -- Ki nodes can be added as fields to structs and they are automatically parented and named with field name during Init function -- essentially they function as fixed children of the parent struct, and are automatically included in FuncDown* traversals, etc -- see also FunFields.

func (*Node) IsUpdating ¶

func (n *Node) IsUpdating() bool

IsUpdating checks if node is currently updating.

func (*Node) IsValidIndex ¶

func (n *Node) IsValidIndex(idx int) error

IsValidIndex returns error if given index is not valid for accessing children nil otherwise.

func (*Node) Name ¶

func (n *Node) Name() string

Name returns the user-defined name of the object (Node.Nm), for finding elements, generating paths, IO, etc.

func (*Node) NodeSignal ¶

func (n *Node) NodeSignal() *Signal

NodeSignal returns the main signal for this node that is used for update, child signals.

func (*Node) NumChildren ¶ added in v0.9.8

func (n *Node) NumChildren() int

NumChildren returns the number of children of this node.

func (*Node) OnAdd ¶ added in v1.1.16

func (n *Node) OnAdd()

OnAdd is a placeholder implementation of [Ki.OnAdd] that does nothing.

func (*Node) OnChildAdded ¶ added in v1.1.16

func (n *Node) OnChildAdded(child Ki)

OnChildAdded is a placeholder implementation of [Ki.OnChildAdded] that does nothing.

func (*Node) OnInit ¶ added in v1.1.16

func (n *Node) OnInit()

OnInit is a placeholder implementation of [Ki.OnInit] that does nothing.

func (*Node) OnlySelfUpdate ¶

func (n *Node) OnlySelfUpdate() bool

OnlySelfUpdate checks if this node only applies UpdateStart / End logic to itself, not its children (which is the default) (via Flag of same name) -- useful for a parent node that has a different function than its children.

func (*Node) OpenJSON ¶

func (n *Node) OpenJSON(filename string) error

OpenJSON opens file over this tree from a JSON-encoded file -- see ReadJSON for details, and OpenNewJSON for opening an entirely new tree.

func (*Node) Parent ¶

func (n *Node) Parent() Ki

Parent returns the parent of this Ki (Node.Par) -- Ki has strict one-parent, no-cycles structure -- see SetParent.

func (*Node) ParentByName ¶

func (n *Node) ParentByName(name string) Ki

ParentByName finds first parent recursively up hierarchy that matches given name -- returns nil if not found.

func (*Node) ParentByNameTry ¶

func (n *Node) ParentByNameTry(name string) (Ki, error)

ParentByNameTry finds first parent recursively up hierarchy that matches given name -- returns error if not found.

func (*Node) ParentByType ¶

func (n *Node) ParentByType(t reflect.Type, embeds bool) Ki

ParentByType finds parent recursively up hierarchy, by type, and returns nil if not found. If embeds is true, then it looks for any type that embeds the given type at any level of anonymous embedding.

func (*Node) ParentByTypeTry ¶

func (n *Node) ParentByTypeTry(t reflect.Type, embeds bool) (Ki, error)

ParentByTypeTry finds parent recursively up hierarchy, by type, and returns error if not found. If embeds is true, then it looks for any type that embeds the given type at any level of anonymous embedding.

func (*Node) ParentLevel ¶

func (n *Node) ParentLevel(par Ki) int

ParentLevel finds a given potential parent node recursively up the hierarchy, returning level above current node that the parent was found, and -1 if not found.

func (*Node) Path ¶

func (n *Node) Path() string

Path returns path to this node from the tree root, using node Names separated by / and fields by . Node names escape any existing / and . characters to \\ and \, Path is only valid when child names are unique (see Unique* functions)

func (*Node) PathFrom ¶

func (n *Node) PathFrom(par Ki) string

PathFrom returns path to this node from given parent node, using node Names separated by / and fields by . Node names escape any existing / and . characters to \\ and \, Path is only valid for finding items when child names are unique (see Unique* functions)

func (*Node) Prop ¶

func (n *Node) Prop(key string) any

Prop returns property value for key that is known to exist. Returns nil if it actually doesn't -- this version allows direct conversion of return. See PropTry for version with error message if uncertain if property exists.

func (*Node) PropInherit ¶

func (n *Node) PropInherit(key string, inherit, typ bool) (any, bool)

PropInherit gets property value from key with options for inheriting property from parents and / or type-level properties. If inherit, then checks all parents. If typ then checks property on type as well (registered via KiT type registry). Returns false if not set anywhere.

func (*Node) PropTag ¶

func (n *Node) PropTag() string

PropTag returns the name to look for in type properties, for types that are valid options for values that can be set in Props. For example in GoGi, it is "style-props" which is then set for all types that can be used in a style (colors, enum options, etc)

func (*Node) PropTry ¶

func (n *Node) PropTry(key string) (any, error)

PropTry returns property value for key. Returns error message if property with that key does not exist.

func (*Node) Properties ¶

func (n *Node) Properties() *Props

Properties (Node.Props) tell the GoGi GUI or other frameworks operating on Trees about special features of each node -- functions below support inheritance up Tree -- see kit convert.go for robust convenience methods for converting interface{} values to standard types.

func (*Node) ReadJSON ¶

func (n *Node) ReadJSON(reader io.Reader) error

ReadJSON reads and unmarshals tree starting at this node, from a JSON-encoded byte stream via io.Reader. First element in the stream must be of same type as this node -- see ReadNewJSON function to construct a new tree. Uses ConfigureChildren to minimize changes from current tree relative to loading one -- wraps UnmarshalJSON and calls UnmarshalPost to recover pointers from paths.

func (*Node) ReadXML ¶

func (n *Node) ReadXML(reader io.Reader) error

ReadXML reads the tree from an XML-encoded byte string over io.Reader, calls UnmarshalPost to recover pointers from paths.

func (*Node) SaveJSON ¶

func (n *Node) SaveJSON(filename string) error

SaveJSON saves the tree to a JSON-encoded file, using WriteJSON.

func (*Node) SetChild ¶

func (n *Node) SetChild(kid Ki, idx int, name string) error

SetChild sets child at given index to be the given item -- if name is non-empty then it sets the name of the child as well -- just calls Init (or InitName) on the child, and SetParent. Names should be unique among children. No UpdateStart / End wrapping is done: do that externally as needed. Can also call SetChildAdded() if notification is needed.

func (*Node) SetChildAdded ¶ added in v1.1.0

func (n *Node) SetChildAdded()

SetChildAdded sets the ChildAdded flag -- set when notification is needed for Add, Insert methods

func (*Node) SetField ¶

func (n *Node) SetField(field string, val any) error

SetField sets given field name to given value, using very robust conversion routines to e.g., convert from strings to numbers, and vice-versa, automatically. Returns error if not successfully set. wrapped in UpdateStart / End and sets the ValUpdated flag.

func (*Node) SetFlag ¶

func (n *Node) SetFlag(flag ...int)

SetFlag sets the given flag(s) using atomic, safe for concurrent access

func (*Node) SetFlagMask ¶

func (n *Node) SetFlagMask(mask int64)

SetFlagMask sets the given flags as a mask using atomic, safe for concurrent access

func (*Node) SetFlagState ¶

func (n *Node) SetFlagState(on bool, flag ...int)

SetFlagState sets the given flag(s) to given state using atomic, safe for concurrent access

func (*Node) SetNChildren ¶

func (n *Node) SetNChildren(trgn int, typ reflect.Type, nameStub string) (mods, updt bool)

SetNChildren ensures that there are exactly n children, deleting any extra, and creating any new ones, using AddNewChild with given type and naming according to nameStubX where X is the index of the child.

IMPORTANT: returns whether any modifications were made (mods) AND if that is true, the result from the corresponding UpdateStart call -- UpdateEnd is NOT called, allowing for further subsequent updates before you call UpdateEnd(updt)

Note that this does not ensure existing children are of given type, or change their names -- use ConfigChildren for those cases. This function is for simpler cases where a parent uses this function consistently to manage children all of the same type.

func (*Node) SetName ¶

func (n *Node) SetName(name string)

SetName sets the name of this node. Names should generally be unique across children of each node. See Unique* functions to check / fix. If node requires non-unique names, add a separate Label field. Does NOT wrap in UpdateStart / End.

func (*Node) SetOnlySelfUpdate ¶

func (n *Node) SetOnlySelfUpdate()

SetOnlySelfUpdate sets the OnlySelfUpdate flag -- see OnlySelfUpdate method and flag.

func (*Node) SetProp ¶

func (n *Node) SetProp(key string, val any)

SetProp sets given property key to value val. initializes property map if nil.

func (*Node) SetPropFloat64 ¶

func (n *Node) SetPropFloat64(key string, val float64)

SetPropFloat64 sets given property key to value val as a float64 (e.g., for python wrapper) Initializes property map if nil.

func (*Node) SetPropInt ¶

func (n *Node) SetPropInt(key string, val int)

SetPropInt sets given property key to value val as an int (e.g., for python wrapper) Initializes property map if nil.

func (*Node) SetPropStr ¶

func (n *Node) SetPropStr(key string, val string)

SetPropStr sets given property key to value val as a string (e.g., for python wrapper) Initializes property map if nil.

func (*Node) SetProps ¶

func (n *Node) SetProps(props Props)

SetProps sets a whole set of properties

func (*Node) SetSubProps ¶

func (n *Node) SetSubProps(key string, val Props)

SetSubProps sets given property key to sub-Props value (e.g., for python wrapper) Initializes property map if nil.

func (*Node) SetValUpdated ¶ added in v1.1.0

func (n *Node) SetValUpdated()

SetValUpdated sets the ValUpdated flag -- set when notification is needed for modifying a value (field, prop, etc)

func (*Node) String ¶

func (n *Node) String() string

String implements the fmt.stringer interface -- returns the Path of the node

func (*Node) This ¶

func (n *Node) This() Ki

This returns the Ki interface that guarantees access to the Ki interface in a way that always reveals the underlying type (e.g., in reflect calls). Returns nil if node is nil, has been destroyed, or is improperly constructed.

func (*Node) UpdateEnd ¶

func (n *Node) UpdateEnd(updt bool)

UpdateEnd should be called when done updating after an UpdateStart, and passed the result of the UpdateStart call -- if this is true, the NodeSignalUpdated signal will be emitted and the Updating flag will be cleared, and DestroyDeleted called -- otherwise it is a no-op.

func (*Node) UpdateEndNoSig ¶

func (n *Node) UpdateEndNoSig(updt bool)

UpdateEndNoSig is just like UpdateEnd except it does not emit a NodeSignalUpdated signal -- use this for situations where updating is already known to be in progress and the signal would be redundant.

func (*Node) UpdateSig ¶

func (n *Node) UpdateSig() bool

UpdateSig just emits a NodeSignalUpdated if the Updating flag is not set -- use this to trigger an update of a given node when there aren't any structural changes and you don't need to prevent any lower-level updates -- much more efficient than a pair of UpdateStart / UpdateEnd's. Returns true if an update signal was sent.

func (*Node) UpdateStart ¶

func (n *Node) UpdateStart() bool

UpdateStart should be called when starting to modify the tree (state or structure) -- returns whether this node was first to set the Updating flag (if so, all children have their Updating flag set -- pass the result to UpdateEnd -- automatically determines the highest level updated, within the normal top-down updating sequence -- can be called multiple times at multiple levels -- it is essential to ensure that all such Start's have an End! Usage:

updt := n.UpdateStart()
... code
n.UpdateEnd(updt)

or

updt := n.UpdateStart()
defer n.UpdateEnd(updt)
... code

func (*Node) WriteJSON ¶

func (n *Node) WriteJSON(writer io.Writer, indent bool) error

WriteJSON writes the tree to an io.Writer, using MarshalJSON -- also saves a critical starting record that allows file to be loaded de-novo and recreate the proper root type for the tree. This calls UniquifyNamesAll because it is essential that names be unique at this point.

func (*Node) WriteXML ¶

func (n *Node) WriteXML(writer io.Writer, indent bool) error

WriteXML writes the tree to an XML-encoded byte string over io.Writer using MarshalXML.

func (NodeSignals) Desc ¶ added in v1.1.16

func (i NodeSignals) Desc() string

func (*NodeSignals) FromString ¶

func (i *NodeSignals) FromString(s string) error

func (NodeSignals) String ¶

func (i NodeSignals) String() string

func (*PropSlice) CopyFrom ¶

func (dest *PropSlice) CopyFrom(src PropSlice, deepCopy bool)

CopyFrom copies properties from source to destination propslice. If deepCopy is true, then any values that are Props or PropSlice are copied too *dest can be nil, in which case it is created.

func (*PropSlice) ElemLabel ¶ added in v0.9.8

func (ps *PropSlice) ElemLabel(idx int) string

ElemLabel satisfies the gi.SliceLabeler interface to provide labels for slice elements

func (*Props) CopyFrom ¶

func (dest *Props) CopyFrom(src map[string]any, deepCopy bool)

CopyFrom copies properties from source to receiver destination map. If deepCopy is true, then any values that are Props or PropSlice are copied too *dest can be nil, in which case it is created.

func (Props) Delete ¶ added in v1.1.3

func (pr Props) Delete(key string)

Delete deletes props value at given key

func (Props) MarshalJSON ¶

func (p Props) MarshalJSON() ([]byte, error)

MarshalJSON saves the type information for each struct used in props, as a separate key with the __type: prefix -- this allows the Unmarshal to create actual types

func (Props) Prop ¶ added in v1.1.3

func (pr Props) Prop(key string) any

Prop returns property of given key

func (*Props) Set ¶ added in v1.1.3

func (pr *Props) Set(key string, val any)

Set sets props value -- safely creates map

func (*Props) UnmarshalJSON ¶

func (p *Props) UnmarshalJSON(b []byte) error

UnmarshalJSON parses the type information in the map to restore actual objects -- this is super inefficient and really needs a native parser, but props are likely to be relatively small

func (*Signal) Connect ¶

func (s *Signal) Connect(recv Ki, fun RecvFunc)

Connect attaches a new receiver and function to the signal -- only one such connection per receiver can be made, so any existing connection to that receiver will be overwritten

func (*Signal) ConnectOnly ¶

func (s *Signal) ConnectOnly(recv Ki, fun RecvFunc)

ConnectOnly first deletes any existing connections and then attaches a new receiver to the signal

func (*Signal) ConsFunc ¶ added in v1.0.2

func (s *Signal) ConsFunc(consFun func(recv Ki, fun RecvFunc) bool)

ConsFunc iterates over the connections with read lock and deletion of destroyed objects, calling given function on each connection -- if it returns false, then iteration is stopped, else continues. function is called with no lock in place.

func (*Signal) Disconnect ¶

func (s *Signal) Disconnect(recv Ki)

Disconnect disconnects (deletes) the connection for a given receiver

func (*Signal) DisconnectAll ¶

func (s *Signal) DisconnectAll()

DisconnectAll removes all connections

func (*Signal) DisconnectDestroyed ¶ added in v1.0.2

func (s *Signal) DisconnectDestroyed(recv Ki) bool

DisconnectDestroyed disconnects (deletes) the connection for a given receiver, if receiver is destroyed, assumed to be under an RLock (unlocks, relocks read lock). Returns true if was disconnected.

func (*Signal) Emit ¶

func (s *Signal) Emit(sender Ki, sig int64, data any)

Emit sends the signal across all the connections to the receivers -- sequentially but in random order due to the randomization of map iteration

func (*Signal) EmitFiltered ¶

func (s *Signal) EmitFiltered(sender Ki, sig int64, data any, filtFun SignalFilterFunc)

EmitFiltered calls function on each potential receiver, and only sends signal if function returns true

func (*Signal) EmitGo ¶

func (s *Signal) EmitGo(sender Ki, sig int64, data any)

EmitGo is the concurrent version of Emit -- sends the signal across all the connections to the receivers as separate goroutines

func (*Signal) EmitGoFiltered ¶

func (s *Signal) EmitGoFiltered(sender Ki, sig int64, data any, filtFun SignalFilterFunc)

EmitGoFiltered is the concurrent version of EmitFiltered -- calls function on each potential receiver, and only sends signal if function returns true (filtering is sequential iteration over receivers)

func (*Signal) EmitTrace ¶

func (s *Signal) EmitTrace(sender Ki, sig int64, data any)

EmitTrace records a trace of signal being emitted

func (*Signal) SendSig ¶

func (s *Signal) SendSig(recv, sender Ki, sig int64, data any)

SendSig sends a signal to one given receiver -- receiver must already be connected so that its receiving function is available

func (*Slice) Config ¶

func (sl *Slice) Config(n Ki, config kit.TypeAndNameList) (mods, updt bool)

Config is a major work-horse routine for minimally-destructive reshaping of a tree structure to fit a target configuration, specified in terms of a type-and-name list. If the node is != nil, then it has UpdateStart / End logic applied to it, only if necessary, as indicated by mods, updt return values.

func (*Slice) ConfigCopy ¶ added in v0.9.8

func (sl *Slice) ConfigCopy(n Ki, frm Slice)

ConfigCopy uses Config method to copy name / type config of Slice from source If n is != nil then Update etc is called properly. it is essential that child names are unique.

func (*Slice) CopyFrom ¶ added in v0.9.8

func (sl *Slice) CopyFrom(frm Slice)

CopyFrom another Slice. It is efficient by using the Config method which attempts to preserve any existing nodes in the destination if they have the same name and type -- so a copy from a source to a target that only differ minimally will be minimally destructive. it is essential that child names are unique.

func (*Slice) DeleteAtIndex ¶

func (sl *Slice) DeleteAtIndex(idx int) error

DeleteAtIndex deletes item at index -- does not do any further management deleted item -- optimized version for avoiding memory leaks. returns error if index is invalid.

func (*Slice) Elem ¶

func (sl *Slice) Elem(idx int) Ki

Elem returns element at index -- panics if index is invalid

func (*Slice) ElemByName ¶

func (sl *Slice) ElemByName(name string, startIdx int) Ki

ElemByName returns first element that has given name, nil if not found. See IndexOf for info on startIdx.

func (*Slice) ElemByNameTry ¶

func (sl *Slice) ElemByNameTry(name string, startIdx int) (Ki, error)

ElemByNameTry returns first element that has given name, error if not found. See IndexOf for info on startIdx.

func (*Slice) ElemByType ¶

func (sl *Slice) ElemByType(t reflect.Type, embeds bool, startIdx int) Ki

ElemByType returns index of element that either is that type or embeds that type, nil if not found. See IndexOf for info on startIdx.

func (*Slice) ElemByTypeTry ¶

func (sl *Slice) ElemByTypeTry(t reflect.Type, embeds bool, startIdx int) (Ki, error)

ElemByTypeTry returns index of element that either is that type or embeds that type, error if not found. See IndexOf for info on startIdx.

func (*Slice) ElemFromEnd ¶

func (sl *Slice) ElemFromEnd(idx int) Ki

ElemFromEnd returns element at index from end of slice (0 = last element, 1 = 2nd to last, etc). Panics if invalid index.

func (*Slice) ElemFromEndTry ¶

func (sl *Slice) ElemFromEndTry(idx int) (Ki, error)

ElemFromEndTry returns element at index from end of slice (0 = last element, 1 = 2nd to last, etc). Try version returns error on invalid index.

func (*Slice) ElemTry ¶

func (sl *Slice) ElemTry(idx int) (Ki, error)

ElemTry returns element at index -- Try version returns error if index is invalid.

func (*Slice) IndexByFunc ¶

func (sl *Slice) IndexByFunc(startIdx int, match func(k Ki) bool) (int, bool)

IndexByFunc finds index of item based on match function (which must return true for a find match, false for not). Returns false if not found. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Slice) IndexByName ¶

func (sl *Slice) IndexByName(name string, startIdx int) (int, bool)

IndexByName returns index of first element that has given name, false if not found. See IndexOf for info on startIdx

func (*Slice) IndexByType ¶

func (sl *Slice) IndexByType(t reflect.Type, embeds bool, startIdx int) (int, bool)

IndexByType returns index of element that either is that type or embeds that type, false if not found. See IndexOf for info on startIdx.

func (*Slice) IndexOf ¶

func (sl *Slice) IndexOf(kid Ki, startIdx int) (int, bool)

IndexOf returns index of element in list, false if not there. startIdx arg allows for optimized bidirectional find if you have an idea where it might be -- can be key speedup for large lists -- pass ki.StartMiddle to start in the middle (good default).

func (*Slice) Insert ¶

func (sl *Slice) Insert(k Ki, idx int)

Insert item at index -- does not do any parent updating etc -- use Ki/Node method unless you know what you are doing.

func (*Slice) IsValidIndex ¶

func (sl *Slice) IsValidIndex(idx int) error

IsValidIndex checks whether the given index is a valid index into slice, within range of 0..len-1. Returns error if not.

func (Slice) MarshalJSON ¶

func (sl Slice) MarshalJSON() ([]byte, error)

MarshalJSON saves the length and type, name information for each object in a slice, as a separate struct-like record at the start, followed by the structs for each element in the slice -- this allows the Unmarshal to first create all the elements and then load them

func (Slice) MarshalXML ¶

func (sl Slice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

MarshalXML saves the length and type information for each object in a slice, as a separate struct-like record at the start, followed by the structs for each element in the slice -- this allows the Unmarshal to first create all the elements and then load them

func (*Slice) Move ¶

func (sl *Slice) Move(frm, to int) error

Move element from one position to another. Returns error if either index is invalid.

func (*Slice) Swap ¶

func (sl *Slice) Swap(i, j int) error

Swap elements between positions. Returns error if either index is invalid

func (*Slice) TypeAndNames ¶

func (sl *Slice) TypeAndNames() kit.TypeAndNameList

TypeAndNames returns a kit.TypeAndNameList of elements in the slice -- useful for Ki ConfigChildren.

func (*Slice) UnmarshalJSON ¶

func (sl *Slice) UnmarshalJSON(b []byte) error

UnmarshalJSON parses the length and type information for each object in the slice, creates the new slice with those elements, and then loads based on the remaining bytes which represent each element

func (*Slice) UnmarshalXML ¶

func (sl *Slice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

UnmarshalXML parses the length and type information for each object in the slice, creates the new slice with those elements, and then loads based on the remaining bytes which represent each element

func (TravMap) End ¶ added in v1.0.2

func (tm TravMap) End(k Ki)

End deletes node once done at end of traversal

func (TravMap) Get ¶ added in v1.0.2

func (tm TravMap) Get(k Ki) (curField, curChild int)

Get retrieves current traversal state

func (TravMap) Set ¶ added in v1.0.2

func (tm TravMap) Set(k Ki, curField, curChild int)

Set updates traversal state

func (TravMap) Start ¶ added in v1.0.2

func (tm TravMap) Start(k Ki)

Start is called at start of traversal