Uses of Class
org.qdl_lang.state.State

Packages that use State

Package	Description
org.qdl_lang.config	All things relating to the QDL configuration file.
org.qdl_lang.evaluate	Evaluators evaluate the built-in functions for QDL as well as perform the usual algebraic operations.
org.qdl_lang.expressions	Expressions are objects that take zero or more arguments and return a result.
org.qdl_lang.expressions.module	Classes that model and manage modules in QDL.
org.qdl_lang.extensions	This contains the classes for extending the QDL language with Java.
org.qdl_lang.extensions.convert	The conversion module.
org.qdl_lang.extensions.crypto	The cryptographic module.
org.qdl_lang.extensions.database	QDL's basic database module.
org.qdl_lang.extensions.dynamodb
org.qdl_lang.extensions.examples.basic	This package contains a simple basic of how to make a java module for QDL.
org.qdl_lang.extensions.examples.stateful
org.qdl_lang.extensions.http	HTTP access module for QDL.
org.qdl_lang.extensions.inputLine	QDL's module for processing command line arguments.
org.qdl_lang.extensions.mail
org.qdl_lang.extensions.X509
org.qdl_lang.functions	Function handling and processing.
org.qdl_lang.gui	Swing terminal implementation.
org.qdl_lang.parsing	Classes that support parsing and the parser itself.
org.qdl_lang.sas	QDL implementation of the NCSA Security Library's SAS.
org.qdl_lang.state	Classes that manage the state of an interpreter session.
org.qdl_lang.statements	The two basic syntactic units of QDL are expressions (which return results) and statements which are the other control structures, such as conditionals, loops, etc.
org.qdl_lang.util	Utilities for QDL.
org.qdl_lang.variables	Variables in QDL and classes that support them.
org.qdl_lang.workspace	The workspace and the commands that drive it.
org.qdl_lang.xml	Everything relating to serialization of QDL workspaces to/from XML.

Uses of State in org.qdl_lang.config

Methods in org.qdl_lang.config with parameters of type State

Modifier and Type	Method	Description
static String	QDLConfigurationLoaderUtils.runBootScript(QDLEnvironment config, State state)
static List<String>	QDLConfigurationLoaderUtils.setupJavaModule(State state, QDLLoader loader, JavaModuleConfig jmc)
static String[]	QDLConfigurationLoaderUtils.setupModules(QDLEnvironment config, State state)
static void	QDLConfigurationLoaderUtils.setupVFS(QDLEnvironment config, State state)

Uses of State in org.qdl_lang.evaluate

Methods in org.qdl_lang.evaluate with parameters of type State

Modifier and Type	Method	Description
protected QDLSet	OpEvaluator.applyToSet(QDLStem lArg, QDLSet rArg, QDLValue defaultValue, State state, Dyad dyad)
protected QDLStem	OpEvaluator.applyToStem(QDLStem lArg, QDLStem rArg, QDLValue defaultValue, State state, Dyad dyad)
protected Object	ListEvaluator.checkCopyNode(ExpressionInterface expr, State state, boolean doInsert)
protected boolean	SystemEvaluator.checkDefined(ExpressionInterface exp, State state)
protected QDLStem	SystemEvaluator.checkDefined(StemListNode stemListNode, State state)
protected QDLStem	SystemEvaluator.checkDefined(StemVariableNode stemVariableNode, State state)
protected Boolean	FunctionEvaluator.checkIsFunction(String fName, int argCount, State state)
static void	AbstractEvaluator.checkNull(Object arg1, ExpressionInterface swri, State state)	Check for Java nulls and logs any errors
protected FStack	ModuleEvaluator.cloneIntrinsicFunctions(State state)
protected VStack	ModuleEvaluator.cloneIntrinsicVariables(State state)
protected QDLStem	AbstractEvaluator.convertArgsToStem(Polyad polyad, Object arg, State state, String component)	Converts a couple of different arguments to the form [[a0{,b0}],[a1{,b1}],...,[an{,bn}] or (if a single argument that is a stem) can pass back:
abstract boolean	AbstractEvaluator.dispatch(Polyad polyad, State state)	Does the actual evaluation of the Polyad.
boolean	FunctionEvaluator.dispatch(Polyad polyad, State state)
boolean	IOEvaluator.dispatch(Polyad polyad, State state)
boolean	ListEvaluator.dispatch(Polyad polyad, State state)
boolean	MathEvaluator.dispatch(Polyad polyad, State state)
boolean	MetaEvaluator.dispatch(Polyad polyad, State state)
boolean	ModuleEvaluator.dispatch(Polyad polyad, State state)
boolean	OpEvaluator.dispatch(Polyad polyad, State state)
boolean	StemEvaluator.dispatch(Polyad polyad, State state)
boolean	StringEvaluator.dispatch(Polyad polyad, State state)
boolean	SystemEvaluator.dispatch(Polyad polyad, State state)
boolean	TMathEvaluator.dispatch(Polyad polyad, State state)
protected void	MathEvaluator.doAbs(Polyad polyad, State state)
protected void	StringEvaluator.doCaput(Polyad polyad, State state)
protected void	StemEvaluator.doCommonKeys(Polyad polyad, State state)	common_keys(stem1., stem2.) Return a list of keys common to both stems.
protected void	SystemEvaluator.doConstants(Polyad polyad, State state)
protected void	StringEvaluator.doContains(Polyad polyad, State state)
protected void	OpEvaluator.doContainsKey(Dyad dyad, State state, boolean containsKey)
protected void	MathEvaluator.doDates(Polyad polyad, State state, boolean isInMillis)
protected void	StringEvaluator.doDetokeninze(Polyad polyad, State state)
protected void	StringEvaluator.doDiff(Polyad polyad, State state)
protected void	IOEvaluator.doDir(Polyad polyad, State state)	Quick note.
protected void	OpEvaluator.doDyadComparisonOperator(Dyad dyad, State state)
protected void	OpEvaluator.doDyadEqualsOperator(Dyad dyad, State state)
protected void	OpEvaluator.doDyadIntegerDivide(Dyad dyad, State state)
protected void	OpEvaluator.doDyadLogicalOperator(Dyad dyad, State state)
protected void	OpEvaluator.doDyadMinus(Dyad dyad, State state)
protected void	OpEvaluator.doDyadPlus(Dyad dyad, State state)	For dyadic plus.
protected void	OpEvaluator.doDyadTimesOrDivide(Dyad dyad, State state, boolean doTimes)
protected void	StemEvaluator.doExcludeKeys(Polyad polyad, State state)	exclude_keys(stem., var | list.) remove all the keys in list.
protected void	StemEvaluator.doForEach(Polyad polyad, State state)	Apply n-ary function to outer product of stems.
protected void	SystemEvaluator.doFork(Polyad polyad, State state)	Run a script in its own thread.
protected void	StemEvaluator.doFromJSON(Polyad polyad, State state)
protected void	FunctionEvaluator.doFunctionEvaluation(Polyad polyad, State state, FR_WithState frs)	Executes a user-defined function, defined in QDL., E.g.
protected void	MathEvaluator.doHash(Polyad polyad, State state)
protected void	StemEvaluator.doHasKey(Polyad polyad, State state)	has_keys(key | keysList., arg.) returns left conformable result if the key or keylist.
protected void	StemEvaluator.doHasKeys(Polyad polyad, State state)	This is not left conformable and any uses should be removed in favor of StemEvaluator.doHasKey(Polyad, State)
protected void	MathEvaluator.doIdentityFunction(Polyad polyad, State state)	The identity function returns its argument.
protected void	ModuleEvaluator.doImport(Polyad polyad, State state)	Eithjer import(string) - namespace import(string, mode) - mode is a string or integer returns the instance of the module.
protected void	StemEvaluator.doIncludeKeys(Polyad polyad, State state)	include_keys(stem., var | list.); include keys on the right in the resulting stem
protected void	StringEvaluator.doIndexOf(Polyad polyad, State state)
protected void	StemEvaluator.doIndices(Polyad polyad, State state)
protected void	StringEvaluator.doInsert(Polyad polyad, State state)
protected void	SystemEvaluator.doInterpret(Polyad polyad, State state)
protected void	OpEvaluator.doIsDefinedDyad(Dyad dyad, State state, boolean isDefined)
protected void	FunctionEvaluator.doIsFunction(Polyad polyad, State state)
protected void	StemEvaluator.doIsList(Polyad polyad, State state)
protected void	StemEvaluator.doIsMemberOf(Polyad polyad, State state)	Compute if the left argument is a member of the right argument.
protected void	FunctionEvaluator.doJavaFunction(Polyad polyad, State state, FR_WithState frs)	Executes a user-defined function, defined in Java as an implementation of QDLFunction.
protected void	StemEvaluator.doJoin(Polyad polyad, State state)
protected void	StemEvaluator.doJPathQuery(Polyad polyad, State state)
protected void	StemEvaluator.doKeys(Polyad polyad, State state)	Return a stem of nothing key the keys, possibly filtering, so the final stem is of the form
protected void	SystemEvaluator.doKillProcess(Polyad polyad, State state)
protected void	ListEvaluator.doListCopyOrInsert(Polyad polyad, State state, boolean doInsert)
protected void	StemEvaluator.doListKeys(Polyad polyad, State state)	Returns the keys in a stem as a list, filtering if wanted.
protected void	ListEvaluator.doListReverse(Polyad polyad, State state)
protected void	ListEvaluator.doListSort(Polyad polyad, State state)	Always returns a sorted list.
protected void	ListEvaluator.doListStartsWith(Polyad polyad, State state)	Returns a list of indices.
protected boolean	ListEvaluator.doListSubset(Polyad polyad, State state)
protected void	ModuleEvaluator.doLoad(Polyad polyad, State state)	Contract is that the type as an explicit argument is no longer required.
protected void	SystemEvaluator.doLoadModule(Polyad polyad, State state)
protected void	StemEvaluator.doMakeIndex(Polyad polyad, State state)
protected void	StemEvaluator.doMask(Polyad polyad, State state)
protected void	MathEvaluator.doMax(Polyad polyad, State state)
protected void	MathEvaluator.doMin(Polyad polyad, State state)
protected void	MathEvaluator.doMinOrMax(Polyad polyad, State state, boolean isMax)
protected void	IOEvaluator.doMkDir(Polyad polyad, State state)
protected void	SystemEvaluator.doModuleImport(Polyad polyad, State state)	The general contract for import.
protected void	SystemEvaluator.doModulePaths(Polyad polyad, State state)
protected void	MathEvaluator.doModulus(Polyad polyad, State state)	Compute the modulus of two numbers, i.e.
protected void	OpEvaluator.doMonadicTilde(Monad monad, State state, boolean isStile)
protected void	OpEvaluator.doMonadIncOrDec(Monad monad, State state, boolean isPlusPlus)	NOTE that at this point this only works for single variables -- you can't apply this to a stem.
protected void	OpEvaluator.doMonadMinus(Monad monad, State state)
protected void	OpEvaluator.doMonadNot(Monad monad, State state)
protected void	OpEvaluator.doMonadPlus(Monad monad, State state)
protected void	SystemEvaluator.doNewLoadModule(Polyad polyad, State state)
protected void	MathEvaluator.doNumericDigits(Polyad polyad, State state)
protected void	StringEvaluator.doOldReplace(Polyad polyad, State state)
protected void	SystemEvaluator.doOSEnv(Polyad polyad, State state)
protected boolean	ListEvaluator.doPickSubset(Polyad polyad, State state)	Pick elements based on a function that is supplied.
protected void	SystemEvaluator.doRaiseError(Polyad polyad, State state)
protected void	MathEvaluator.doRandom(Polyad polyad, State state)
protected void	MathEvaluator.doRandomString(Polyad polyad, State state)
protected void	IOEvaluator.doReadFile(Polyad polyad, State state)
protected void	OpEvaluator.doRegexMatch(Dyad dyad, State state)	Contract is expression regex ≈ expression returns true if it matches expression as a string.
protected void	StemEvaluator.doRemove(Polyad polyad, State state)	Remove the entire variable from the symbol table.
protected void	StemEvaluator.doRenameKeys(Polyad polyad, State state)	rename_keys(arg., indices.); list.
protected void	StringEvaluator.doReplace(Polyad polyad, State state)
protected QDLSet	StringEvaluator.doReplace(Polyad polyad, QDLSet<QDLValue> inSet, QDLStem replacements, QDLStem regexStem, State state)
protected QDLStem	StringEvaluator.doReplace(Polyad polyad, QDLStem inStem, QDLStem replacements, QDLStem regexStem, State state)	Do replace where there is an arbitrary stem and a stem of replacements and regexes The keys for the replacements and regexes correspond, and the replacements happen to every elements if inStem, the target of the replacement.
protected void	SystemEvaluator.doReturn(Polyad polyad, State state)
protected void	IOEvaluator.doRMDir(Polyad polyad, State state)
protected void	IOEvaluator.doRMFile(Polyad polyad, State state)
protected void	SystemEvaluator.doSay(Polyad polyad, State state, boolean printIt)	Does print, say and to_string commands.
protected void	IOEvaluator.doScan(Polyad polyad, State state)
protected void	SystemEvaluator.doScriptArgs(Polyad polyad, State state)	This will return a given script arg for a given index.
protected void	SystemEvaluator.doScriptArgs2(Polyad polyad, State state)	New function for script arguments.
protected void	SystemEvaluator.doScriptPaths(Polyad polyad, State state)	This accepts either a stem of paths or a single string that is parsed.
protected void	SystemEvaluator.doSendInterrupt(Polyad polyad, State state)
protected void	StemEvaluator.doSetDefault(Polyad polyad, State state)	Sets the default value for a stem.
protected void	OpEvaluator.doSetUnionOrInteresection(Dyad dyad, State state)
protected void	StemEvaluator.doShuffle(Polyad polyad, State state)	Permute the elements in a stem.
protected Object	OpEvaluator.doSingleApply(QDLValue lArg, DyadicFunctionReferenceNode fNode, QDLValue defaultValue, State state, Dyad dyad)
protected QDLValue	OpEvaluator.doSingleApply(QDLValue lArg, FunctionReferenceNode fNode, State actualState)
protected Object	OpEvaluator.doSingleApply(QDLValue lArg, FunctionReferenceNode fNode, QDLValue defaultValue, State state, Dyad dyad)	apply the argument to a single function.
protected void	StemEvaluator.doSize(Polyad polyad, State state)
protected void	StringEvaluator.doSubstring(Polyad polyad, State state)
protected void	StringEvaluator.doSwapCase(Polyad polyad, State state, boolean isLower)
protected void	SystemEvaluator.doSysInfo(Polyad polyad, State state)
protected void	StringEvaluator.doTail(Polyad polyad, State state)
protected void	OpEvaluator.doTilde(Dyad dyad, State state)
protected void	StemEvaluator.doToJSON(Polyad polyad, State state)
protected void	StringEvaluator.doTokenize(Polyad polyad, State state)
protected void	StemEvaluator.doTransform(Polyad polyad, State state)
protected void	StringEvaluator.doTrim(Polyad polyad, State state)
protected void	OpEvaluator.doUnaryPlusMinus(Monad monad, State state, Long sign)	This will evaluate the expression and take its opposite.
protected void	ModuleEvaluator.doUse(Polyad polyad, State state)
protected void	StemEvaluator.doValues(Polyad polyad, State state)
void	SystemEvaluator.doVarType(Polyad polyad, State state)	Get the type of the argument.
protected void	IOEvaluator.doWriteFile(Polyad polyad, State state)
boolean	AbstractEvaluator.evaluate(String alias, Polyad polyad, State state)
boolean	AbstractEvaluator.evaluate(Polyad polyad, State state)	Decides if a Polyad is evaluated by this evaluator and if not, returns false, if so, it evaluates it and returns true.
boolean	FunctionEvaluator.evaluate(String alias, Polyad polyad, State state)
boolean	FunctionEvaluator.evaluate(Polyad polyad, State state)
boolean	MetaEvaluator.evaluate(String alias, Polyad polyad, State state)
boolean	MetaEvaluator.evaluate(Polyad polyad, State state)
void	OpEvaluator.evaluate(Dyad dyad, State state)
void	OpEvaluator.evaluate(Monad monad, State state)
void	OpEvaluator.evaluate(Nilad nilad, State state)
boolean	OpEvaluator.evaluate(Polyad polyad, State state)
void	OpEvaluator.evaluate2(Dyad dyad, State state)
void	OpEvaluator.evaluate2(Monad monad, State state)
boolean	MetaEvaluator.evaluateNEW(Polyad polyad, State state)	Proposed method to allow for overriding base system functions.
protected Object	OpEvaluator.evaluateNextArgForApplies(QDLValue lArg, Object rArg, QDLValue defaultValue, State state, Dyad dyad)
boolean	MetaEvaluator.evaluateOLD(Polyad polyad, State state)
protected void	FunctionEvaluator.figureOutEvaluation(Polyad polyad, State state, boolean checkForDuplicates)
protected QDLValue	StemEvaluator.forEachEval(ExpressionImpl f, State state, List<QDLValue> args)
protected void	StemEvaluator.forEachRecursion(QDLStem output, ExpressionImpl f, State state, QDLValue[] args, IndexList indexList, ArrayList<QDLValue> values, int currentIndex)
protected void	StemEvaluator.forEachRecursion2(QDLStem output, ExpressionImpl f, State state, QDLValue[] args, IndexList indexList, ArrayList<QDLValue> values, int currentIndex)
protected String	ModuleEvaluator.getClassPathFromToolPath(List<String> toolPath, State state)
protected void	SystemEvaluator.getConst(Polyad polyad, State state, QDLStem values)
protected FunctionReferenceNodeInterface	AbstractEvaluator.getFunctionReferenceNode(State state, ExpressionInterface arg0)
FunctionReferenceNodeInterface	AbstractEvaluator.getFunctionReferenceNode(State state, ExpressionInterface arg0, boolean pushNewState)
static ExpressionImpl	AbstractEvaluator.getOperator(State state, FunctionReferenceNodeInterface frNode, int nAry)	get a polyad or dyad (for the operator) from the FunctionReferenceNode.
protected QDLStem	AbstractEvaluator.getOrCreateStem(ExpressionInterface node, State state, String informativeMessage)	This will take an ExpressionImpl that should contain a stem, check the reference and it the stem does not exist, create and put it in the symbol table.
protected void	SystemEvaluator.isDefined(Polyad polyad, State state)
protected void	SystemEvaluator.loadScript(Polyad polyad, State state)
protected static ExpressionImpl	AbstractEvaluator.NEWgetOperator(State state, FunctionReferenceNodeInterface frNode, int nAry)
protected static ExpressionImpl	AbstractEvaluator.OLDgetOperator(State state, FunctionReferenceNodeInterface frNode, int nAry)
static void	AbstractEvaluator.process1(ExpressionImpl polyad, AbstractEvaluator.fPointer pointer, String name, State state)	Main workhorse for monadic system functions.
static void	AbstractEvaluator.process2(ExpressionImpl polyad, AbstractEvaluator.fPointer pointer, String name, State state)	Main workhorse method of evaluating a QDL dyadic system function.
static void	AbstractEvaluator.process2(ExpressionImpl polyad, AbstractEvaluator.fPointer pointer, String name, State state, boolean optionalArgs)	Note
static void	AbstractEvaluator.process3(ExpressionImpl polyad, AbstractEvaluator.fPointer pointer, String name, State state, boolean optionalArguments)	Main workhorse for evaluating QDL system valence 3 functions.
protected QDLStem	IOEvaluator.processWriteFileStem(QDLStem input, State state, Polyad polyad)
protected QDLStem	IOEvaluator.readFileStem(QDLStem input, QDLStem types, Long defaultType, State state, Polyad polyad)
protected Object	IOEvaluator.readSingleFile(String fileName, Long type, State state, Polyad polyad)
protected ArrayList<XThing>	FunctionEvaluator.resolveArguments(FunctionRecordInterface functionRecord, Polyad polyad, State state, State localState)	This will take the function record and polyad and find the arguments that are requested in the function record vs.
VFSEntry	AbstractEvaluator.resolveResourceToFile(String resourceName, int type, State state)	This will look at the resource name and decide if it is in a VFS and resolve it against that.
static QDLScript	SystemEvaluator.resolveScript(String name, List<String> paths, State state)	This will use the path information and try to resolve the script based on that.
static int	SystemEvaluator.runnit(Polyad polyad, State state, boolean hasNewState)
static int	SystemEvaluator.runnit(Polyad polyad, State state, List<String> paths, boolean hasNewState, boolean newThread)
protected void	SystemEvaluator.runScript(Polyad polyad, State state)	Run an external qdl script with its own state.
protected InterruptException	SystemEvaluator.startHalt(Polyad polyad, State state)
static String	AbstractEvaluator.tempFname(State state)	Create an unused name for a function.
protected boolean	FunctionEvaluator.tryScript(Polyad polyad, State state)
protected void	IOEvaluator.vfsMount(Polyad polyad, State state)
protected void	IOEvaluator.vfsUnmount(Polyad polyad, State state)
protected void	IOEvaluator.writeSingleFile(String fileName, QDLValue content, int fileType, State state, Polyad polyad)

Constructors in org.qdl_lang.evaluate with parameters of type State

Constructor	Description
ARForEachImpl(ExpressionImpl f, State state, int axis)
AxisExpand(ExpressionImpl operator, State state)
AxisReduce(ExpressionImpl operator, State state)
ReduceAll(ExpressionImpl f, State state)

Uses of State in org.qdl_lang.expressions

Methods in org.qdl_lang.expressions that return State

Modifier and Type	Method	Description
State	ModuleExpression.getAmbientState()
State	ModuleExpression.getLocalState(State state)
State	ModuleExpression.getModuleState()
State	ModuleExpression.getModuleState(State state)	The state of the current module only.

Methods in org.qdl_lang.expressions with parameters of type State

Modifier and Type	Method	Description
boolean	IndexArgs.add(IndexArg indexArg, State state)
protected IndexArgs	StemExtractionNode.checkIfAlreadyLinearized(State state)
protected IndexArgs	IndexArgs.checkIfList(IndexArg indexArg, State state)
Collection<? extends QDLKey>	IndexArg.createKeySet(QDLStem in, State state)
protected Object	ExpressionStemNode.doLeftSVCase(ExpressionInterface leftArg, List<ExpressionInterface> indices, State state)	Case that the left hand argument is a stem variable.
protected Object	ExpressionStemNode.doLeftSVCase(ExpressionInterface leftArg, ExpressionInterface rightArg, State state)
QDLValue	ExpressionImpl.evalArg(int index, State state)
QDLValue	ExpressionImpl.evalLastArg(State state)
QDLValue	AltIfExpressionNode.evaluate(State state)
QDLValue	ANode2.evaluate(State state)
QDLValue	AxisExpression.evaluate(State state)
QDLValue	ClosedSliceNode.evaluate(State state)
QDLValue	ComparisonDyad.evaluate(State state)
QDLValue	ConstantNode.evaluate(State state)
QDLValue	Dyad.evaluate(State state)
QDLValue	ESN2.evaluate(State state)
QDLValue	ExpressionStemNode.evaluate(State state)	Since this is a dyadic operation in the parser, the result will be a tree of objects of the form
QDLValue	ModuleExpression.evaluate(State ambientState)
QDLValue	Monad.evaluate(State state)
QDLValue	Nilad.evaluate(State state)
QDLValue	OpenSliceNode.evaluate(State state)
QDLValue	ParenthesizedExpression.evaluate(State state)
QDLValue	Polyad.evaluate(State state)
QDLValue	SelectExpressionNode.evaluate(State state)
QDLValue	StemExtractionNode.evaluate(State state)
QDLValue	VariableNode.evaluate(State state)
List<QDLValue>	ExpressionImpl.evaluatedArgs(State state)	Evaluate the arguments using the given state and set the ExpressionImpl.setEvaluatedArgs(List) Calling this evaluates the args.
protected QDLValue	ESN2.get(State state)
State	ModuleExpression.getLocalState(State state)
State	ModuleExpression.getModuleState(State state)	The state of the current module only.
protected QDLValue	ExpressionStemNode.getOrSetValue(State state, boolean setValue, QDLValue newValue)
protected QDLValue	ComparisonDyad.handleEquals(State state)	In this case, we have A == B or A != B.
protected List<IndexArg>	StemExtractionNode.linearize(State state)	Start linearizing the tree.
protected IndexArgs	StemExtractionNode.linearizeLeftArgs(List<IndexArg> indices, State state)	Some parts of parse trees are left balanced, not right.
protected QDLValue	ComparisonDyad.newEvaluate(State state)
protected QDLValue	StemExtractionNode.recurse(QDLStem in, IndexArgs sourceIndices, State state)	Starts descent through all of the nodes
protected Object	StemExtractionNode.recurse(QDLStem in, QDLStem out, IndexList targetIndex, List<IndexArg> sourceIndices, int indexLocation, long strictIndex, State state)
boolean	ESN2.remove(State state)
void	ESN2.set(State state, QDLValue newValue)
void	ModuleExpression.set(State state, Object newValue)	Set the value of this expression using the state
void	ModuleExpression.setAmbientState(State ambientState)
void	ModuleExpression.setModuleState(State moduleState)
QDLValue	ExpressionStemNode.setValue(State state, QDLValue newValue)
protected void	ANode2.setValueFromSWRI(ExpressionInterface swri, Object value, Object i, State state)

Uses of State in org.qdl_lang.expressions.module

Methods in org.qdl_lang.expressions.module that return State

Modifier and Type	Method	Description
State	Module.getState()

Methods in org.qdl_lang.expressions.module with parameters of type State

Modifier and Type	Method	Description
XStack	MIStack.getStateStack(State state)
XStack	MTStack.getStateStack(State state)
abstract Module	Module.newInstance(State state)	Modules are effectively templates.
Module	QDLModule.newInstance(State state)
void	Module.setState(State state)
void	MIStack.setStateStack(State state, XStack xStack)
void	MTStack.setStateStack(State state, XStack xStack)

Constructors in org.qdl_lang.expressions.module with parameters of type State

Constructor	Description
Module(URI namespace, String alias, State state)
Module(URI namespace, State state)

Uses of State in org.qdl_lang.extensions

Methods in org.qdl_lang.extensions with parameters of type State

Modifier and Type	Method	Description
QDLValue	QDLFunction.evaluate(QDLValue[] qdlValues, State state)	The method that is invoked by QDL that is the function.
void	JavaModule.init(State state)	This is critical in that it puts all the functions and variables (with their correct alias) in to the state for this module.
void	JavaModule.init(State state, boolean doVariables)

Uses of State in org.qdl_lang.extensions.convert

Methods in org.qdl_lang.extensions.convert with parameters of type State

Modifier and Type	Method	Description
QDLValue	QDLConvert.GetAttributes.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.HOCONExport.evaluate(QDLValue[] objects, State state)
QDLValue	QDLConvert.HOCONImport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.IniExport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.IniImport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.QDLExport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.QDLImport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.Snarf.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.XMLExport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.XMLImport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.YAMLExport.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLConvert.YAMLImport.evaluate(QDLValue[] qdlValues, State state)
protected String	QDLConvert.getFileArg(Object object, State state, String name)	This will look into the object if it is a stem or string and determine if there is a file to import.
protected Object	QDLConvert.XMLImport.newEvaluate(QDLValue[] qdlValues, State state)
protected Object	QDLConvert.XMLImport.newEvaluate2(Object[] objects, State state)	Uses XML to JSON (Jackson, actually) serialization.
Module	QDLConvertModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.crypto

Methods in org.qdl_lang.extensions.crypto with parameters of type State

Modifier and Type	Method	Description
QDLValue	Crypto.B64ToHex.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.B64ToInt.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.CodeChallenge.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.CreateKey.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.Decrypt.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.Encrypt.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.ExportKeys.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.FromJWT.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.GetPublicKey.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.HexToB64.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.HexToInt.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.ImportKey.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.IntToBase64.evaluate(QDLValue[] qdlValues, State state)	Take a Long or exact BigDecimal and turn the bytes into a base 64 representation.
QDLValue	Crypto.IntToHex.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.ReadCert.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.ReadOID.evaluate(QDLValue[] qdlValues, State state)
QDLValue	Crypto.ToJWT.evaluate(QDLValue[] objects, State state)
QDLValue	Crypto.VerifyJWT.evaluate(QDLValue[] qdlValues, State state)
protected Object	Crypto.exportJWKS(QDLValue[] qdlValues, State state)	Does the actual work of exporting a JWKS set.
protected Object	Crypto.exportPKCS(QDLValue[] qdlValues, State state)	Does the actual work or exporting various PKCS files.
Object	Crypto.importJWKS(QDLValue[] qdlValues, State state)
Object	Crypto.importPKCS(QDLValue[] qdlValues, State state)
Module	CryptoModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.database

Methods in org.qdl_lang.extensions.database with parameters of type State

Modifier and Type	Method	Description
QDLValue	QDLDB.BatchExecute.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLDB.BatchRead.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLDB.Connect.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLDB.Execute.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLDB.Read.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLDB.Update.evaluate(QDLValue[] qdlValues, State state)
Module	QDLDBModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.dynamodb

Methods in org.qdl_lang.extensions.dynamodb with parameters of type State

Modifier and Type	Method	Description
QDLValue	DynamoDB.Close.evaluate(QDLValue[] qdlValues, State state)
QDLValue	DynamoDB.Get.evaluate(QDLValue[] objects, State state)
QDLValue	DynamoDB.Open.evaluate(QDLValue[] qdlValues, State state)
QDLValue	DynamoDB.PartitionKeyFunction.evaluate(QDLValue[] qdlValues, State state)
QDLValue	DynamoDB.RegionFunction.evaluate(QDLValue[] qdlValues, State state)
QDLValue	DynamoDB.Regions.evaluate(QDLValue[] qdlValues, State state)
QDLValue	DynamoDB.TableNameFunction.evaluate(QDLValue[] qdlValues, State state)
Module	QDLDynamoDBModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.examples.basic

Methods in org.qdl_lang.extensions.examples.basic with parameters of type State

Modifier and Type	Method	Description
QDLValue	ConcatFunction.evaluate(QDLValue[] qdlValues, State state)
QDLValue	ExtrinsicFunction.evaluate(QDLValue[] objects, State state)
QDLValue	FEvalFunction.evaluate(QDLValue[] qdlValues, State state)
Module	EGModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.examples.stateful

Methods in org.qdl_lang.extensions.examples.stateful with parameters of type State

Modifier and Type	Method	Description
QDLValue	StatefulExample.GetS.evaluate(QDLValue[] qdlValues, State state)
QDLValue	StatefulExample.SetS.evaluate(QDLValue[] qdlValues, State state)
Module	StatefulModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.http

Methods in org.qdl_lang.extensions.http with parameters of type State

Modifier and Type	Method	Description
QDLValue	HTTPClient.doPostOrPut(QDLValue[] qdlValues, State state, boolean isPost)
QDLValue	HTTPClient.Close.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Configuration.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.CreateCredentials.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Delete.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Download.evaluate(QDLValue[] objects, State state)
QDLValue	HTTPClient.EchoHTTPRequest.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.EchoHTTPResponse.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Get.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Headers.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Host.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.IsJSON.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.IsOpen.evaluate(QDLValue[] objects, State state)
QDLValue	HTTPClient.IsText.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Open.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Post.evaluate(QDLValue[] qdlValues, State state)
QDLValue	HTTPClient.Put.evaluate(QDLValue[] qdlValues, State state)
Module	QDLHTTPModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.inputLine

Methods in org.qdl_lang.extensions.inputLine with parameters of type State

Modifier and Type	Method	Description
QDLValue	QDLCLITools.ToStem.evaluate(QDLValue[] qdlValues, State state)
Module	QDLCLIToolsModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.mail

Methods in org.qdl_lang.extensions.mail with parameters of type State

Modifier and Type	Method	Description
QDLValue	QDLMail.Send.evaluate(QDLValue[] qdlValues, State state)
QDLValue	QDLMail.SetCfg.evaluate(QDLValue[] qdlValues, State state)
Module	QDLMailModule.newInstance(State state)

Uses of State in org.qdl_lang.extensions.X509

Methods in org.qdl_lang.extensions.X509 with parameters of type State

Modifier and Type	Method	Description
QDLValue	X509.LoadKeystore.evaluate(QDLValue[] qdlValues, State state)
Module	QDL509Module.newInstance(State state)

Uses of State in org.qdl_lang.functions

Methods in org.qdl_lang.functions that return State

Modifier and Type	Method	Description
State	DyadicFunctionReferenceNode.getModuleState()
State	FunctionReferenceNode.getModuleState()
State	FunctionReferenceNodeInterface.getModuleState()

Methods in org.qdl_lang.functions with parameters of type State

Modifier and Type	Method	Description
QDLValue	DyadicFunctionReferenceNode.evaluate(State state)
QDLValue	FunctionDefinitionStatement.evaluate(State state)
QDLValue	FunctionReferenceNode.evaluate(State state)
QDLValue	LambdaDefinitionNode.evaluate(State state)
protected FunctionRecord	DyadicFunctionReferenceNode.getFRByArgCount(State state, int argCount, String functionName)
XStack	FStack.getStateStack(State state)
void	DyadicFunctionReferenceNode.setModuleState(State moduleState)
void	FunctionReferenceNode.setModuleState(State moduleState)
void	FunctionReferenceNodeInterface.setModuleState(State moduleState)
void	FStack.setStateStack(State state, XStack xStack)

Uses of State in org.qdl_lang.gui

Methods in org.qdl_lang.gui with parameters of type State

Modifier and Type	Method	Description
static org.fife.ui.autocomplete.DefaultCompletionProvider	QDLSwingUtil.createCompletionProvider(State state)	Create the auto completion provider with a given state object.

Uses of State in org.qdl_lang.parsing

Methods in org.qdl_lang.parsing that return State

Modifier and Type	Method	Description
State	QDLInterpreter.getState()
State	QDLRunner.getState()

Methods in org.qdl_lang.parsing with parameters of type State

Modifier and Type	Method	Description
QDLValue	ParseExpressionBlockNode.evaluate(State state)
QDLValue	ParseStatementBlock.evaluate(State state)
protected QDLParserParser	QDLParserDriver.getParser(Reader reader, State state)
protected QDLParserParser	QDLParserDriver.getParser2(InputStream inputStream, State state)
protected void	QDLRunner.run(int startIndex, State currentState, boolean startProcess, SIInterrupts siInterrupts, boolean noInterrupt)
void	QDLRunner.setState(State state)	You may inject state at runtime if you need this to start with some existing state.

Constructors in org.qdl_lang.parsing with parameters of type State

Constructor	Description
QDLInterpreter(edu.uiuc.ncsa.security.core.configuration.XProperties environment, State state)
QDLInterpreter(State state)
QDLListener(ParsingMap parsingMap, State state)	Note that the state is supplied here not for evaluation, but because it has the evaluators needed to resolve the various values of operators that are being produced by the parser.
QDLParserDriver(edu.uiuc.ncsa.security.core.configuration.XProperties environment, State state)

Uses of State in org.qdl_lang.sas

Methods in org.qdl_lang.sas that return State

Modifier and Type	Method	Description
State	QDLExe.createState()

Uses of State in org.qdl_lang.state

Fields in org.qdl_lang.state declared as State

Modifier and Type	Field	Description
State	SIEntry.state

Methods in org.qdl_lang.state that return State

Modifier and Type	Method	Description
static State	StateUtils.clone(State state)	Take the current state and make a complete copy of it.
abstract State	StateUtils.create()
static State	State.getFactory()
static State	State.getRootState()	At system startup this is set to be the top-level state object for the system.
State	AbstractState.getSuperState()	Superstate is used in modules, functions, scripts etc.
State	State.getTargetState()	The target state is used in cases where argument lists are processed.
static State	StateUtils.javaClone(State state)
static State	StateUtils.load(InputStream inputStream)	See note on StateUtils.load(State, XMLEventReader)
static State	StateUtils.load(XMLEventReader xer)
static State	StateUtils.load(State state, XMLEventReader xer)	Read in the state from an even reader.
static State	StateUtils.load(State state, SerializationState SerializationState, XMLEventReader xer)
static State	StateUtils.loadb64(String encodedState)	Deserialize the state from a base 64 encoded string.
State	State.newCleanState()	This creates a completely clean state, using the current environment (so modules and script paths, but not variables, modules etc.) and preserves debugging
State	State.newFunctionState()	Carries over modules and functions, but not variables.
State	State.newInstance()	A new instance with the default components.
State	State.newInstance(VStack symbolStack, OpEvaluator opEvaluator, MetaEvaluator metaEvaluator, FStack<? extends FTable<? extends FKey,? extends FunctionRecordInterface>> ftStack, MTStack mtStack, MIStack miStack, edu.uiuc.ncsa.security.core.util.MyLoggingFacade myLoggingFacade, boolean isServerMode, boolean isRestrictedIO, boolean assertionsOn)	If you extend this class, you must override this method to return a new instance of your state with everything in it you want or need.
static State	StateUtils.newInstance()
State	State.newLocalState()	Convenience method for newLocalState(State) with a null argument
State	State.newLocalState(State moduleState)	Creates a new state object and pushes the moduleState's stacks onto the current one.
State	State.newSelectiveState(State moduleState)
State	State.newSelectiveState(State moduleState, boolean inheritVariables)	Create a clean state, taking the old modules from moduleState, all the functions and allowing inheritance of the current variable stack
State	State.newSelectiveState(State moduleState, boolean inheritFunctions, boolean inheritVariables)	This will clone the current state and will add the modules (templates and instances -- old modules) from moduleState.
State	State.newSelectiveState(State moduleState, boolean inheritModules, boolean inheritFunctions, boolean inheritVariables, boolean inheritIntrinsics)	Create a new state based on the current state and choosing what to inherit.

Methods in org.qdl_lang.state with parameters of type State

Modifier and Type	Method	Description
void	LibLoader.add(State state)	Typically this just calls addLibEntries(String, QDLStem) or addLibEntry(String, String, String).
static State	StateUtils.clone(State state)	Take the current state and make a complete copy of it.
void	XStack.deserializeFromJSON(net.sf.json.JSONObject jsonObject, SerializationState serializationState, State state)
void	XStack.deserializeFromJSONNEW(net.sf.json.JSONObject jsonObject, SerializationState serializationState, State state)
void	XStack.deserializeFromJSONOLD(net.sf.json.JSONObject jsonObject, SerializationState serializationState, State state)
abstract XStack	XStack.getStateStack(State state)	This gets the stack corresponding to this class from the state..
void	State.injectTransientFields(State oldState)	For the case where this has been deserialized and needs to have its transient fields initialized.
static State	StateUtils.javaClone(State state)
static State	StateUtils.load(State state, XMLEventReader xer)	Read in the state from an even reader.
static State	StateUtils.load(State state, SerializationState SerializationState, XMLEventReader xer)
State	State.newLocalState(State moduleState)	Creates a new state object and pushes the moduleState's stacks onto the current one.
State	State.newSelectiveState(State moduleState)
State	State.newSelectiveState(State moduleState, boolean inheritVariables)	Create a clean state, taking the old modules from moduleState, all the functions and allowing inheritance of the current variable stack
State	State.newSelectiveState(State moduleState, boolean inheritFunctions, boolean inheritVariables)	This will clone the current state and will add the modules (templates and instances -- old modules) from moduleState.
State	State.newSelectiveState(State moduleState, boolean inheritModules, boolean inheritFunctions, boolean inheritVariables, boolean inheritIntrinsics)	Create a new state based on the current state and choosing what to inherit.
static void	StateUtils.save(State state, OutputStream outputStream)	Serialize the Sate object to the given output stream.
static String	StateUtils.saveb64(State state)	Serialize the state to a base 64 encoded string.
static void	State.setFactory(State factory)
static void	State.setRootState(State newRoot)
abstract void	XStack.setStateStack(State state, XStack xStack)	This sets the stack corresponding to this class from the state with the given stack.
void	AbstractState.setSuperState(State superState)
void	State.setTargetState(State targetState)
static int	StateUtils.size(State state)

Constructors in org.qdl_lang.state with parameters of type State

Constructor	Description
QDLThread(State qdlState, QDLScript qdlScript, int pid)

Uses of State in org.qdl_lang.statements

Methods in org.qdl_lang.statements with parameters of type State

Modifier and Type	Method	Description
protected Object	WhileLoop.doBasicWhile(State localState)
protected Object	WhileLoop.doForLoop(State localState)
protected Object	WhileLoop.doPostLoop(State localState)
QDLValue	AssertStatement.evaluate(State state)
QDLValue	BlockStatement.evaluate(State state)
QDLValue	ConditionalStatement.evaluate(State state)
QDLValue	LocalBlockStatement.evaluate(State state)
QDLValue	ModuleStatement.evaluate(State state)
QDLValue	Statement.evaluate(State state)
QDLValue	SwitchStatement.evaluate(State state)
QDLValue	TryCatch.evaluate(State state)
QDLValue	WhileLoop.evaluate(State state)
protected Object	WhileLoop.forKeysOrValuesLoop(State localState, boolean doKeys)	for_keys(var, stem.) -- Loop over the keys in a given stem, assigning each to the var.

Uses of State in org.qdl_lang.util

Methods in org.qdl_lang.util with parameters of type State

Modifier and Type	Method	Description
static boolean	QDLFileUtil.canRead(State state, String path)
QDLStem	ModuleUtils.convertArgsToStem(Polyad polyad, QDLValue arg, State state, String component)	Converts a couple of different arguments to the form [[a0{,b0}],[a1{,b1}],...,[an{,bn}] or (if a single argument that is a stem) can pass back:
static void	QDLFileUtil.copy(State state, String source, String target)
Module	ModuleUtils.deserializeFromJSON(State state, net.sf.json.JSONObject json, boolean useModule, SerializationState serializationState)
Module	ModuleUtils.deserializeFromJSON(State state, net.sf.json.JSONObject json, SerializationState serializationState)	This starts the load from the JSON since which type of module to instantiate is needed, so the right module has to exist before Module.deserializeFromJSON(JSONObject, SerializationState) can be called.
void	ModuleUtils.deserializeUsedModules(State state, net.sf.json.JSONArray jsonArray, SerializationState serializationState)
static String[]	QDLFileUtil.dir(State state, String path)
static String[]	QDLFileUtil.dir(State state, String path, WorkspaceCommands.RegexFileFilter regexFileFilter)
List<String>	ModuleUtils.doJavaModuleLoad(State state, String resourceName, JavaModuleConfig javaModuleConfig)	Load a single java module, returning a null if it failed or the FQ name if it worked.
List<String>	ModuleUtils.doQDLModuleLoad(State state, String resourceName)	Load the module(s) in a single resource.
static boolean	QDLFileUtil.exists(State state, String path)
static String	InputFormUtil.inputForm(String fName, int argCount, State state)	Look up a function for the given state by arg count.
static String	InputFormUtil.inputFormModule(String moduleName, State state)
static String	InputFormUtil.inputFormModule(URI moduleNS, State state)	Finds the input form for a module.
static String	InputFormUtil.inputFormVar(String varName, int indentFactor, State state)	Finds the input form for a variable from the state.
static String	InputFormUtil.inputFormVar(String varName, State state)
static boolean	QDLFileUtil.isDirectory(State state, String path)
static long	QDLFileUtil.length(State state, String path)
static QDLFileUtil.FileAttributes	QDLFileUtil.readAttributes(State state, String fullPath)	Read off the file attributes (such as name, length etc.) from the given file
static byte[]	QDLFileUtil.readBinaryFile(State state, String fullPath)	Main entry point for reading a binary file.
static byte[]	QDLFileUtil.readBinaryVFS(State state, String path)	Read the bytes from the VFS file.
static InputStream	QDLFileUtil.readFileAsInputStream(State state, String fullPath)
static String	QDLFileUtil.readTextFile(State state, String fullPath)	Main entry point for reading a text file as lines
static List<String>	QDLFileUtil.readTextFileAsLines(State state, String fullPath)	Main entry point for reading a text file as lines.
static QDLStem	QDLFileUtil.readTextFileAsStem(State state, String fullPath)	main entry point for reading a text file as a stem.
static String	QDLFileUtil.readTextVFS(State state, String path)
net.sf.json.JSONArray	ModuleUtils.serializeUsedModules(State state, SerializationState serializationState)
void	ModuleUtils.updateSerializedState(net.sf.json.JSONObject jsonObject, State state, SerializationState serializationState)	There are two steps to deserialzing a workspace.
void	ModuleUtils.updateUsedModuleState(net.sf.json.JSONObject jsonObject, State state, SerializationState serializationState)
static void	QDLFileUtil.writeBinaryFile(State state, String fullPath, byte[] bytes)	Main entry point for writing a binary file
static void	QDLFileUtil.writeBinaryVFS(State state, String path, byte[] bytes)	Write the set of bytes to the given VFS file.
static void	QDLFileUtil.writeTextFile(State state, String fullPath, String contents)
static void	QDLFileUtil.writeTextFile(State state, String fullPath, List<String> contents)
static void	QDLFileUtil.writeTextVFS(State state, String path, String content)

Uses of State in org.qdl_lang.variables

Methods in org.qdl_lang.variables with parameters of type State

Modifier and Type	Method	Description
static void	StemUtility.doNodeSurgery(ExpressionStemNode ESN, State state)
QDLValue	QDLSetNode.evaluate(State state)
QDLValue	StemEntryNode.evaluate(State state)
QDLValue	StemListNode.evaluate(State state)
QDLValue	StemVariableNode.evaluate(State state)
XStack	VStack.getStateStack(State state)
void	VStack.setStateStack(State state, XStack xStack)

Uses of State in org.qdl_lang.workspace

Methods in org.qdl_lang.workspace that return State

Modifier and Type	Method	Description
State	InterruptUtil.SIThread.getQDLState()
State	BufferManager.getState()
State	WorkspaceCommands.getState()	Creates the top-level state object for the system.

Methods in org.qdl_lang.workspace with parameters of type State

Modifier and Type	Method	Description
void	WorkspaceCommands.setState(State state)	This is used in serialization tests.
protected void	WorkspaceCommands.setupJavaModule(State state, QDLLoader loader, boolean importASAP)

Constructors in org.qdl_lang.workspace with parameters of type State

Constructor	Description
SIThread(InterruptException ie, State qdlState)

Uses of State in org.qdl_lang.xml

Fields in org.qdl_lang.xml with type parameters of type State

Modifier and Type	Field	Description
Map<UUID,State>	SerializationState.stateMap

Methods in org.qdl_lang.xml that return State

Modifier and Type	Method	Description
State	SerializationState.getState(UUID uuid)

Methods in org.qdl_lang.xml with parameters of type State

Modifier and Type	Method	Description
boolean	SerializationState.addState(State state)	The state, returning true if it was added and false otherwise.
static void	XMLUtilsV2.deserializeExtrinsicFunctions(XMLEventReader xer, State state, SerializationState serializationState)
static void	XMLUtilsV2.deserializeExtrinsicVariables(XMLEventReader xer, State state, SerializationState serializationState)
static void	XMLUtils.deserializeFunctions(XMLEventReader xer, edu.uiuc.ncsa.security.core.configuration.XProperties xp, State state)
static void	XMLUtilsV2.deserializeFunctions(XMLEventReader xer, State state, SerializationState serializationState)
static void	XMLUtils.deserializeImports(XMLEventReader xer, edu.uiuc.ncsa.security.core.configuration.XProperties xp, State state)
static void	XMLUtilsV2.deserializeInstances(XMLEventReader xer, State state, SerializationState serializationState)
static void	XMLUtilsV2.deserializeIntrinsicFunctions(XMLEventReader xer, State state, SerializationState serializationState)
static void	XMLUtilsV2.deserializeIntrinsicVariables(XMLEventReader xer, State state, SerializationState serializationState)
protected static Module	XMLUtils.deserializeModule(XMLEventReader xer, XMLUtils.ModuleAttributes moduleAttributes, edu.uiuc.ncsa.security.core.configuration.XProperties xp, State state)	process a single module.
static void	XMLUtils.deserializeTemplates(XMLEventReader xer, edu.uiuc.ncsa.security.core.configuration.XProperties xp, State state)
static void	XMLUtilsV2.deserializeTemplates(XMLEventReader xer, State state, SerializationState serializationState)	Deserializes a template stack of references.
static void	XMLUtilsV2.deserializeVariables(XMLEventReader xer, State state, SerializationState serializationState)
protected static void	XMLUtilsV2.deserializeXStack(XMLEventReader xer, XStack QDLStack, State state, SerializationState serializationState)
static void	XMLUtils.oldDeserializeFunctions(XMLEventReader xer, edu.uiuc.ncsa.security.core.configuration.XProperties xp, State state)	Used for reading very old serialized versions, before there were multiple stacks.
boolean	SerializationState.processedState(State state)