| java.lang.Object
 org.gjt.sp.jedit.bsh.NameSpace
All known Subclasses: org.gjt.sp.jedit.bsh.BlockNameSpace, org.gjt.sp.jedit.bsh.ExternalNameSpace,
| NameSpace | | public class NameSpace implements java.io.Serializable,BshClassManager.Listener,NameSource(Code) | | 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
|
| Inner Class :static class CommandPathEntry | |
| Method Summary | |
| public void | addCommandPath(String path, Class clas)
Adds a URL to the command path. | | public void | addNameSourceListener(NameSource.Listener listener)
Implements NameSource
Add a listener who is notified upon changes to names in this space. | | void | cacheClass(String name, Class c)
Helper that caches class. | | public void | classLoaderChanged()
| | public void | clear()
Clear all variables, methods, and imports from this namespace. | | public void | doSuperImport()
Perform "import *;" causing the entire classpath to be mapped. | | public Object | get(String name, Interpreter interpreter)
Resolve name to an object through this namespace. | | public String[] | getAllNames()
| | protected void | getAllNamesAux(Vector vec)
| | public Class | getClass(String name)
Load a class through this namespace taking into account imports. | | Object | getClassInstance()
| | public BshClassManager | getClassManager()
| | public Object | getCommand(String name, Class[] argTypes, Interpreter interpreter)
A command is a scripted method or compiled command class implementing a
specified method signature. | | public InputStream | getCommand(String name)
Looks up a command. | | public Variable[] | getDeclaredVariables()
| | public This | getGlobal(Interpreter declaringInterpreter)
Get the top level namespace or this namespace if we are the top. | | protected BshMethod | getImportedMethod(String name, Class[] sig)
| | protected Variable | getImportedVar(String name)
| | public int | getInvocationLine()
| | public String | getInvocationText()
| | public BshMethod | getMethod(String name, Class[] sig)
| | public BshMethod | getMethod(String name, Class[] sig, boolean declaredOnly)
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. | | public String[] | getMethodNames()
Get the names of methods declared in this namespace. | | public BshMethod[] | getMethods()
Get the methods defined in this namespace. | | public String | getName()
The name of this namespace. | | Name | getNameResolver(String ambigname)
This is the factory for Name objects which resolve names within
this namespace (e.g. | | SimpleNode | getNode()
| | String | getPackage()
| | public NameSpace | getParent()
Get the parent namespace. | | public This | getSuper(Interpreter declaringInterpreter)
Get the parent namespace' This reference or this namespace' This
reference if we are the top. | | This | getThis(Interpreter declaringInterpreter)
A This object is a thin layer over a namespace, comprising a bsh object
context. | | public Object | getVariable(String name)
Get the specified variable in this namespace or a parent namespace.
Note: this method is primarily intended for use internally. | | public Object | getVariable(String name, boolean recurse)
Get the specified variable in this namespace.
Parameters:
recurse - If recurse is true then we recursively search throughparent namespaces for the variable.Note: this method is primarily intended for use internally. | | protected Variable | getVariableImpl(String name, boolean recurse)
Locate a variable and return the Variable object with optional
recursion through parent name spaces. | | public String[] | getVariableNames()
Get the names of variables defined in this namespace. | | 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. | | public void | importClass(String name)
Import a class name. | | public void | importCommands(String name)
Import scripted or compiled BeanShell commands in the following package
in the classpath. | | public void | importObject(Object obj)
Import a compiled Java object's methods and variables into this
namespace. | | public void | importPackage(String name)
| | public void | importStatic(Class clas)
| | public Object | invokeMethod(String methodName, Object[] args, Interpreter interpreter)
Invoke a method in this namespace with the specified args and
interpreter reference. | | public Object | invokeMethod(String methodName, Object[] args, Interpreter interpreter, CallStack callstack, SimpleNode callerInfo)
| | public void | loadDefaultImports()
Import standard packages. | | public void | nameSpaceChanged()
| | public void | prune()
| | public void | removeCommandPath(String path, Class clas)
Remove a URLfrom the command path. | | void | setClassInstance(Object instance)
| | void | setClassManager(BshClassManager classManager)
| | void | setClassStatic(Class clas)
| | void | setLocalVariable(String name, Object value, boolean strictJava)
Set a variable explicitly in the local scope. | | public void | setMethod(String name, BshMethod method)
Note: this is primarily for internal use. | | public void | setName(String name)
| | void | setNode(SimpleNode node)
Set the node associated with the creation of this namespace. | | void | setPackage(String packageName)
Set the package name for classes defined in this namespace. | | public void | setParent(NameSpace parent)
| | public void | setTypedVariable(String name, Class type, Object value, boolean isFinal)
| | public void | setTypedVariable(String name, Class type, Object value, Modifiers modifiers)
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. | | public void | setVariable(String name, Object value, boolean strictJava)
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. | | void | setVariable(String name, Object value, boolean strictJava, boolean recurse)
Set the value of a the variable 'name' through this namespace.
The variable may be an existing or non-existing variable.
It may live in this namespace or in a parent namespace if recurse is
true.
Note: This method is not public and does *not* know about LOCALSCOPING.
Its caller methods must set recurse intelligently in all situations
(perhaps based on LOCALSCOPING).
Note: this method is primarily intended for use internally. | | public void | setVariable(String name, Object value)
| | public String | toString()
| | public void | unsetVariable(String name)
Remove the variable from the namespace. | | protected Object | unwrapVariable(Variable var)
Unwrap a variable to its value.
return the variable value. |
| callerInfoNode | | SimpleNode callerInfoNode(Code) | | The node associated with the creation of this namespace.
This is used support getInvocationLine() and getInvocationText().
|
| isClass | | boolean isClass(Code) | | Note that the namespace is a class body or class instance namespace.
This is used for controlling static/object import precedence, etc.
|
| isMethod | | boolean isMethod(Code) | | Note that the namespace is a method body namespace. This is used for
printing stack traces in exceptions.
|
| addCommandPath | | public void addCommandPath(String path, Class clas)(Code) | | Adds a URL to the command path.
|
| addNameSourceListener | | public void addNameSourceListener(NameSource.Listener listener)(Code) | | Implements NameSource
Add a listener who is notified upon changes to names in this space.
|
| classLoaderChanged | | public void classLoaderChanged()(Code) | | Clear all cached classes and names
|
| clear | | public void clear()(Code) | | Clear all variables, methods, and imports from this namespace.
If this namespace is the root, it will be reset to the default
imports.
See Also: NameSpace.loadDefaultImports() |
| doSuperImport | | public void doSuperImport() throws UtilEvalError(Code) | | Perform "import *;" causing the entire classpath to be mapped.
This can take a while.
|
| getAllNames | | public String[] getAllNames()(Code) | | Implements NameSource
all variable and method names in this and all parentnamespaces |
| getAllNamesAux | | protected void getAllNamesAux(Vector vec)(Code) | | Helper for implementing NameSource
|
| getClass | | public Class getClass(String name) throws UtilEvalError(Code) | | 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(Code) | | 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.
a BshMethod, Class, or null if no such command is found.
Parameters:
name - is the name of the desired command method
Parameters:
argTypes - is the signature of the desired command method.
throws:
UtilEvalError - if loadScriptedCommand throws UtilEvalErrori.e. on errors loading a script that was found |
| getGlobal | | public This getGlobal(Interpreter declaringInterpreter)(Code) | | 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()(Code) | | |
| getMethod | | public BshMethod getMethod(String name, Class[] sig, boolean declaredOnly) throws UtilEvalError(Code) | | 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.
See Also: org.gjt.sp.jedit.bsh.Primitive the BshMethod or null if not found
Parameters:
declaredOnly - if true then only methods declared directly in thisnamespace will be found and no inherited or imported methods willbe visible. |
| getMethodNames | | public String[] getMethodNames()(Code) | | Get the names of methods declared in this namespace.
(This does not include methods in parent namespaces).
|
| getMethods | | public BshMethod[] getMethods()(Code) | | 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()(Code) | | 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.
|
| getNameResolver | | Name getNameResolver(String ambigname)(Code) | | This is the factory for Name objects which resolve names within
this namespace (e.g. toObject(), toClass(), toLHS()).
This was intended to support name resolver caching, allowing
Name objects to cache info about the resolution of names for
performance reasons. However this not proven useful yet.
We'll leave the caching as it will at least minimize Name object
creation.
(This method would be called getName() if it weren't already used for
the simple name of the NameSpace)
This method was public for a time, which was a mistake.
Use get() instead.
|
| getParent | | public NameSpace getParent()(Code) | | 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)(Code) | | Get the parent namespace' This reference or this namespace' This
reference if we are the top.
|
| getThis | | This getThis(Interpreter declaringInterpreter)(Code) | | A This object is a thin layer over a namespace, comprising a bsh object
context. It handles things like the interface types the bsh object
supports and aspects of method invocation on it.
The declaringInterpreter is here to support callbacks from Java through
generated proxies. The scripted object "remembers" who created it for
things like printing messages and other per-interpreter phenomenon
when called externally from Java.
|
| getVariable | | public Object getVariable(String name) throws UtilEvalError(Code) | | 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.
See Also: Primitive.unwrap(Object) The variable value or Primitive.VOID if it is not defined. |
| getVariable | | public Object getVariable(String name, boolean recurse) throws UtilEvalError(Code) | | Get the specified variable in this namespace.
Parameters:
recurse - If recurse is true then we recursively search throughparent namespaces for the variable.Note: this method is primarily intended for use internally. If you usethis method outside of the bsh package you will have to usePrimitive.unwrap() to get primitive values.
See Also: Primitive.unwrap(Object) The variable value or Primitive.VOID if it is not defined. |
| getVariableImpl | | protected Variable getVariableImpl(String name, boolean recurse) throws UtilEvalError(Code) | | 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()(Code) | | Get the names of variables defined in this namespace.
(This does not show variables in parent namespaces).
|
| identifierToClass | | public static Class identifierToClass(ClassIdentifier ci)(Code) | | 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)(Code) | | Import a class name.
Subsequent imports override earlier ones
|
| importCommands | | public void importCommands(String name)(Code) | | 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)(Code) | | 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)(Code) | | subsequent imports override earlier ones
|
| invokeMethod | | public Object invokeMethod(String methodName, Object[] args, Interpreter interpreter) throws EvalError(Code) | | 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.
See Also: org.gjt.sp.jedit.bsh.This.invokeMethod(
See Also: String methodName, Object [] args, Interpreter interpreter,
See Also: CallStack callstack, SimpleNode callerInfo, boolean ) |
| invokeMethod | | public Object invokeMethod(String methodName, Object[] args, Interpreter interpreter, CallStack callstack, SimpleNode callerInfo) throws EvalError(Code) | | This method simply delegates to This.invokeMethod();
See Also: org.gjt.sp.jedit.bsh.This.invokeMethod(
See Also: String methodName, Object [] args, Interpreter interpreter,
See Also: CallStack callstack, SimpleNode callerInfo ) |
| loadDefaultImports | | public void loadDefaultImports()(Code) | | Import standard packages. Currently:
importClass("org.gjt.sp.jedit.bsh.EvalError");
importClass("org.gjt.sp.jedit.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");
addCommandPath("/org/gjt/sp/jedit/bsh/commands",getClass());
|
| nameSpaceChanged | | public void nameSpaceChanged()(Code) | | Clear all cached classes and names
|
| prune | | public void prune()(Code) | | Used for serialization
|
| removeCommandPath | | public void removeCommandPath(String path, Class clas)(Code) | | Remove a URLfrom the command path.
|
| setClassInstance | | void setClassInstance(Object instance)(Code) | | |
| setLocalVariable | | void setLocalVariable(String name, Object value, boolean strictJava) throws UtilEvalError(Code) | | Set a variable explicitly in the local scope.
|
| setNode | | void setNode(SimpleNode node)(Code) | | Set the node associated with the creation of this namespace.
This is used in debugging and to support the getInvocationLine()
and getInvocationText() methods.
|
| setPackage | | void setPackage(String packageName)(Code) | | Set the package name for classes defined in this namespace.
Subsequent sets override the package.
|
| setTypedVariable | | public void setTypedVariable(String name, Class type, Object value, Modifiers modifiers) throws UtilEvalError(Code) | | 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.
See Also: org.gjt.sp.jedit.bsh.Primitive
Parameters:
value - If value is null, you'll get the default value for the type
Parameters:
modifiers - may be null |
| setVariable | | public void setVariable(String name, Object value, boolean strictJava) throws UtilEvalError(Code) | | 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.
See Also: org.gjt.sp.jedit.bsh.Primitive
See Also:
See Also: Setting a new variable (which didn't exist before) or removing
See Also: a variable causes a namespace change.
Parameters:
strictJava - specifies whether strict java rules are applied.
|
| setVariable | | void setVariable(String name, Object value, boolean strictJava, boolean recurse) throws UtilEvalError(Code) | | Set the value of a the variable 'name' through this namespace.
The variable may be an existing or non-existing variable.
It may live in this namespace or in a parent namespace if recurse is
true.
Note: This method is not public and does *not* know about LOCALSCOPING.
Its caller methods must set recurse intelligently in all situations
(perhaps based on LOCALSCOPING).
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.
See Also: org.gjt.sp.jedit.bsh.Primitive
See Also:
See Also: Setting a new variable (which didn't exist before) or removing
See Also: a variable causes a namespace change.
Parameters:
strictJava - specifies whether strict java rules are applied.
Parameters:
recurse - determines whether we will search for the variable inour parent's scope before assigning locally.
|
| unsetVariable | | public void unsetVariable(String name)(Code) | | Remove the variable from the namespace.
|
| unwrapVariable | | protected Object unwrapVariable(Variable var) throws UtilEvalError(Code) | | Unwrap a variable to its value.
return the variable value. A null var is mapped toPrimitive.VOID |
|
|