A namespace in which methods, variables, and imports (class names) live.
This is package public because it is used in the implementation of some
bsh commands. However for normal use you should be using methods on
bsh.Interpreter to interact with your scripts.
A bsh.This object is a thin layer over a NameSpace that associates it with
an Interpreter instance. Together they comprise a Bsh scripted object
context.
Note: I'd really like to use collections here, but we have to keep this
compatible with JDK1.1
clear
public void clear()
Clear all variables, methods, and imports from this namespace.
If this namespace is the root, it will be reset to the default
imports.
loadDefaultImports()
doSuperImport
public void doSuperImport()
throws UtilEvalError
Perform "import *;" causing the entire classpath to be mapped.
This can take a while.
get
public Object get(String name,
Interpreter interpreter)
throws UtilEvalError
Resolve name to an object through this namespace.
getAllNames
public String[] getAllNames()
Implements NameSource
- getAllNames in interface NameSource
- all variable and method names in this and all parent
namespaces
getAllNamesAux
protected void getAllNamesAux(Vector vec)
Helper for implementing NameSource
getClass
public Class getClass(String name)
throws UtilEvalError
Load a class through this namespace taking into account imports.
The class search will proceed through the parent namespaces if
necessary.
- null if not found.
getCommand
public Object getCommand(String name,
Class[] argTypes,
Interpreter interpreter)
throws UtilEvalError
A command is a scripted method or compiled command class implementing a
specified method signature. Commands are loaded from the classpath
and may be imported using the importCommands() method.
This method searches the imported commands packages for a script or
command object corresponding to the name of the method. If it is a
script the script is sourced into this namespace and the BshMethod for
the requested signature is returned. If it is a compiled class the
class is returned. (Compiled command classes implement static invoke()
methods).
The imported packages are searched in reverse order, so that later
imports take priority.
Currently only the first object (script or class) with the appropriate
name is checked. If another, overloaded form, is located in another
package it will not currently be found. This could be fixed.
name
- is the name of the desired command methodargTypes
- is the signature of the desired command method.
- a BshMethod, Class, or null if no such command is found.
UtilEvalError
- if loadScriptedCommand throws UtilEvalError
i.e. on errors loading a script that was found
getDeclaredVariables
public Variable[] getDeclaredVariables()
getGlobal
public This getGlobal(Interpreter declaringInterpreter)
Get the top level namespace or this namespace if we are the top.
Note: this method should probably return type bsh.This to be consistent
with getThis();
getInvocationLine
public int getInvocationLine()
getInvocationText
public String getInvocationText()
getMethod
public BshMethod getMethod(String name,
Class[] sig)
throws UtilEvalError
getMethod( String, Class [], boolean )
, getMethod( String, Class [] )
getMethod
public BshMethod getMethod(String name,
Class[] sig,
boolean declaredOnly)
throws UtilEvalError
Get the bsh method matching the specified signature declared in
this name space or a parent.
Note: this method is primarily intended for use internally. If you use
this method outside of the bsh package you will have to be familiar
with BeanShell's use of the Primitive wrapper class.
declaredOnly
- if true then only methods declared directly in this
namespace will be found and no inherited or imported methods will
be visible.
- the BshMethod or null if not found
Primitive
getMethodNames
public String[] getMethodNames()
Get the names of methods declared in this namespace.
(This does not include methods in parent namespaces).
getMethods
public BshMethod[] getMethods()
Get the methods defined in this namespace.
(This does not show methods in parent namespaces).
Note: This will probably be renamed getDeclaredMethods()
getName
public String getName()
The name of this namespace. If the namespace is a method body
namespace then this is the name of the method. If it's a class or
class instance then it's the name of the class.
getParent
public NameSpace getParent()
Get the parent namespace.
Note: this isn't quite the same as getSuper().
getSuper() returns 'this' if we are at the root namespace.
getSuper
public This getSuper(Interpreter declaringInterpreter)
Get the parent namespace' This reference or this namespace' This
reference if we are the top.
getVariable
public Object getVariable(String name)
throws UtilEvalError
Get the specified variable in this namespace or a parent namespace.
Note: this method is primarily intended for use internally. If you use
this method outside of the bsh package you will have to use
Primitive.unwrap() to get primitive values.
- The variable value or Primitive.VOID if it is not defined.
Primitive.unwrap(Object)
getVariable
public Object getVariable(String name,
boolean recurse)
throws UtilEvalError
Get the specified variable in this namespace.
recurse
- If recurse is true then we recursively search through
parent namespaces for the variable.
Note: this method is primarily intended for use internally. If you use
this method outside of the bsh package you will have to use
Primitive.unwrap() to get primitive values.
- The variable value or Primitive.VOID if it is not defined.
Primitive.unwrap(Object)
getVariableImpl
protected Variable getVariableImpl(String name,
boolean recurse)
throws UtilEvalError
Locate a variable and return the Variable object with optional
recursion through parent name spaces.
If this namespace is static, return only static variables.
- the Variable value or null if it is not defined
getVariableNames
public String[] getVariableNames()
Get the names of variables defined in this namespace.
(This does not show variables in parent namespaces).
identifierToClass
public static Class identifierToClass(ClassIdentifier ci)
This is a helper method for working inside of bsh scripts and commands.
In that context it is impossible to see a ClassIdentifier object
for what it is. Attempting to access a method on a ClassIdentifier
will look like a static method invocation.
This method is in NameSpace for convenience (you don't have to import
bsh.ClassIdentifier to use it );
importClass
public void importClass(String name)
Import a class name.
Subsequent imports override earlier ones
importCommands
public void importCommands(String name)
Import scripted or compiled BeanShell commands in the following package
in the classpath. You may use either "/" path or "." package notation.
e.g. importCommands("/bsh/commands") or importCommands("bsh.commands")
are equivalent. If a relative path style specifier is used then it is
made into an absolute path by prepending "/".
importObject
public void importObject(Object obj)
Import a compiled Java object's methods and variables into this
namespace. When no scripted method / command or variable is found
locally in this namespace method / fields of the object will be
checked. Objects are checked in the order of import with later imports
taking precedence.
importPackage
public void importPackage(String name)
subsequent imports override earlier ones
importStatic
public void importStatic(Class clas)
invokeMethod
public Object invokeMethod(String methodName,
Object[] args,
Interpreter interpreter)
throws EvalError
Invoke a method in this namespace with the specified args and
interpreter reference. No caller information or call stack is
required. The method will appear as if called externally from Java.
bsh.This.invokeMethod(
String methodName, Object [] args, Interpreter interpreter,
CallStack callstack, SimpleNode callerInfo, boolean )
invokeMethod
public Object invokeMethod(String methodName,
Object[] args,
Interpreter interpreter,
CallStack callstack,
bsh.SimpleNode callerInfo)
throws EvalError
This method simply delegates to This.invokeMethod();
bsh.This.invokeMethod(
String methodName, Object [] args, Interpreter interpreter,
CallStack callstack, SimpleNode callerInfo )
loadDefaultImports
public void loadDefaultImports()
Import standard packages. Currently:
importClass("bsh.EvalError");
importClass("bsh.Interpreter");
importPackage("javax.swing.event");
importPackage("javax.swing");
importPackage("java.awt.event");
importPackage("java.awt");
importPackage("java.net");
importPackage("java.util");
importPackage("java.io");
importPackage("java.lang");
importCommands("/bsh/commands");
nameSpaceChanged
public void nameSpaceChanged()
Clear all cached classes and names
prune
public void prune()
Used for serialization
setName
public void setName(String name)
setParent
public void setParent(NameSpace parent)
setTypedVariable
public void setTypedVariable(String name,
Class type,
Object value,
boolean isFinal)
throws UtilEvalError
See #setTypedVariable( String, Class, Object, Modifiers )
setTypedVariable
public void setTypedVariable(String name,
Class type,
Object value,
Modifiers modifiers)
throws UtilEvalError
Declare a variable in the local scope and set its initial value.
Value may be null to indicate that we would like the default value
for the variable type. (e.g. 0 for integer types, null for object
types). An existing typed variable may only be set to the same type.
If an untyped variable of the same name exists it will be overridden
with the new typed var.
The set will perform a Types.getAssignableForm() on the value if
necessary.
Note: this method is primarily intended for use internally. If you use
this method outside of the bsh package and wish to set variables with
primitive values you will have to wrap them using bsh.Primitive.
value
- If value is null, you'll get the default value for the typemodifiers
- may be null
Primitive
setVariable
public void setVariable(String name,
Object value,
boolean strictJava)
throws UtilEvalError
Set the variable through this namespace.
This method obeys the LOCALSCOPING property to determine how variables
are set.
Note: this method is primarily intended for use internally. If you use
this method outside of the bsh package and wish to set variables with
primitive values you will have to wrap them using bsh.Primitive.
strictJava
- specifies whether strict java rules are applied.
Setting a new variable (which didn't exist before) or removing
a variable causes a namespace change.
toString
public String toString()
unsetVariable
public void unsetVariable(String name)
Remove the variable from the namespace.
unwrapVariable
protected Object unwrapVariable(Variable var)
throws UtilEvalError
Unwrap a variable to its value.
- return the variable value. A null var is mapped to
Primitive.VOID