charger.act

Class GraphUpdater

Object

charger.act.GraphUpdater

All Implemented Interfaces:

Runnable

public class GraphUpdater
extends Object
implements Runnable

Implements the actor updating ("firing") mechanism of conceptual graphs. In general, is activated by a referent change somewhere in a graph.

Author:

Harry S. Delugach ( delugach@uah.edu ) Copyright (c) 1998-2020 by Harry S. Delugach.

See Also:

CanvasPanel.userFinishedEditingText(java.lang.String)

Field Summary

Fields

Modifier and Type	Field and Description
private GNode	GNodeToUpdate
static Hashtable	GraphObjectAttributes Contains an entry for each actor consisting of a ArrayList with properties we care about.
private GraphObject	GraphObjectToUpdate
private Graph	GraphToUpdate
static Hashtable	InputSignatures Contains an entry for each actor, specifying its input concepts in order
static Hashtable	OutputSignatures Contains an entry for each actor, specifying its input concepts in order
EditFrame	ownerFrame The editframe whose canvas panel spawned this updater thread.
static Hashtable	pluginInstances key is specific charger.obj.Actor, entry is the plugin instance associated with this actor
static Hashtable	pluginRegistry key is actor name, entry is Class object corresponding to the plugin

Constructor Summary

Constructors

Constructor and Description
GraphUpdater(EditFrame ef, GraphObject go) Creates an instance of the updater for a given graph object.

Method Summary

Modifier and Type	Method and Description
static void	AddStringAsConceptType(ArrayList<Concept> cons, String s)
static void	compareGraphObjectList(ArrayList defs, ArrayList actuals, String whichList) Compares a list of graph objects to another.
static ArrayList<Concept>	createConceptList(int numberOfConcepts, String typeLabel) Convenience method for actor builders.
void	fireActor(Actor a, ArrayList inputs, ArrayList outputs) Actually "fires" the given actor.
static String[]	getActorNames() Similar to getting the concept or relation names in effect, but since the actors are all registered with Global, that's the easiest place to get them.
static String[]	getPluginList() Gets the names of all the plugins.
static boolean	hasAttribute(GraphObject go, Object attr) Checks to see if the graph object has an executable procedure associated with it.
static boolean	hasAttribute(String actorName, Object attr) Checks to see if the graph object has an executable procedure associated with it.
void	initiateActorUpdate(Actor a) Sets up an actor for execution by first seeing if it is executable and then finding its associated input and output concepts which it passes to the actual updater.
static boolean	isExecutable(Actor a) Tells whether the given actor is executable; i.e., can be activated.
void	propagate(GNode gn) Notifies this graph updater that a particular node has changed and requires updating.
static void	registerActorSignature(String actorName, ArrayList inputs, ArrayList outputs, ArrayList attributes) Records each actor's input and output signature for actor activation.
static void	registerPlugin(Class pluginClass)
static void	registerPlugins(String[] plugins) Load plugins from an array of plugin class names.
static void	registerPrimitives() Stores the signatures and attributes for all primitive actors.
void	run() Spawn an updater based on the originating node that changed.
private void	setGNode(GNode gn)
private void	setGraph(Graph g)
private void	setGraphObject(GraphObject go)
static void	shutdownAllActors() With no arguments, find all the edit frames and shut down all the actors! Note: does not shut down actors for any graph that is not in a frame.
static void	shutdownAllActors(Graph g) For a given graph, stop all its actors.
static void	startupAllActors() With no arguments, find all the edit frames and start up all the actors! Note: doesn't start up actors for any graph that is not in a frame.
static void	startupAllActors(Graph g) For a given graph, start up all its actors.
void	updateCoref(GNode gn, Coref c) If a referent is changed, then we update the referents of any coreferenced concepts.
void	updateGEdge(GEdge gn) Performs whatever update or validate routine required for the given edge.
void	updateGNode(GNode gn) Performs whatever update or validate routine required for the given node.
void	updateGraph(Graph g) For all concepts or graphs in a graph, update each of them.
void	updateGraphObject(GraphObject go) General routine for verifying/updating/validating any node.
static void	verifyActor(String actorNamePassed, ArrayList inputs, ArrayList outputs) Given an actor's actual signature, verifies that it matches the actor's definition signature.
void	WaitWhenAnimating(int milliseconds) Given any graph object on which to wait, pause the current thread for the AnimationDelay interval.

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

GraphToUpdate

private Graph GraphToUpdate

GNodeToUpdate

private GNode GNodeToUpdate

GraphObjectToUpdate

private GraphObject GraphObjectToUpdate

InputSignatures

public static Hashtable InputSignatures

Contains an entry for each actor, specifying its input concepts in order

OutputSignatures

public static Hashtable OutputSignatures

Contains an entry for each actor, specifying its input concepts in order

GraphObjectAttributes

public static Hashtable GraphObjectAttributes

Contains an entry for each actor consisting of a ArrayList with properties we care about. Valid properties (all strings) are:

"executable"	actor has an executable definition, either built-in or defined
"commutative"	order of actor's inputs and outputs does not matter
"primitive"	if a primitive, to be executed by GraphUpdater; otherwise, look for plugin
"varyingInputCardinality"	number of inputs may vary
"varyingOutputCardinality"	number of inputs may vary
"autonomous"	acts on its own, tells updaters that this actor may fire on its own, without waiting for an input to change.
"trigger"	always fire when the updater has the opportunity, regardless of actual changes.

pluginRegistry

public static Hashtable pluginRegistry

key is actor name, entry is Class object corresponding to the plugin

pluginInstances

public static Hashtable pluginInstances

key is specific charger.obj.Actor, entry is the plugin instance associated with this actor

ownerFrame

public EditFrame ownerFrame

The editframe whose canvas panel spawned this updater thread. Null if there isn't one.

Constructor Detail

GraphUpdater

public GraphUpdater(EditFrame ef,
                    GraphObject go)

Creates an instance of the updater for a given graph object.

Parameters:

ef - If the graph is in an editing window, the updater may use it (especially for animation)

go - The original object that changed, causing the need for updating. The node may not have actually changed; the updater pretends that it has.

Method Detail

run

public void run()

Spawn an updater based on the originating node that changed. Decides what component to start with and creates a thread to update actors in sequence. If there are multiple threads running, then wait until the last remaining thread is over before marking the graph as having been completely changed, then repaint the frame if there is one.

Specified by:

run in interface Runnable

setGraph

private void setGraph(Graph g)

setGNode

private void setGNode(GNode gn)

setGraphObject

private void setGraphObject(GraphObject go)

WaitWhenAnimating

public void WaitWhenAnimating(int milliseconds)

Given any graph object on which to wait, pause the current thread for the AnimationDelay interval.

Parameters:

milliseconds - the wait time between "ticks"

registerActorSignature

public static void registerActorSignature(String actorName,
                                          ArrayList inputs,
                                          ArrayList outputs,
                                          ArrayList attributes)

Records each actor's input and output signature for actor activation. Uses a clone of the signature lists so that further changes to the list don't affect it.

Parameters:

actorName - Name by which the actor will be known throughout the system

inputs - List of input concepts (or graph), each with a constraining type (or "T" )

outputs - List of output concepts (or graph), each with a constraining type (or "T")

attributes - List of strings indicating various properties of the actor

See Also:

GraphObjectAttributes

startupAllActors

public static void startupAllActors(Graph g)

For a given graph, start up all its actors. Spawn a new graph updater (attached to the graph's editing window), and fire up a new thread for that updater.

startupAllActors

public static void startupAllActors()

With no arguments, find all the edit frames and start up all the actors! Note: doesn't start up actors for any graph that is not in a frame.

shutdownAllActors

public static void shutdownAllActors(Graph g)

For a given graph, stop all its actors.

See Also:

pluginInstances

shutdownAllActors

public static void shutdownAllActors()

With no arguments, find all the edit frames and shut down all the actors! Note: does not shut down actors for any graph that is not in a frame.

propagate

public void propagate(GNode gn)
               throws CGActorException

Notifies this graph updater that a particular node has changed and requires updating.

Parameters:

gn - Node that needs updating.

Throws:

CGActorException

registerPrimitives

public static void registerPrimitives()

Stores the signatures and attributes for all primitive actors. Has no relationship whatsoever with the (in)famous Microsoft Windows "registry" or anything like it.

See Also:

registerActorSignature(java.lang.String, java.util.ArrayList, java.util.ArrayList, java.util.ArrayList), verifyActor(java.lang.String, java.util.ArrayList, java.util.ArrayList)

getPluginList

public static String[] getPluginList()

Gets the names of all the plugins. Looks first for a jar file then for a regular set of classes in a class path. Only accepts names of files that start with "actorplugin" and end with ".class" that do NOT have a '$' in them. Returns a list of names without the leading "actorplugin/" in case file separator is different.

registerPlugins

public static void registerPlugins(String[] plugins)

Load plugins from an array of plugin class names. Expects that classes will be named .class and strips extension from the name.

registerPlugin

public static void registerPlugin(Class pluginClass)

updateGraph

public void updateGraph(Graph g)

For all concepts or graphs in a graph, update each of them. Needs: to handle changes to the graph itself; e.g., referent, etc.

updateGraphObject

public void updateGraphObject(GraphObject go)

General routine for verifying/updating/validating any node. If node of any kind is changed/ready to fire/whatever, then fire any actors for which it is an input, then do something?? about actors for which it is an input...

Parameters:

go - Object to be updated, insert your own code if you want to provide behavior.

updateGNode

public void updateGNode(GNode gn)
                 throws CGActorException

Performs whatever update or validate routine required for the given node. At present only does useful work for concepts or graphs connected to actors or through a coreferent link. If a concept or graph is being updated, it does the following:

• copies this node's referent into any concepts linked via coreferent links,
• activates any actors for which this concept/graph is an OUTPUT, making sure it's consistent,
• activates any actors for which this concept/graph is an INPUT.
• tells its enclosing context if it has changed, so that outer actors can fire.

In other words, after following coreferent it goes upstream first, then downstream, then out of context.

Parameters:

gn - the node to be updated

Throws:

CGActorException

updateGEdge

public void updateGEdge(GEdge gn)
                 throws CGActorException

Performs whatever update or validate routine required for the given edge. Deleting an edge is handled by the EditFrame; this is for updating the text label. Easiest way to do this is by deleting and then re-inserting. NEEDED: When changing a line's label, re-sort the myedges of its ends! This will probably involve stopping and restarting any plugin actors affected.

Throws:

CGActorException

updateCoref

public void updateCoref(GNode gn,
                        Coref c)
                 throws CGActorException

If a referent is changed, then we update the referents of any coreferenced concepts. In a way, this may be incorrect: should MorningStar be copied to EveningStar? Certain referents ( forall, exists, etc.) aren't copied, no matter what. This is ultimately controlled by a user-selectable option "enableCopyCorefs"

Parameters:

gn - The node that was changed

c - The coref that points us to a new node that is subject to being changed.

Throws:

CGActorException

initiateActorUpdate

public void initiateActorUpdate(Actor a)
                         throws CGActorException

Sets up an actor for execution by first seeing if it is executable and then finding its associated input and output concepts which it passes to the actual updater.

Throws:

CGActorException

verifyActor

public static void verifyActor(String actorNamePassed,
                               ArrayList inputs,
                               ArrayList outputs)
                        throws CGActorException

Given an actor's actual signature, verifies that it matches the actor's definition signature. For now, also make sure that no input or output is a context; we don't handle those yet.

Parameters:

actorNamePassed - Label from actual actor that appears in graph.

inputs - The list of input concepts that appear.

outputs - The list of output concepts that appear.

Throws:

CGActorException

See Also:

compareGraphObjectList(java.util.ArrayList, java.util.ArrayList, java.lang.String)

compareGraphObjectList

public static void compareGraphObjectList(ArrayList defs,
                                          ArrayList actuals,
                                          String whichList)
                                   throws CGGraphFormationError

Compares a list of graph objects to another. Currently just checks to make sure the cardinality agrees. In the future, will also check types, referents, etc. No return; just throw a formation exception.

Parameters:

defs - Pattern list of objects

actuals - List of objects to be checked against the pattern

Throws:

CGGraphFormationError

See Also:

CGGraphFormationError

fireActor

public void fireActor(Actor a,
                      ArrayList inputs,
                      ArrayList outputs)
               throws CGActorException

Actually "fires" the given actor.

Throws:

CGActorException

See Also:

ActorPrimitive

hasAttribute

public static boolean hasAttribute(GraphObject go,
                                   Object attr)

Checks to see if the graph object has an executable procedure associated with it.

Returns:

true if the object has the attribute "executable" in its attribute ArrayList.

hasAttribute

public static boolean hasAttribute(String actorName,
                                   Object attr)

Checks to see if the graph object has an executable procedure associated with it.

Returns:

true if the object has the attribute "executable" in its attribute ArrayList.

isExecutable

public static boolean isExecutable(Actor a)

Tells whether the given actor is executable; i.e., can be activated. Not all actors are executable. If the user creates an actor from his own knowledge (i.e., outside of the list already defined in Charger) then there's nothing the system can execute. When an actor is registered, it has a list of attributes, one of which indicates whether it's executable or not.

createConceptList

public static ArrayList<Concept> createConceptList(int numberOfConcepts,
                                                   String typeLabel)

Convenience method for actor builders. Constructs a list of charger.obj.Concept suitable for use in an actor signature. If differing type labels are needed, then the concept list has to be created element by element.

Parameters:

numberOfConcepts - how many concepts desired in this list

typeLabel - what label each of the concepts will have.

Returns:

ArrayList of charger.obj.Concept instances, all with the same type label

See Also:

ActorPlugin.getPluginActorInputConceptList(), ActorPlugin.getPluginActorOutputConceptList()

AddStringAsConceptType

public static void AddStringAsConceptType(ArrayList<Concept> cons,
                                          String s)

getActorNames

public static String[] getActorNames()

Similar to getting the concept or relation names in effect, but since the actors are all registered with Global, that's the easiest place to get them.

Returns:

possibly empty list of actor types, sorted according to name