Uses of Interface
edu.vub.at.objects.ATTable

Packages that use ATTable

edu.vub.at.actors
edu.vub.at.actors.natives
edu.vub.at.eval
edu.vub.at.exceptions
edu.vub.at.objects
edu.vub.at.objects.coercion
edu.vub.at.objects.grammar
edu.vub.at.objects.mirrors
edu.vub.at.objects.natives
edu.vub.at.objects.natives.grammar
edu.vub.at.objects.symbiosis

Uses of ATTable in edu.vub.at.actors

Subinterfaces of ATTable in edu.vub.at.actors

interface

ATMailbox A mailbox is a special kind of table object used to buffer asynchronous messages

Methods in edu.vub.at.actors that return ATTable

ATTable	ATMailbox.base_flush() Clears the content of the mailbox (i.e. mailbox becomes empty) and return all current messages in a fresh table, which is no longer causally connected to this mailbox.
ATTable	ATFarReference.meta_retractUnsentMessages() Retracts all of the outgoing messages buffered in this far object reference by passing them in a table.

Methods in edu.vub.at.actors with parameters of type ATTable

ATAsyncMessage

ATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments) Creates a first-class message in the language.

Uses of ATTable in edu.vub.at.actors.natives

Methods in edu.vub.at.actors.natives that return ATTable

ATTable	NATRemoteFarRef.meta_retractUnsentMessages()
ATTable	NATLocalFarRef.meta_retractUnsentMessages() The 'outbox' of a far reference to a local actor is always empty.
ATTable	NATFarReference.meta_listFields()
ATTable	NATFarReference.meta_listMethods()
ATTable	NATFarReference.meta_getStripes() The stripes of a far reference are the stripes of the remote object it points to, plus the FarReference stripe.
ATTable	NATActorMirror.meta_getStripes()
ATTable	ELFarReference.retractUnsentMessages()

Methods in edu.vub.at.actors.natives with parameters of type ATTable

ATObject	NATFarReference.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments)
ATObject	NATFarReference.meta_newInstance(ATTable initargs) Cannot create a new instance using a farObject, this should be done either by sending rather than invoking new(args) such that the correct method is triggered or by invoking newInstance on a farMirror, which will send the call as well.
ATAsyncMessage	NATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments)
ATObject	NATActorMirror.meta_newInstance(ATTable initargs) actor.new(closure) => same effect as evaluating 'actor: closure'

Constructors in edu.vub.at.actors.natives with parameters of type ATTable

NATAsyncMessage(ATObject sender, ATSymbol sel, ATTable arg)

NATAsyncMessage(ATObject sdr, ATObject rcv, ATSymbol sel, ATTable arg)

Uses of ATTable in edu.vub.at.eval

Fields in edu.vub.at.eval declared as ATTable

ATTable

InvocationStack.InvocationFrame.arguments

Methods in edu.vub.at.eval with parameters of type ATTable

static void	PartialBinder.defineParamsForArgs(PartialBinder residual, ATContext context, ATTable arguments) Bind all of the given parameters as newly defined slots in the given scope to the given arguments.
static void	PartialBinder.assignArgsToParams(PartialBinder residual, ATContext context, ATTable arguments) Assign all of the formal parameter names in the scope object to the given arguments The scope is defined as the lexical scope of the given context.
static PartialBinder	PartialBinder.calculateResidual(java.lang.String forFunction, ATTable parameters) Performs the partial evaluation of the binding algorithm given the formal parameters.
void	InvocationStack.functionCalled(ATExpression funCall, ATClosure fun, ATTable evaluatedArgs)
static NATText	Evaluator.printAsStatements(ATTable tab)
static NATText	Evaluator.printAsList(ATTable tab)
private static void	Evaluator.bindArguments(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments, Evaluator.BindClosure binder) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static void	Evaluator.defineParamsForArgs(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static void	Evaluator.assignArgsToParams(java.lang.String funnam, ATContext context, ATTable parameters, ATTable arguments) Deprecated. use partial evalation using PartialBinder.bind(ATObject[], ATContext, edu.vub.at.eval.PartialBinder.BindClosure) instead.
static NATTable	Evaluator.evalMandatoryPars(ATTable formals, ATContext ctx) Given a formal parameter list, this auxiliary method returns a new table consisting of the values of the bindings of the mandatory parameters of formals within the context ctx.

Constructors in edu.vub.at.eval with parameters of type ATTable

InvocationStack.InvocationFrame(ATExpression inv, ATObject rcvr, ATTable args)

Uses of ATTable in edu.vub.at.exceptions

Methods in edu.vub.at.exceptions that return ATTable

ATTable

XImportConflict.getConflictingNames()

Uses of ATTable in edu.vub.at.objects

Methods in edu.vub.at.objects that return ATTable

ATTable	ATMethod.base_getParameters() Structural access to the parameter list of the method, which is normally a table of symbols.
ATTable	ATStripe.base_getParentStripes()
ATTable	ATNumber.base__optms__optms_(ATNumber end)
ATTable	ATNumber.base__optms__optms__optms_(ATNumber end)
ATTable	ATMessage.base_getArguments() Messages may optionally have a table of arguments.
ATTable	ATObject.meta_listFields() Queries an object for a list of all of its field slots.
ATTable	ATObject.meta_listMethods() Queries an object for a list of all of its method slots.
ATTable	ATObject.meta_getStripes() Returns the stripes of this object.
ATTable	ATTable.base_map_(ATClosure clo) Map a closure over each element of the table, resulting in a new table.
ATTable	ATTable.base_filter_(ATClosure clo) Keep only those elements of the table for which the closure evaluates to true.
ATTable	ATTable.base_select(ATNumber start, ATNumber stop) Select a subrange of the table: idx: 1 2 3 4 5 [a, b, c, d, e].select(2,4) => [b, c, d]
ATTable	ATTable.base__oppls_(ATTable other) [1,2,3] + [4,5] => [1,2,3,4,5]
ATTable	ATText.base_explode()
ATTable	ATText.base_split(ATText separator)

Methods in edu.vub.at.objects with parameters of type ATTable

ATObject	ATMethod.base_apply(ATTable arguments, ATContext ctx) Applies the method to the given arguments in the given context.
ATObject	ATMethod.base_applyInScope(ATTable arguments, ATContext ctx) Applies the method to the given arguments in the given context.
ATNil	ATMessage.base_setArguments(ATTable arguments) Assigns the arguments of a first class method.
ATObject	ATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invoke a method corresponding to the selector with the given arguments.
ATObject	ATObject.meta_newInstance(ATTable initargs) Create a new instance of the receiver object.
ATTable	ATTable.base__oppls_(ATTable other) [1,2,3] + [4,5] => [1,2,3,4,5]
ATObject	ATClosure.base_apply(ATTable args) Applies the closure to the given arguments, already wrapped in a table.
ATObject	ATClosure.base_applyInScope(ATTable args, ATObject scope) Applies the closure to the given arguments, already wrapped in a table.

Uses of ATTable in edu.vub.at.objects.coercion

Methods in edu.vub.at.objects.coercion that return ATTable

ATTable

ATConversions.base_asTable()

Uses of ATTable in edu.vub.at.objects.grammar

Methods in edu.vub.at.objects.grammar that return ATTable

ATTable	ATSymbol.base__opmns__opgtx_(ATObject obj) Used during import: declarations to conveniently denote aliases for names.
ATTable	ATMultiDefinition.base_getParameters()
ATTable	ATMultiAssignment.base_getParameters()
ATTable	ATMessageCreation.base_getArguments()
ATTable	ATDefStripe.base_getParentStripeExpressions()
ATTable	ATDefMethod.base_getArguments()
ATTable	ATDefExternalMethod.base_getArguments()
ATTable	ATClosureLiteral.base_getArguments()
ATTable	ATBegin.base_getStatements()
ATTable	ATApplication.base_getArguments()

Uses of ATTable in edu.vub.at.objects.mirrors

Fields in edu.vub.at.objects.mirrors declared as ATTable

protected ATTable	ReflectiveAccessTest.closures
private ATTable	PrimitiveMethod.formals_

Methods in edu.vub.at.objects.mirrors that return ATTable

ATTable	PrimitiveMethod.base_getParameters()
ATTable	PrimitiveMethod.meta_getStripes()
ATTable	OBJMirrorRoot.meta_getStripes()
ATTable	NATMirage.magic_listMethods()
ATTable	NATMirage.magic_listFields()
ATTable	NATMirage.magic_getStripes()
ATTable	NATMirage.meta_listMethods()
ATTable	NATMirage.meta_listFields()
ATTable	NATMirage.meta_getStripes()
ATTable	NativeMethod.base_getParameters() The parameters of a wrapped method are represented as symbols representing the class name of the parameter type.
ATTable	NativeMethod.meta_getStripes()
ATTable	NativeField.meta_getStripes()
ATTable	NativeAnonymousMethod.base_getParameters()
ATTable	NativeAnonymousMethod.meta_getStripes()
ATTable	NATIntrospectiveMirror.meta_listFields() Listing the fields of a mirror requires us to list all of the meta_get methods of the principal + all of the base_get methods of the mirror itself
ATTable	NATIntrospectiveMirror.meta_listMethods() Listing the methods of a mirror requires us to list all of the meta_ methods of the principal (excluding meta_get/set methods) + all of the base_ methods (excluding base_get/set methods) of the mirror itself
ATTable	NATIntrospectiveMirror.meta_getStripes()
ATTable	NATIntercessiveMirror.meta_getStripes()

Methods in edu.vub.at.objects.mirrors with parameters of type ATTable

static ATObject	Reflection.upInvocation(ATObject atOrigRcvr, java.lang.String jSelector, ATTable atArgs) upInvocation takes an explicit AmbientTalk method invocation and turns it into an implicitly performed Java invocation.
static ATObject	Reflection.upInstanceCreation(ATObject jRcvr, ATTable atInitargs) upInstanceCreation takes an explicit AmbientTalk 'new' invocation and turns it into an implicit Java instance creation by calling a constructor.
static ATObject	Reflection.upExceptionCreation(InterpreterException jRcvr, ATTable atInitargs)
abstract ATObject	PrimitiveMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	PrimitiveMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	OBJMirrorRoot.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The effect of invoking methods on a mirror (through meta_invoke) consists of checking whether the requested functionality is provided as a meta-operation by the principal that is wrapped by this mirror.
ATObject	NATMirage.magic_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.magic_newInstance(ATTable initargs)
ATObject	NATMirage.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.meta_newInstance(ATTable initargs)
ATObject	NativeMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	NativeMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NativeField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
ATObject	NativeClosure.base_apply(ATTable arguments) Apply the NativeClosure, which either gives rise to executing a native piece of code supplied by an anonymous subclass, or executes the wrapped NativeMethod.
ATObject	NativeClosure.base_applyInScope(ATTable args, ATObject scope) A NativeClosure can also be directed to execute its wrapped NativeMethod in an externally specified scope.
ATObject	NativeClosure.get(ATTable args, int n) Auxiliary method to more easily extract arguments from an ATTable
int	NativeClosure.getNbr(ATTable args, int n)
double	NativeClosure.getFrc(ATTable args, int n)
java.lang.String	NativeClosure.getTxt(ATTable args, int n)
boolean	NativeClosure.getBln(ATTable args, int n)
java.lang.Object[]	NativeClosure.getTab(ATTable args, int n)
void	NativeClosure.checkArity(ATTable args, int required)
ATObject	NativeAnonymousMethod.base_apply(ATTable arguments, ATContext ctx) It is an error to directly apply an anonymous method.
ATObject	NativeAnonymousMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NATIntrospectiveMirror.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The effect of invoking methods on a mirror (through meta_invoke) consists of checking whether the requested functionality is provided as a meta-operation by the principal that is wrapped by this mirror.
ATObject	NATIntrospectiveMirror.meta_newInstance(ATTable init) This method allows re-initialise a mirror object.

Constructors in edu.vub.at.objects.mirrors with parameters of type ATTable

PrimitiveMethod(ATSymbol name, ATTable formals)

Uses of ATTable in edu.vub.at.objects.natives

Classes in edu.vub.at.objects.natives that implement ATTable

class

NATTable The native implementation of an AmbientTalk table.

Fields in edu.vub.at.objects.natives declared as ATTable

private ATTable	NATStripe.parentStripes_
private ATTable	NATMethod.parameters_

Methods in edu.vub.at.objects.natives that return ATTable

ATTable	OBJSystem.base_getArgv() def argv := command-line arguments passed to iat
ATTable	OBJLexicalRoot.base_retract_(ATFarReference farReference) retract: farReference => retract all currently unsent messages from the far reference's outbox This has the side effect that the returned messages will *not* be sent automatically anymore, the programmer is responsible to resend all messages that still need to be sent by hand.
ATTable	OBJLexicalRoot.base_stripesOf_(ATObject object) stripesOf: object => returns all of the stripes of an object
ATTable	NATText.meta_getStripes()
ATTable	NATText.base_explode() Explodes a text string into a table of constinuent characters
ATTable	NATText.base_split(ATText regexp) Split the string according to the given regular expression.
ATTable	NATTable.base_asTable()
ATTable	NATTable.meta_getStripes()
ATTable	NATTable.base_map_(ATClosure clo)
ATTable	NATTable.base_filter_(ATClosure clo)
ATTable	NATTable.base_select(ATNumber first, ATNumber last) tab.select(start, stop) == els = [ ] ; start.to: stop do: { |i| els << tab[i] } ; els
ATTable	NATTable.base__oppls_(ATTable other)
ATTable	NATStripe.base_getParentStripes()
ATTable	NATStripe.meta_getStripes()
ATTable	NATObject.meta_listMethods()
ATTable	NATObject.meta_getStripes() Return the stripes that were directly attached to this object.
ATTable	NATObject.base_asTable()
ATTable	NATNumeric.meta_getStripes()
ATTable	NATNumber.meta_getStripes()
ATTable	NATNumber.base__optms__optms_(ATNumber end) NBR(start) ** NBR(stop) => [ start, ..., stop [ Example: 2 ** 5 => [ 2, 3, 4 ] 5 ** 2 => [ 5, 4, 3 ]
ATTable	NATNumber.base__optms__optms__optms_(ATNumber end) NBR(start) *** NBR(stop) => [ start, ..., stop ] Example: 2 *** 5 => [ 2, 3, 4, 5 ] 5 *** 2 => [ 5, 4, 3, 2 ]
ATTable	NATNil.meta_listFields()
ATTable	NATNil.meta_listMethods()
ATTable	NATNil.base_asTable()
ATTable	NATNil.meta_getStripes() By default, a native object (and also nil) has no stripes.
ATTable	NATMethod.base_getParameters()
ATTable	NATMethod.meta_getStripes()
ATTable	NATMessage.base_getArguments()
ATTable	NATHandler.meta_getStripes()
ATTable	NATFraction.meta_getStripes()
ATTable	NATField.meta_getStripes()
ATTable	NATException.meta_getStripes()
ATTable	NATContext.meta_getStripes()
ATTable	NATClosureMethod.base_getParameters()
ATTable	NATClosureMethod.meta_getStripes()
ATTable	NATClosure.meta_getStripes()
ATTable	NATCallframe.meta_listFields()
ATTable	NATCallframe.meta_listMethods()
ATTable	NATBoolean.meta_getStripes()

Methods in edu.vub.at.objects.natives with parameters of type ATTable

private static java.util.Hashtable	OBJLexicalRoot.preprocessAliases(ATTable aliases) Given a table of tables, of the form [ [oldname, newname], ... ], returns a hashtable mapping the old names to the new names.
private static java.util.HashSet	OBJLexicalRoot.preprocessExcludes(ATTable exclusions) Given a table of symbols, returns a hashset containing all the names.
ATObject	OBJLexicalRoot.base_foreach_in_(ATClosure body, ATTable tab) The foreach:in: primitive, which calls back on the table using each: usage: foreach: { |v| body } in: [ table ] pseudo-implementation: [ table ].each: { |v| body }
ATObject	OBJLexicalRoot.base_object_stripedWith_(ATClosure code, ATTable stripes) object: { code } stripedWith: [ s1, s2, ... ] => creates a new object tagged with the given stripes
ATObject	OBJLexicalRoot.base_try_usingHandlers_(ATClosure tryBlock, ATTable exceptionHandlers) try: { tryBlock } usingHandlers: [ handler1, handler2, ... ] Applies the given closure (to []) and handles exceptions using the given exception handlers.
ATTable	NATTable.base__oppls_(ATTable other)
static NATStripe	NATStripe.atValue(ATSymbol stripeName, ATTable parentStripes) Stripes should not be created directly because it should be verified that their list of parent stripes is never empty.
ATObject	NATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invocations on an object ( o.m( args ) ) are handled by looking up the requested selector in the dynamic parent chain of the receiver.
ATObject	NATObject.meta_newInstance(ATTable initargs) When new is invoked on an object's mirror, the object is first cloned by the mirror, after which the method named 'init' is invoked on it.
ATObject	NATNil.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) The default behaviour of 'delegate' for primitive non-object ambienttalk language values is to check whether the requested functionality is provided by a native Java method with the same selector, but prefixed with 'base_'.
ATObject	NATNil.meta_newInstance(ATTable initargs)
ATObject	NATMethod.base_apply(ATTable arguments, ATContext ctx) To apply a function, first bind its parameters to the evaluated arguments within a new call frame.
ATObject	NATMethod.base_applyInScope(ATTable arguments, ATContext ctx) Applies the method in the context given, without first inserting a call frame to bind parameters.
ATNil	NATMessage.base_setArguments(ATTable arguments)
ATObject	NATField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
ATObject	NATException.meta_newInstance(ATTable initargs)
ATObject	NATClosureMethod.base_apply(ATTable arguments, ATContext ctx) A closure method application acts exactly like a regular direct method application, except that the given lexical scope is disregarded and replaced by the lexical scope encapsulated by the closure method.
ATObject	NATClosureMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NATClosure.base_apply(ATTable arguments) To apply a closure, apply its underlying method with the context of the closure, rather than the runtime context of the invoker.
ATObject	NATClosure.base_applyInScope(ATTable args, ATObject scope) To apply a closure in a given scope, apply its underlying method with a new context constructed from the scope object.
ATObject	NATCallframe.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Normally, call frames are not used in receiverful method invocation expressions.
ATObject	NATCallframe.meta_newInstance(ATTable initargs)

Constructors in edu.vub.at.objects.natives with parameters of type ATTable

NATStripe(ATSymbol stripeName, ATTable parentStripes)
The constructor is declared protected such that it cannot be used externally, but can be used by the OBJRootStripe class to create a stripe with an empty parent table, which is normally not allowed.

NATMethodInvocation(ATSymbol sel, ATTable arg)

NATMethod(ATSymbol name, ATTable parameters, ATBegin body)

NATMessage(ATSymbol sel, ATTable arg, ATStripe stripe)

NATDelegation(ATObject delegator, ATSymbol sel, ATTable arg)

Uses of ATTable in edu.vub.at.objects.natives.grammar

Fields in edu.vub.at.objects.natives.grammar declared as ATTable

private ATTable	AGMultiDefinition.parameters_
private ATTable	AGMultiAssignment.parameters_
protected ATTable	AGMessageCreation.arguments_
private ATTable	AGDefStripe.parentStripeExpressions_
private ATTable	AGDefFunction.argumentExps_
private ATTable	AGDefExternalMethod.argumentExps_
protected ATTable	AGClosureLiteral.arguments_
private ATTable	AGBegin.statements_
private ATTable	AGApplication.arguments_

Methods in edu.vub.at.objects.natives.grammar that return ATTable

ATTable	NATAbstractGrammar.meta_getStripes()
ATTable	AGSymbol.base__opmns__opgtx_(ATObject obj)
ATTable	AGMultiDefinition.base_getParameters()
ATTable	AGMultiAssignment.base_getParameters()
ATTable	AGMessageCreation.base_getArguments()
ATTable	AGExpression.meta_getStripes()
ATTable	AGDefStripe.base_getParentStripeExpressions()
ATTable	AGDefFunction.base_getArguments()
ATTable	AGDefExternalMethod.base_getArguments()
ATTable	AGClosureLiteral.base_getArguments()
ATTable	AGBegin.base_getStatements()
ATTable	AGApplication.base_getArguments()

Methods in edu.vub.at.objects.natives.grammar with parameters of type ATTable

protected ATObject	AGMethodInvocationCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)
protected abstract ATObject	AGMessageCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs) Subclasses must implement this method in order to return a new instance of themselves parameterized with their quoted arguments.
protected ATObject	AGDelegationCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)
protected ATObject	AGAsyncMessageCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)

Constructors in edu.vub.at.objects.natives.grammar with parameters of type ATTable

AGMultiDefinition(ATTable par, ATExpression val)

AGMultiAssignment(ATTable par, ATExpression val)

AGMethodInvocationCreation(ATSymbol sel, ATTable args)

AGMessageCreation(ATSymbol sel, ATTable args)

AGDelegationCreation(ATSymbol sel, ATTable args)

AGDefStripe(ATSymbol stripeName, ATTable parentStripeExpressions)

AGDefFunction(ATSymbol sel, ATTable args, ATBegin bdy)

AGDefExternalMethod(ATSymbol rcv, ATSymbol sel, ATTable args, ATBegin bdy)

AGClosureLiteral(ATTable args, ATBegin body)

AGBegin(ATTable statements)

AGAsyncMessageCreation(ATSymbol selector, ATTable arguments)

AGApplication(ATExpression fun, ATTable arg)

Uses of ATTable in edu.vub.at.objects.symbiosis

Methods in edu.vub.at.objects.symbiosis that return ATTable

ATTable	JavaObject.meta_listFields() Querying a symbiotic Java object for its fields results in a table containing both the 'native' Java fields and the fields of its AT symbiont
ATTable	JavaObject.meta_listMethods() Querying a symbiotic Java object for its methods results in a table containing both all 'native' Java instance methods and the methods of its AT symbiont
ATTable	JavaMethod.base_getParameters()
ATTable	JavaMethod.meta_getStripes()
ATTable	JavaField.meta_getStripes()
ATTable	JavaClass.meta_listFields() Querying a symbiotic Java class object for its fields results in a table containing both 'native' static Java fields and the fields of its AT symbiont
ATTable	JavaClass.meta_listMethods() Querying a symbiotic Java class object for its methods results in a table containing both 'native' static Java methods and the methods of its AT symbiont
ATTable	JavaClass.base_getParentStripes() If this class represents an interface type, parentStripes are wrappers for all interfaces extended by this Java interface type

Methods in edu.vub.at.objects.symbiosis with parameters of type ATTable

ATObject	JavaObject.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) When a method is invoked upon a symbiotic Java object, an underlying Java method with the same name as the AmbientTalk selector is invoked.
ATObject	JavaObject.meta_newInstance(ATTable initargs) Invoking new on a JavaObject will exhibit the same behaviour as if new was invoked on the parent class.
ATObject	JavaMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	JavaMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	JavaField.meta_newInstance(ATTable initargs) Fields can be re-initialized when installed in an object that is being cloned.
ATObject	JavaClass.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments) When a method is invoked upon a symbiotic Java class object, the underlying static Java method with the same name as the AmbientTalk selector is invoked.
ATObject	JavaClass.meta_newInstance(ATTable initargs) aJavaClass.new(@args) == invoke a Java constructor AmbientTalk objects can add a custom new method to the class in order to intercept instance creation.