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

Packages that use ATObject

edu.vub.at
edu.vub.at.actors
edu.vub.at.actors.natives
edu.vub.at.actors.net
edu.vub.at.eval
edu.vub.at.exceptions
edu.vub.at.exceptions.signals
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
edu.vub.at.parser

Uses of ATObject in edu.vub.at

Classes in edu.vub.at that implement ATObject

class

OBJUnit OBJUnit is a preliminary version of a unit test framework to be used in AmbientTalk.

Methods in edu.vub.at that return ATObject

static ATObject	AmbientTalkTest.evalSnippet(java.lang.Class forTestClass, java.lang.String name, ATContext inContext) Loads and evaluates the content of a code snippet file and returns the resulting AmbientTalk ATObject.
ATObject	AmbientTalkTest.evalAndReturn(java.lang.String input)
ATObject	AmbientTalkTest.evalInActor(java.lang.String input)
ATObject	OBJUnit.meta_evaluate(ATText source)
ATObject	OBJUnit.base_unittest_(ATClosure code) The unittest: primitive, implemented as base-level code.

Methods in edu.vub.at with parameters of type ATObject

void	AmbientTalkTest.evalAndCompareTo(java.lang.String input, ATObject output)
void	AmbientTalkTest.printedEquals(ATObject input, java.lang.String expected)
NATNil	OBJUnit.base_echo_(ATObject message)
NATNil	OBJUnit.base_assert_equals_(ATObject expected, ATObject actual)
NATNil	OBJUnit.base_assert_evaluatesTo(ATText source, ATObject expected)
NATNil	OBJUnit.base_assert_printsTo(ATText source, ATObject expected)

Uses of ATObject in edu.vub.at.actors

Subinterfaces of ATObject in edu.vub.at.actors

interface	ATActorMirror
interface	ATAsyncMessage Instances of the class ATAsyncMessage represent first-class asynchronous message sends.
interface	ATFarReference ATFarReference is an object reference denoting an object hosted by another actor.
interface	ATMailbox A mailbox is a special kind of table object used to buffer asynchronous messages
interface	ATObservable

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

ATObject	ATMailbox.base_enqueue(ATObject value)
ATObject	ATMailbox.base_dequeue()
ATObject	ATAsyncMessage.base_getSender() Signifies the object on behalf of which this asynchronous message is sent.
ATObject	ATAsyncMessage.base_getReceiver() Messages also have an explicitly named receiver, which may either be a local object, or a representative of an object inside another actor.
ATObject	ATAsyncMessage.base_process(ATActorMirror inActor) This method is responsible for processing the message in a certain actor.
ATObject	ATActorMirror.base_send(ATAsyncMessage message) This method implements the default asynchronous message sending semantics for this particular actor.
ATObject	ATActorMirror.base_provide(ATStripe topic, ATObject service) This mechanism is the most basic mechanism to provide a service.
ATObject	ATActorMirror.base_require(ATStripe topic, ATClosure handler, ATBoolean bool) This mechanism is the most basic mechanism to require a service.
ATObject	ATActorMirror.base_install_(ATClosure code) def protocol := install: { code } Installs a meta-object protocol into this actor.

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

ATObject	ATMailbox.base_enqueue(ATObject value)
ATAsyncMessage	ATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments) Creates a first-class message in the language.
ATObject	ATActorMirror.base_provide(ATStripe topic, ATObject service) This mechanism is the most basic mechanism to provide a service.

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

Classes in edu.vub.at.actors.natives that implement ATObject

class	NATActorMirror The NATActorMirror class implements the concurrency model of ambienttalk.
static class	NATActorMirror.NATProtocol A protocol object is defined as: object: { def installedMirror := //the installed actor mirror; def uninstall() { //uninstall the protocol object } }
static class	NATActorMirror.NATPublication A publication object is defined as: object: { def topic := //topic under which service is published; def service := //the exported service object; def cancel() { //unexport the service object } }
static class	NATActorMirror.NATSubscription A subscription object is defined as: object: { def topic := //topic subscribed to; def handler := //the closure to be triggered; def cancel() { //unsubscribe the handler } }
class	NATAsyncMessage Instances of the class NATAsyncMessage represent first-class asynchronous messages.
class	NATFarReference NATFarReference is the root of the native classes that represent native far references.
static class	NATFarReference.NATDisconnectionSubscription
static class	NATFarReference.NATReconnectionSubscription
class	NATLocalFarRef Instances of NATLocalFarRef denote far references to objects 'local' to this address space.
class	NATRemoteFarRef Instances of NATRemoteFarRef represent far references to physically remote actors.

Fields in edu.vub.at.actors.natives declared as ATObject

private ATObject	ELActor.behaviour_
ATObject	DiscoveryManager.Subscription.deserializedHandler_

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

abstract ATObject	SharedActorField.initialize() Hook to be overridden in order to initialize the field which should be installed in every actor's lexical root object.
ATObject	ReceptionistsSet.resolveObject(ATObjectID objectId, ATStripe[] stripes) Try to resolve a remote object reference into a local (near) reference.
ATObject	Packet.unpack()
protected ATObject	NATRemoteFarRef.transmit(ATAsyncMessage message)
protected ATObject	NATLocalFarRef.transmit(ATAsyncMessage passedMessage)
ATObject	NATFarReference.meta_resolve() After deserialization, ensure that only one unique remote reference exists for my target.
ATObject	NATFarReference.meta_receive(ATAsyncMessage message)
protected abstract ATObject	NATFarReference.transmit(ATAsyncMessage passedMessage)
ATObject	NATFarReference.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments)
ATObject	NATFarReference.meta_doesNotUnderstand(ATSymbol selector)
ATObject	NATFarReference.meta_clone() References to objects hosted by another actor are forced to be unique.
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.
ATObject	NATFarReference.meta_extend(ATClosure code) TODO(discuss) Think about extending objects of another actor.
ATObject	NATFarReference.meta_share(ATClosure code) TODO(discuss) Think about sharing objects of another actor.
ATObject	NATFarReference.meta_select(ATObject receiver, ATSymbol selector)
ATObject	NATFarReference.meta_lookup(ATSymbol selector)
ATObject	NATFarReference.meta_getDynamicParent()
ATObject	NATFarReference.meta_getLexicalParent()
ATObject	NATAsyncMessage.base_getSender()
ATObject	NATAsyncMessage.base_getReceiver()
ATObject	NATAsyncMessage.base_process(ATActorMirror inActor)
ATObject	NATAsyncMessage.base_sendTo(ATObject receiver, ATObject sender) To evaluate an asynchronous message send, an asynchronous invoke is performed on the receiver object.
ATObject	NATActorMirror.base_provide(ATStripe topic, ATObject service)
ATObject	NATActorMirror.base_require(ATStripe topic, ATClosure handler, ATBoolean isPermanent)
ATObject	NATActorMirror.meta_clone()
ATObject	NATActorMirror.meta_newInstance(ATTable initargs) actor.new(closure) => same effect as evaluating 'actor: closure'
ATObject	NATActorMirror.meta_send(ATAsyncMessage msg) To send a message msg to a receiver object rcv: - if rcv is a local reference, schedule accept(msg) in my incoming event queue - if rcv is a far reference, schedule msg in far reference's outbox
ATObject	NATActorMirror.meta_receive(ATAsyncMessage msg)
ATObject	NATActorMirror.base_send(ATAsyncMessage message) When default base-level objects send an asynchronous message, they delegate this responsibility to their actor by means of this base-level method.
ATObject	NATActorMirror.base_install_(ATClosure code) def install: { code }
ATObject	ELActor.resolve(ATObjectID id, ATStripe[] stripes) Resolve the given object id into a local reference.
ATObject	ELActor.sync_event_eval(ATAbstractGrammar ast) This method should only be used for purposes such as the IAT shell or unit testing.

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

NATLocalFarRef	ReceptionistsSet.exportObject(ATObject object) Export a local object such that it now has a unique global identifier which can be distributed to other actors.
void	ReceptionistsSet.addClient(ATObject service, ATFarReference client) Invoked whenever another actor is passed a reference to an object offering a service on this actor.
void	ReceptionistsSet.removeClient(ATObject service, ATFarReference client) Called upon the collection of a service on a remote device, or possibly when the conditions negotiated for the use of the service (e.g. its lease period) have expired.
ATObject	NATFarReference.meta_invoke(ATObject receiver, ATSymbol atSelector, ATTable arguments)
ATObject	NATFarReference.meta_select(ATObject receiver, ATSymbol selector)
ATNil	NATFarReference.meta_defineField(ATSymbol name, ATObject value)
ATNil	NATFarReference.meta_assignField(ATObject receiver, ATSymbol name, ATObject value)
ATNil	NATFarReference.meta_assignVariable(ATSymbol name, ATObject value)
ATBoolean	NATFarReference.meta_isCloneOf(ATObject original)
ATBoolean	NATFarReference.meta_isRelatedTo(ATObject object)
ATObject	NATAsyncMessage.base_sendTo(ATObject receiver, ATObject sender) To evaluate an asynchronous message send, an asynchronous invoke is performed on the receiver object.
ATAsyncMessage	NATActorMirror.base_createMessage(ATObject sender, ATSymbol selector, ATTable arguments)
ATObject	NATActorMirror.base_provide(ATStripe topic, ATObject service)
void	ELFarReference.addDisconnectionListener(ATObject listener)
void	ELFarReference.addReconnectionListener(ATObject listener)
void	ELFarReference.removeDisconnectionListener(ATObject listener)
void	ELFarReference.removeReconnectionListener(ATObject listener)
NATLocalFarRef	ELActor.export(ATObject object) Export the given local object such that it is now remotely accessible via the returned object id.
void	DiscoveryManager.notifyOfExternalPublication(ATStripe pubTopic, ATObject remoteService) When a remote VM hears the request of the local VM for services it requires, it returns its own matching services, using a CMDJoinServices command.
private void	DiscoveryManager.notify(ATObject handler, ATObject service) Performs handler<-apply([ service ])

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

Packet(java.lang.String description, ATObject object)

Packet(ATObject object)

NATAsyncMessage(ATObject sender, ATSymbol sel, ATTable arg)

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

NATActorMirror.NATPublication(ELDiscoveryActor discoveryActor, ATStripe topic, ATObject service, DiscoveryManager.Publication pub)

Uses of ATObject in edu.vub.at.actors.net

Classes in edu.vub.at.actors.net that implement ATObject

class

OBJNetwork This class represents the singleton network object which provides methods to interface with AT/2's distribution layer.

Methods in edu.vub.at.actors.net that return ATObject

ATObject

OBJNetwork.meta_resolve() After deserialization, ensure that the network object remains unique.

Uses of ATObject in edu.vub.at.eval

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

ATObject

InvocationStack.InvocationFrame.receiver

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

protected abstract void	PartialBinder.bind(ATObject[] arguments, ATContext inContext, PartialBinder.BindClosure binder) Bind the given actual arguments to the formal parameters encapsulated by this partial bind function.
private static PartialBinder	PartialBinder.makeMandatory(java.lang.String funnam, ATObject[] formals) - Mandatory (n 0 0) example: f(a,b)
private static PartialBinder	PartialBinder.makeMandatoryOptional(java.lang.String funnam, ATObject[] formals, int numMandatory, int numOptional) - MandatoryOptional (n m 0) example: f(a,b,c:=1)
private static PartialBinder	PartialBinder.makeOptional(java.lang.String funnam, ATObject[] formals) - Optional (0 m 0) example: f(a:=1,b:=2)
private static PartialBinder	PartialBinder.makeMandatoryVariable(java.lang.String funnam, ATObject[] formals) - MandatoryVariable (n 0 1) example: f(a,b,@rest)
private static PartialBinder	PartialBinder.makeOptionalVariable(java.lang.String funnam, ATObject[] formals) - OptionalVariable (0 m 1) example: f(a:=1,@rest)
private static PartialBinder	PartialBinder.makeGeneric(java.lang.String funnam, ATObject[] formals, int numMandatory, int numOptional) - Generic (n m 1) example: f(a,b:=1,@rest)
void	PartialBinder.BindClosure.bindParamToArg(ATObject inScope, ATSymbol param, ATObject arg)
void	InvocationStack.methodInvoked(ATExpression methodInvocation, ATObject receiver, ATMessage message)
void	InvocationStack.methodReturned(ATObject result)
void	InvocationStack.funcallReturned(ATObject result)
static NATText	Evaluator.printElements(ATObject[] els, java.lang.String start, java.lang.String sep, java.lang.String stop) Auxiliary function used to print the elements of a table using various separators.
static java.lang.String	Evaluator.toString(ATObject obj)
void	Evaluator.BindClosure.bindParamToArg(ATObject inScope, ATSymbol param, ATObject arg)

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

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

Uses of ATObject in edu.vub.at.exceptions

Fields in edu.vub.at.exceptions declared as ATObject

ATObject	XUserDefined.customException_
private ATObject	XTypeMismatch.failedObject_
ATObject	XSelectorNotFound.inObject_

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

ATObject	XUserDefined.getAmbientTalkRepresentation()
ATObject	XTypeMismatch.getFailedObject()
ATObject	InterpreterException.getAmbientTalkRepresentation()

Constructors in edu.vub.at.exceptions with parameters of type ATObject

XUserDefined(ATObject customException)

XTypeMismatch(java.lang.Class expectedType, ATObject failedObject)

XSymbiosisFailure(java.lang.Object symbiont, java.lang.String selector, java.util.LinkedList choices, ATObject[] atArgs)
Reports that an overloaded method could not be resolved to a unique implementation because there are multiple matches.

XSymbiosisFailure(java.lang.Object symbiont, java.lang.String selector, ATObject[] atArgs)
Reports that an overloaded method could not be resolved to a unique implementation because there are no matches for any static types.

XSymbiosisFailure(java.lang.Class failedClass, java.lang.reflect.Constructor[] choices, ATObject[] atArgs, int numMatchingCtors)
Reports that an overloaded constructor could not be resolved to a unique implementation.

XSelectorNotFound(ATSymbol selector, ATObject inObject)

Uses of ATObject in edu.vub.at.exceptions.signals

Fields in edu.vub.at.exceptions.signals declared as ATObject

ATObject

SignalEscape.returnedValue

Constructors in edu.vub.at.exceptions.signals with parameters of type ATObject

SignalEscape(ATClosure originatingBlock, ATObject returnedValue)

Uses of ATObject in edu.vub.at.objects

Subinterfaces of ATObject in edu.vub.at.objects

interface	ATAbstractGrammar ATAbstractGrammar contains all methods to be understood by any parsetree element in the ambienttalk/2 programming language.
interface	ATBoolean The ATBoolean interface is the public interface to a boolean object.
interface	ATClosure The public interface to a native AmbientTalk closure (a method + enclosing environment).
interface	ATContext ATContext describes a triplet of scope pointers used during evaluation, namely one for the lexical scope (where the lookup starts for receiverless messages), one for the late-bound receiver and one for the parent object.
interface	ATField ATFields provide a mapping from an immutable name to a potentially mutable value.
interface	ATFraction The public interface to a native AmbientTalk fraction (a floating point value).
interface	ATHandler Instances of the class ATHandler represent first-class exception handlers which have a filter object, describing the kind of exceptions caught by the handler and a code block which acts as replacement code for the code that raised the exception.
interface	ATMessage Instances of the class ATMessage represent first-class AmbientTalk asynchronous messages.
interface	ATMethod ATMethods are ambienttalk's representation of methods as named functions.
interface	ATMethodInvocation Instances of the class ATMethodInvocation represent first-class method invocations.
interface	ATMirror ATMirror is an interface describing the additional behaviour exhibited by mirrors with respect to ordinary objects.
interface	ATNil the native object representing 'nil' implements this interface.
interface	ATNumber The public interface to an AmbientTalk native number (an integer value).
interface	ATNumeric The common interface to both numbers and fractions.
interface	ATStripe The public interface to a native stripe object.
interface	ATTable The public interface to a native AmtientTalk table (an array).
interface	ATText The public interface to a native AmbientTalk string (a string of characters).

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

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.
ATObject	ATHandler.base_handle(ATObject anException) When a handler has answered that it can handle an exception, the following method is invoked, asking the handler to handle the exception.
ATObject	ATBoolean.base_ifTrue_(ATClosure cons)
ATObject	ATBoolean.base_ifFalse_(ATClosure alt)
ATObject	ATBoolean.base_ifTrue_ifFalse_(ATClosure cons, ATClosure alt)
ATObject	ATMessage.base_sendTo(ATObject receiver, ATObject sender) Sends this message to a particular receiver object.
ATObject	ATField.base_readField()
ATObject	ATObject.meta_send(ATAsyncMessage message) Sends a newly created message asynchronously by this object.
ATObject	ATObject.meta_receive(ATAsyncMessage message) Handles a first-class message of which it is the receiver.
ATObject	ATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invoke a method corresponding to the selector with the given arguments.
ATObject	ATObject.meta_doesNotUnderstand(ATSymbol selector) Called when a selection fails because the selector was not found along the dynamic delegation hierarchy.
ATObject	ATObject.meta_pass() Allows objects to specify how they should be passed when passed as an argument in a message sent to another actor.
ATObject	ATObject.meta_resolve() When an object is deserialized after it has been passed to another actor, it is given a chance to tell the interpreter which object it represents.
ATObject	ATObject.meta_select(ATObject receiver, ATSymbol selector) Select a slot (field | method) from an object whose name corresponds to the given selector.
ATObject	ATObject.meta_lookup(ATSymbol selector) Select a slot (field | method) from an object whose name corresponds to the given selector.
ATObject	ATObject.meta_clone() Clone the receiver object.
ATObject	ATObject.meta_newInstance(ATTable initargs) Create a new instance of the receiver object.
ATObject	ATObject.meta_extend(ATClosure code) Create an is-a extension of the receiver object.
ATObject	ATObject.meta_share(ATClosure code) Create a shares-a extension of the receiver object.
ATObject	ATObject.meta_getDynamicParent() Objects have a classical dynamic parent chain created using extension primitives.
ATObject	ATObject.meta_getLexicalParent() Objects also have a lexical parent which is the scope in which their definitions are nested.
ATObject	ATObject.meta_eval(ATContext ctx) Evaluates a particular parsetree with respect to a particular context.
ATObject	ATObject.meta_quote(ATContext ctx) Quotes a parsetree, in other words allows the parsetree to return itself instead of evaluating.
ATObject	ATObject.base_new(ATObject[] initargs) The object instantiation method.
ATObject	ATObject.base_init(ATObject[] initargs) The object initialisation method.
ATObject	ATContext.base_getLexicalScope() Structural access to the lexical environment of the current context.
ATObject	ATContext.base_getSelf() Structural access to the receiver (self pseudovariable) in the current context.
ATObject	ATTable.base_at(ATNumber index)
ATObject	ATTable.base_atPut(ATNumber index, ATObject value)
ATObject	ATTable.base_with_collect_(ATObject init, ATClosure clo) Collect all elements of the table by combining them using the given closure.
ATObject	ATTable.base_find_(ATClosure clo) Return the index of the first element for which the given predicate returns true.
ATObject	ATMirror.base_getBase() Provides access to the AmbientTalk language value this mirror reflects upon.
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.
ATObject	ATClosure.base_whileTrue_(ATClosure body) Allows AmbientTalk programmers to write { booleanCondition }.whileTrue: { body } which will execute body as long as the boolean condition evaluates to true.
ATObject	ATClosure.base_escape() { |quit| ... quit(val) ... }.escape() The escape control construct passes to its receiver block a function which when invoked, immediately transfers control back to the caller of escape, returning the value passed to quit.

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

ATBoolean	ATHandler.base_canHandle(ATObject anException) Used to determine whether a handler will be triggered when an exception is raised.
ATObject	ATHandler.base_handle(ATObject anException) When a handler has answered that it can handle an exception, the following method is invoked, asking the handler to handle the exception.
ATObject	ATMessage.base_sendTo(ATObject receiver, ATObject sender) Sends this message to a particular receiver object.
ATNil	ATField.base_writeField(ATObject newValue) Sets the value of the field if possible
ATObject	ATObject.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Invoke a method corresponding to the selector with the given arguments.
ATObject	ATObject.meta_select(ATObject receiver, ATSymbol selector) Select a slot (field | method) from an object whose name corresponds to the given selector.
ATNil	ATObject.meta_defineField(ATSymbol name, ATObject value) Defines a new field in an object.
ATNil	ATObject.meta_assignVariable(ATSymbol name, ATObject value) Sets the value of the variable to the given value.
ATNil	ATObject.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Sets the value of a field to the given value.
ATBoolean	ATObject.meta_isRelatedTo(ATObject object) Detects whether both objects have a common origin, in other words whether they are related through a combination of the cloning and extension operators.
ATBoolean	ATObject.meta_isCloneOf(ATObject original) Detects whether this object an the passed parameter are the result of cloning from a common ancestor (possibly either one of the objects itself).
ATBoolean	ATObject.base__opeql__opeql_(ATObject other) The pointer equality == operator.
ATObject	ATObject.base_new(ATObject[] initargs) The object instantiation method.
ATObject	ATObject.base_init(ATObject[] initargs) The object initialisation method.
ATContext	ATContext.base_withLexicalEnvironment(ATObject scope)
ATContext	ATContext.base_withDynamicReceiver(ATObject self)
ATObject	ATTable.base_atPut(ATNumber index, ATObject value)
ATObject	ATTable.base_with_collect_(ATObject init, ATClosure clo) Collect all elements of the table by combining them using the given closure.
ATText	ATText.base__oppls_(ATObject other)
ATObject	ATClosure.base_applyInScope(ATTable args, ATObject scope) Applies the closure to the given arguments, already wrapped in a table.

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

Methods in edu.vub.at.objects.coercion with parameters of type ATObject

static java.lang.Object

Coercer.coerce(ATObject object, java.lang.Class type)

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

Subinterfaces of ATObject in edu.vub.at.objects.grammar

interface	ATApplication
interface	ATAssignField
interface	ATAssignment
interface	ATAssignTable
interface	ATAssignVariable
interface	ATAsyncMessageCreation An ATAsyncMessageCreation instance is created whenever an asynchronous message send o <- m() is performed, or when a first-class async msg is created using code such as <- m().
interface	ATBegin
interface	ATClosureLiteral
interface	ATDefExternalField
interface	ATDefExternalMethod
interface	ATDefField
interface	ATDefinition
interface	ATDefMethod
interface	ATDefStripe The public interface to a stripe definition abstract grammar element.
interface	ATDefTable
interface	ATExpression
interface	ATMessageCreation
interface	ATMessageSend
interface	ATMethodInvocationCreation
interface	ATMultiAssignment
interface	ATMultiDefinition
interface	ATQuote
interface	ATSelection
interface	ATSplice
interface	ATStatement
interface	ATSymbol
interface	ATTabulation
interface	ATUnquote
interface	ATUnquoteSplice

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

ATTable

ATSymbol.base__opmns__opgtx_(ATObject obj) Used during import: declarations to conveniently denote aliases for names.

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

Classes in edu.vub.at.objects.mirrors that implement ATObject

class	NATIntercessiveMirror NATIntercessiveMirror extends the default NATIntrospectiveMirror to also allow programmers to supply their own code for the meta-operations defined on an object.
class	NATIntrospectiveMirror NATIntrospectiveMirror is a default mirror to represent an ambienttalk object which is capable of offering the java meta-interface of any language value at the ambienttalk level.
class	NativeAnonymousMethod A NativeAnonymousMethod represents the meta_apply method of an anonymous NativeClosure subclass.
class	NativeClosure A NativeClosure is a wrapper class for a piece of Java code.
class	NativeField Native Fields are represented in our reflective implementation as a pair of accessor and mutator methods in the class of the native AmbientTalk object.
class	NativeMethod A NativeMethod is a wrapper around a Java method allowing it to be selected from native base-level objects and passed around as an ordinary object.
class	NATMirage A NATMirage is an object that forwards all meta-operations invoked upon it (at the java-level) to its designated mirror object.
class	OBJMirrorRoot OBJMirrorRoot is a singleton which is shared by as a parent by all NATIntercessiveMirrors, It encodes the default behaviour to deal with invocation, selection and field assignment along the dynamic parent chain.
class	PrimitiveMethod A primitive method is the equivalent of a NativeClosure but for methods rather than closures.

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

protected ATObject	ReflectiveAccessTest.lexicalRoot
private ATObject	NativeField.host_ The AmbientTalk native object to which this field belongs
protected ATObject	NativeClosure.scope_
private ATObject	NATIntrospectiveMirror.principal_ the object reflected on.

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

static ATObject	Reflection.downInvocation(ATObject atRcvr, java.lang.reflect.Method jMethod, ATObject[] jArgs) downInvocation takes an implicit Java invocation and turns it into an explicit AmbientTalk invocation process.
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.upFieldSelection(ATObject atOrigRcvr, java.lang.String jSelector) upFieldSelection takes an explicit AmbientTalk field selection and turns it into an implicitly performed Java selection by invoking a getter method, if such a getter method exists.
static ATObject	Reflection.upFieldAssignment(ATObject atOrigRcvr, java.lang.String jSelector, ATObject value) upFieldAssignment takes an explicit AmbientTalk field assignment and turns it into an implicitly performed Java field assignment by invoking a mutator method, if such a method exists.
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)
static ATObject	Reflection.downObject(ATObject metaObject) Pass an AmbientTalk meta-level object into the base-level
static ATObject	Reflection.upObject(ATObject baseObject) Pass an AmbientTalk base-level object to the meta-level
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	OBJMirrorRoot.meta_clone() OBJMirrorRoot is a singleton object.
protected ATObject	OBJMirrorRoot.createChild(ATClosure code, boolean parentPointerType)
ATObject	OBJMirrorRoot.meta_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATObject	OBJMirrorRoot.meta_resolve() After deserialization, ensure that the mirror root remains unique.
ATObject	NATMirage.magic_extend(ATClosure code)
ATObject	NATMirage.magic_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.magic_lookup(ATSymbol selector)
ATObject	NATMirage.magic_newInstance(ATTable initargs)
ATObject	NATMirage.magic_select(ATObject receiver, ATSymbol selector)
ATObject	NATMirage.magic_share(ATClosure code)
ATObject	NATMirage.magic_doesNotUnderstand(ATSymbol selector)
ATObject	NATMirage.magic_send(ATAsyncMessage message)
ATObject	NATMirage.magic_eval(ATContext ctx)
ATObject	NATMirage.magic_quote(ATContext ctx)
ATObject	NATMirage.magic_getDynamicParent()
ATObject	NATMirage.magic_getLexicalParent()
ATObject	NATMirage.magic_pass()
ATObject	NATMirage.magic_resolve()
ATObject	NATMirage.meta_clone()
ATObject	NATMirage.meta_extend(ATClosure code)
ATObject	NATMirage.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.meta_lookup(ATSymbol selector)
ATObject	NATMirage.meta_newInstance(ATTable initargs)
ATObject	NATMirage.meta_select(ATObject receiver, ATSymbol selector)
ATObject	NATMirage.meta_share(ATClosure code)
ATObject	NATMirage.meta_doesNotUnderstand(ATSymbol selector)
ATObject	NATMirage.meta_send(ATAsyncMessage message)
ATObject	NATMirage.meta_eval(ATContext ctx)
ATObject	NATMirage.meta_quote(ATContext ctx)
ATObject	NATMirage.meta_getDynamicParent()
ATObject	NATMirage.meta_getLexicalParent()
ATObject	NATMirage.meta_pass()
ATObject	NATMirage.meta_resolve()
ATObject	NativeMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	NativeMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	NativeField.base_readField()
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
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.base_getBase()
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_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATObject	NATIntrospectiveMirror.meta_clone() We enforce the restriction that any object has but a single IntrospectiveMirror by returning the mirror itself when asked to clone.
ATObject	NATIntrospectiveMirror.meta_newInstance(ATTable init) This method allows re-initialise a mirror object.
ATObject	NATIntercessiveMirror.base_getBase()
ATObject	NATIntercessiveMirror.meta_clone()
protected ATObject	NATIntercessiveMirror.createChild(ATClosure code, boolean parentPointerType)
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.Class jClass, ATObject natReceiver, java.lang.String jSelector, ATObject[] jArguments) Invokes a method on a Java object identified by a selector.
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.reflect.Method javaMethod, ATObject jReceiver, ATObject[] jArguments) Invokes a method on a native AmbientTalk object identified by a java.lang.reflect.Method object.
static ATObject	JavaInterfaceAdaptor.createNativeATObject(java.lang.Class jClass, ATObject[] jInitArgs) Try to create a new instance of a Java class given an array of initialization arguments.
static ATObject	JavaInterfaceAdaptor.primitiveJavaToATObject(java.lang.Object jObj)

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

static ATField	Reflection.downField(ATObject natObject, ATSymbol atSelector, java.lang.String getPrefix, java.lang.String setPrefix) Constructs an AmbientTalk ATField from a pair of accessor/mutator methods of a Java object.
static ATField	Reflection.downBaseLevelField(ATObject natObject, ATSymbol atSelector)
static ATField	Reflection.downMetaLevelField(ATObject natObject, ATSymbol atSelector)
static ATMethod	Reflection.downMethod(ATObject natObject, java.lang.String jSelector, ATSymbol origName) Constructs an AmbientTalk ATMethod from a Java method.
static ATMethod	Reflection.downBaseLevelMethod(ATObject natObject, ATSymbol atSelector)
static ATMethod	Reflection.downMetaLevelMethod(ATObject natObject, ATSymbol atSelector)
static ATObject	Reflection.downInvocation(ATObject atRcvr, java.lang.reflect.Method jMethod, ATObject[] jArgs) downInvocation takes an implicit Java invocation and turns it into an explicit AmbientTalk invocation process.
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 boolean	Reflection.upRespondsTo(ATObject jRcvr, java.lang.String jSelector) upRespondsTo transforms an explicit AmbientTalk respondsTo meta-level request into an implicit check whether the given jRcvr java object has a method corresponding to the given selector, prefixed with base_
static ATObject	Reflection.upFieldSelection(ATObject atOrigRcvr, java.lang.String jSelector) upFieldSelection takes an explicit AmbientTalk field selection and turns it into an implicitly performed Java selection by invoking a getter method, if such a getter method exists.
static ATObject	Reflection.upFieldAssignment(ATObject atOrigRcvr, java.lang.String jSelector, ATObject value) upFieldAssignment takes an explicit AmbientTalk field assignment and turns it into an implicitly performed Java field assignment by invoking a mutator method, if such a method exists.
static NativeClosure	Reflection.upMethodSelection(ATObject atOrigRcvr, java.lang.String jSelector, ATSymbol origSelector) upMethodSelection takes an explicit AmbientTalk field selection and checks whether a Java method exists that matches the selector.
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.downObject(ATObject metaObject) Pass an AmbientTalk meta-level object into the base-level
static ATObject	Reflection.upObject(ATObject baseObject) Pass an AmbientTalk base-level object to the meta-level
static ATField[]	Reflection.downBaseLevelFields(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeField objects corresponding to all non-static methods of that object's Java class, where each method's name is prefixed with 'base_get'
static ATField[]	Reflection.downMetaLevelFields(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeField objects corresponding to all non-static methods of that object's Java class, where each method's name is prefixed with 'meta_get'
static ATMethod[]	Reflection.downBaseLevelMethods(ATObject atObj) Returns, for a given AmbientTalk object atObj, an array of NativeMethod objects corresponding to all non-static methods of that object's class, where each method's name: - is prefixed with 'base_' - is not prefixed with 'base_get' - is not prefixed with 'base_set'
static ATMethod[]	Reflection.downMetaLevelMethods(ATObject natObj) Returns, for a given AmbientTalk object natObj, an array of NativeMethod objects corresponding to all non-static methods of that object's class, where each method's name: - is prefixed with 'meta_' - is not prefixed with 'meta_get' - is not prefixed with 'meta_set'
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	OBJMirrorRoot.meta_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATNil	OBJMirrorRoot.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) The effect of assigning a field on a mirror can be twofold.
ATNil	NATMirage.magic_assignField(ATObject receiver, ATSymbol selector, ATObject value)
protected NATObject	NATMirage.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATNil	NATMirage.magic_defineField(ATSymbol name, ATObject value)
ATObject	NATMirage.magic_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.magic_select(ATObject receiver, ATSymbol selector)
ATNil	NATMirage.magic_assignVariable(ATSymbol name, ATObject value)
ATNil	NATMirage.meta_assignField(ATObject receiver, ATSymbol selector, ATObject value)
ATNil	NATMirage.meta_defineField(ATSymbol name, ATObject value)
ATObject	NATMirage.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments)
ATObject	NATMirage.meta_select(ATObject receiver, ATSymbol selector)
ATNil	NATMirage.meta_assignVariable(ATSymbol name, ATObject value)
ATNil	NativeField.base_writeField(ATObject newValue)
ATObject	NativeClosure.base_applyInScope(ATTable args, ATObject scope) A NativeClosure can also be directed to execute its wrapped NativeMethod in an externally specified scope.
static ATMirror	NATIntrospectiveMirror.atValue(ATObject objectRepresentation) Return a mirror on the given native or custom AmbientTalk object.
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_select(ATObject receiver, ATSymbol atSelector) The effect of selecting fields or methods on a mirror (through meta_select) consists of checking whether the requested selector matches a field of the principal wrapped by this mirror.
ATNil	NATIntrospectiveMirror.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) The effect of assigning a field on a mirror can be twofold.
protected NATObject	NATIntercessiveMirror.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.Class jClass, ATObject natReceiver, java.lang.String jSelector, ATObject[] jArguments) Invokes a method on a Java object identified by a selector.
static ATObject	JavaInterfaceAdaptor.invokeNativeATMethod(java.lang.reflect.Method javaMethod, ATObject jReceiver, ATObject[] jArguments) Invokes a method on a native AmbientTalk object identified by a java.lang.reflect.Method object.
static ATObject	JavaInterfaceAdaptor.createNativeATObject(java.lang.Class jClass, ATObject[] jInitArgs) Try to create a new instance of a Java class given an array of initialization arguments.
static java.lang.reflect.Method	JavaInterfaceAdaptor.getNativeATMethod(java.lang.Class baseInterface, ATObject receiver, java.lang.String methodName)
private static java.lang.Object[]	JavaInterfaceAdaptor.coerceArguments(ATObject[] args, java.lang.Class[] types)
static java.lang.Object	JavaInterfaceAdaptor.atObjectToPrimitiveJava(ATObject atObj, java.lang.Class type)

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

NATMirage(ATObject lexicalParent, NATIntercessiveMirror mirror)

NATMirage(ATObject dynamicParent, ATObject lexicalParent, NATIntercessiveMirror mirror, boolean parentType)

NATMirage(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, NATIntercessiveMirror mirror)
Constructs a new ambienttalk mirage as a clone of an existing one.

NativeField(ATObject host, ATSymbol name, java.lang.reflect.Method accessor, java.lang.reflect.Method mutator)

NativeClosure(ATObject scope)
Create a new NativeClosure where meta_apply will be overridden by anonymous subclasses.

NativeClosure(ATObject scope, NativeMethod meth)
Create a new NativeClosure where meta_apply will invoke the given Java Method.

NATIntrospectiveMirror(ATObject representation)
An introspective mirror is a wrapper which forwards a deified (upped) version of invoked methods and field accesses to its principal.

NATIntercessiveMirror(ATObject lexicalParent, boolean parentType)
Constructs a new ambienttalk mirror based on a set of parent pointers.

NATIntercessiveMirror(NATIntercessiveMirror dynamicParent, ATObject lexicalParent, boolean parentType)
Constructs a new ambienttalk mirror based on a set of parent pointers.

NATIntercessiveMirror(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, NATMirage base)
Constructs a new ambienttalk mirage as a clone of an existing one.

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

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

class	NATBoolean NATBoolean is simply a container class for ambienttalk booleans.
static class	NATBoolean.NATFalse
static class	NATBoolean.NATTrue
class	NATByCopy This class is the abstract superclass of all AT/2 object types which should be passed by copy when passed as a parameter between actors.
class	NATByRef This class is the abstract superclass of all AT/2 objects that require by-reference parameter passing semantics when passed between actors.
class	NATCallframe NATCallframe is a native implementation of a callframe.
class	NATClosure A NATClosure instance represents a first-class AmbientTalk closure.
class	NATClosureMethod A 'closure method' is literally a function that sits in between of a full closure and a method.
class	NATContext NATContext is a purely functional implementation of the ATContext interface.
class	NATDelegation Instances of the class NATMethodInvocation represent first-class method invocations.
class	NATException Instances of the class NATException provide a AmbientTalk representation for the default instances of all InterpreterExceptions.
class	NATField NATField implements a causally connected field of an object.
class	NATFraction The native implementation of an AmbientTalk fraction.
class	NATHandler TODO document the class NATHandler
class	NATMessage Instances of the class NATMessage represent first-class messages.
class	NATMethod NATMethod implements methods as named functions which are in fact simply containers for a name, a table of arguments and a body.
class	NATMethodInvocation Instances of the class NATMethodInvocation represent first-class method invocations.
class	NATNamespace Instances of the class NATNamespace represent namespace objects.
class	NATNil NATNil implements default semantics for all test and conversion methods.
class	NATNumber The native implementation of an AmbientTalk number.
class	NATNumeric A common superclass of both numbers and fractions to factor out common base-level behaviour.
class	NATObject Native implementation of a default ambienttalk object.
private class	NATObjectClosureTest.AGScopeTest This class is a special statement class used to test the correct scoping of method invocation from the java level, rather than by executing ambienttalk code directly.
class	NATStripe The native implementation of AmbientTalk stripe objects.
static class	NATStripe.OBJRootStripe The root stripe of the stripe hierarchy: every stripe eventually has this stripe as its parent.
class	NATTable The native implementation of an AmbientTalk table.
class	NATText The native implementation of an AmbientTalk text string.
class	OBJLexicalRoot An instance of the class OBJLexicalRoot represents the lexical root of an actor.
class	OBJSystem The sole instance of the class OBJSystem represents the 'system' object, accessible from the lexical root during execution of 'iat'.

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

ATObject[]	NATTable.elements_
private ATObject	NATObjectClosureTest.AGScopeTest.scope_
private ATObject	NATObjectClosureTest.AGScopeTest.self_
private ATObject	NATObjectClosureTest.AGScopeTest.super_
private ATObject	NATContext.scope_
private ATObject	NATContext.self_
private ATObject	NATClosureMethod.lexicalScope_
protected ATObject	NATCallframe.lexicalParent_ The lexical parent 'scope' of this call frame/object.
private ATObject	CustomFieldsTest.testField_

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

ATObject	SAFWorkingDirectory.initialize()
ATObject	SAFSystem.initialize()
ATObject	SAFLobby.initialize()
ATObject	OBJSystem.base_read() def read() { read character from standard input }
ATObject	OBJSystem.base_readln() def readln() { read next line from input }
ATObject	OBJSystem.base_reset() def reset() { reset VM into fresh startup state and re-evaluates init and main file } Resets the global lexical scope to an empty object.
private static ATObject	OBJLexicalRoot.performImport(ATObject sourceObject, ATContext ctx, java.util.Hashtable aliases, java.util.HashSet exclude) Performs the actual copying of the slots from the source object to the importing object.
ATObject	OBJLexicalRoot.base_get_opdiv_() '/' (the global namespace) '/' is an alias for 'lobby'
ATObject	OBJLexicalRoot.base_getLobby() lobby (the global namespace initialized using the objectpath)
ATObject	OBJLexicalRoot.base_getRoot() root (the global scope)
ATObject	OBJLexicalRoot.base_getJlobby() jlobby (the Java class package root, initialized using the Java classpath)
ATObject	OBJLexicalRoot.base_getNetwork() network (the network control object, to go online and offline)
ATObject	OBJLexicalRoot.base_if_then_(ATBoolean cond, ATClosure consequent) The if:then: primitive, which calls back on the boolean using ifTrue: usage: if: booleanCondition then: { consequent }
ATObject	OBJLexicalRoot.base_if_then_else_(ATBoolean cond, ATClosure consequent, ATClosure alternative) The if:then:else primitive, which calls back on the boolean using ifTrue:ifFalse: usage: if: booleanCondition then: { consequent } else: { alternative } pseudo-implementation: booleanCondition.ifTrue: { consequent } ifFalse: { alternative }
ATObject	OBJLexicalRoot.base_while_do_(ATClosure condition, ATClosure body) The while:do: primitive, which calls back on the closure using whileTrue: usage: while: { condition } do: { body } pseudo-implementation: { condition }.whileTrue: { body }
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_do_if_(ATClosure body, ATBoolean condition) The do:if: primitive, which in Ruby terminology is a 'statement modifier' usage: do: { body } if: condition pseudo-implementation: condition.ifTrue: { body }
ATObject	OBJLexicalRoot.base_do_unless_(ATClosure body, ATBoolean condition) The do:unless: primitive, which in Ruby terminology is a 'statement modifier' usage: do: { body } unless: condition pseudo-implementation: condition.ifFalse: { body }
ATObject	OBJLexicalRoot.base_let_(ATClosure body) The let: primitive, which allows for the easy creation of temporary local variables.
ATObject	OBJLexicalRoot.base_actor_(ATClosure code) actor: { code } == actor: { code } mirroredBy: The semantics of actor creation is as follows: - Mandatory parameters to the block of initialization code are treated as lexically visible variables that have to remain available in the new actor behaviour.
ATObject	OBJLexicalRoot.base_export_as_(ATObject object, ATStripe topic) export: object as: topic => object becomes discoverable by objects in other actors via topic returns a publication object that can be used to cancel the export
ATObject	OBJLexicalRoot.base_when_discovered_(ATStripe topic, ATClosure handler) when: topic discovered: { code } => when an object is exported by another actor under topic, trigger the code returns a subscription object that can be used to cancel the handler Once the code block has run once, it will not be triggered again.
ATObject	OBJLexicalRoot.base_whenever_discovered_(ATStripe topic, ATClosure handler) whenever: topic discovered: { code } => when an object is exported by another actor under topic, trigger the code returns a subscription object that can be used to cancel the handler The code block can be fired multiple times.
ATObject	OBJLexicalRoot.base_when_disconnected_(ATFarReference farReference, ATClosure listener) when: farReference disconnected: { code } => when the remote reference is broken due to network disconnections, trigger the code returns a subscription object that can be used to cancel the listener
ATObject	OBJLexicalRoot.base_when_reconnected_(ATFarReference farReference, ATClosure listener) when: farReference reconnected: { code } => when the remote reference is reinstated after a network disconnection, trigger the code returns a subscription object that can be used to cancel the listener
ATObject	OBJLexicalRoot.base_extend_with_(ATObject parent, ATClosure code) The extend:with: primitive, which delegates to the extend meta operation on the parent object.
ATObject	OBJLexicalRoot.base_object_(ATClosure code) The object: primitive, implemented as base-level code.
ATObject	OBJLexicalRoot.base_isolate_(ATClosure code) isolate: { code } => create an isolate object Equivalent to: object: { code } stripedWith: [ at.stripes.Isolate ]
ATObject	OBJLexicalRoot.base_share_with_(ATObject parent, ATClosure code) The share:with: primitive, which delegates to the share meta operation on the parent object.
ATObject	OBJLexicalRoot.base_reflect_(ATObject reflectee) The reflect: primitive, which returns a mirror on an object.
ATObject	OBJLexicalRoot.base_clone_(ATObject original) The clone: primitive, which returns a clone of an object.
ATObject	OBJLexicalRoot.base_mirror_(ATClosure code) The mirror: primitive, which allows creating custom mirrors which can be used to allow intercessive reflection on objects created from this mirror.
ATObject	OBJLexicalRoot.base_object_mirroredBy_(ATClosure code, NATIntercessiveMirror mirror) object: { code } mirroredBy: mirror => return an object mirage initialized with code
ATObject	OBJLexicalRoot.base_extend_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
ATObject	OBJLexicalRoot.base_share_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
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.
ATObject	OBJLexicalRoot.base_try_using_(ATClosure tryBlock, ATHandler handler) try: { tryBlock} using: handler Ad-hoc code for one exception handler
ATObject	OBJLexicalRoot.base_try_using_using_(ATClosure tryBlock, ATHandler hdl1, ATHandler hdl2) try: { tryBlock} using: handler1 using: handler2 Ad-hoc code for two exception handlers
ATObject	OBJLexicalRoot.base_try_using_using_using_(ATClosure tryBlock, ATHandler hdl1, ATHandler hdl2, ATHandler hdl3) try: { tryBlock} using: hdl1 using: hdl2 using: hdl3 Ad-hoc code for three exception handlers
ATObject	OBJLexicalRoot.base_try_catch_using_(ATClosure tryBlock, ATStripe filter, ATClosure replacementCode) try: { tryBlock} catch: stripe using: { |e| replacementCode } 'Syntactic sugar' for one in-line handler
ATObject	OBJLexicalRoot.base_try_catch_using_catch_using_(ATClosure tryBlock, ATStripe filter1, ATClosure hdl1, ATStripe filter2, ATClosure hdl2) try: { tryBlock } catch: stripe using: { |e| replacementCode } catch: stripe2 using: { |e| replacementCode2 } 'Syntactic sugar' for two in-line handlers
ATObject	OBJLexicalRoot.base_try_catch_using_catch_using_catch_using_(ATClosure tryBlock, ATStripe filter1, ATClosure hdl1, ATStripe filter2, ATClosure hdl2, ATStripe filter3, ATClosure hdl3) try: { tryBlock } catch: stripe using: { |e| replacementCode } catch: stripe2 using: { |e| replacementCode2 } catch: stripe3 using: { |e| replacementCode3 } 'Syntactic sugar' for three in-line handlers
ATObject	OBJLexicalRoot.base_handle_with_(ATStripe filter, ATClosure replacementCode) handle: stripe with: { |e| replacementCode } Creates a first-class handler from a filter prototype and some handler code.
ATObject	OBJLexicalRoot.base_eval_in_(ATAbstractGrammar ast, ATObject obj) eval: ast in: obj => evaluates the given AST in the context of the given object, returning its value
ATObject	OBJLexicalRoot.base_new(ATObject[] initargs) Invoking root.new(args) results in an exception for reasons of safety.
ATObject	OBJLexicalRoot.meta_resolve() After deserialization, ensure that the lexical root remains unique.
ATObject	NATTable.meta_eval(ATContext ctx) To evaluate a table, evaluate all of its constituent expressions, taking special care to take into account spliced expressions.
ATObject	NATTable.meta_quote(ATContext ctx) To quote a table, quote all elements of the table.
ATObject	NATTable.base_at(ATNumber index)
ATObject	NATTable.base_atPut(ATNumber index, ATObject value)
ATObject	NATTable.base_with_collect_(ATObject init, ATClosure clo)
ATObject	NATTable.base_find_(ATClosure clo)
static ATObject[]	NATTable.collate(ATObject[] ary1, ATObject[] ary2) Auxiliary method to collate two Java arrays
ATObject	NATTable.meta_resolve()
ATObject	NATObjectClosureTest.AGScopeTest.meta_eval(ATContext ctx)
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_select(ATObject receiver, ATSymbol selector) meta_select is used to evaluate code of the form o.m.
ATObject	NATObject.meta_lookup(ATSymbol selector) This method is used to evaluate code of the form selector within the scope of this object.
ATObject	NATObject.meta_clone() When cloning an object, it is first determined whether the parent has to be shared by the clone, or whether the parent must also be cloned.
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	NATObject.meta_extend(ATClosure code)
ATObject	NATObject.meta_share(ATClosure code)
protected ATObject	NATObject.createChild(ATClosure code, boolean parentPointerType) When creating children of objects, care must be taken that an extension of an isolate itself remains an isolate.
ATObject	NATObject.meta_pass() An isolate object does not return a proxy representation of itself during serialization, hence it is serialized itself.
ATObject	NATObject.meta_resolve() An isolate object represents itself upon deserialization.
ATObject	NATNil.meta_send(ATAsyncMessage message) Asynchronous messages ( o<-m( args )) sent in the context of an object o (i.e.
ATObject	NATNil.meta_receive(ATAsyncMessage message)
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_doesNotUnderstand(ATSymbol selector) By default, when a selection is not understood by a primitive object, an error is raised.
ATObject	NATNil.meta_select(ATObject receiver, ATSymbol selector) It is possible to select a method from any ambienttalk value provided that it offers the method in its provided interface.
ATObject	NATNil.meta_lookup(ATSymbol selector) A lookup can only be issued at the base level by writing selector inside the scope of a particular object.
ATObject	NATNil.meta_clone()
ATObject	NATNil.meta_newInstance(ATTable initargs)
protected ATObject	NATNil.createChild(ATClosure code, boolean parentPointerType)
ATObject	NATNil.meta_extend(ATClosure code)
ATObject	NATNil.meta_share(ATClosure code)
ATObject	NATNil.meta_eval(ATContext ctx) All NATObjects which are not Abstract Grammar elements are self-evaluating.
ATObject	NATNil.meta_quote(ATContext ctx) Quoting a native object returns itself, except for pure AG elements.
ATObject	NATNil.meta_getDynamicParent() Only true extending objects have a dynamic pointer, others return nil
ATObject	NATNil.meta_getLexicalParent() By default numbers, tables and so on do not have lexical parents,
ATObject	NATNil.base_new(ATObject[] initargs)
ATObject	NATNil.base_init(ATObject[] initargs)
ATObject	NATNil.meta_pass() This method allows objects to decide which object should be serialized in their stead when they are passed as argument in an asynchronous message send that crosses actor boundaries.
ATObject	NATNil.meta_resolve() After deserialization, ensure that nil remains unique.
ATObject	NATNamespace.meta_doesNotUnderstand(ATSymbol selector) For a namespace object, doesNotUnderstand triggers the querying of the local file system to load files corresponding to the missing selector.
ATObject	NATMethodInvocation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a method invocation, invoke the method corresponding to the encapsulated selector to the given receiver with the encapsulated arguments.
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.
ATObject	NATHandler.base_handle(ATObject anException)
ATObject	NATField.base_readField()
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	NATDelegation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a delegating message send, invoke the method corresponding to the encapsulated selector with the encapsulated arguments.
ATObject	NATContext.base_getLexicalScope()
ATObject	NATContext.base_getSelf()
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	NATClosure.base_whileTrue_(ATClosure body) receiver is a zero-argument block closure returning a boolean
ATObject	NATClosure.base_escape() The following is a pseudo-code implementation of escape.
ATObject	NATCallframe.meta_invoke(ATObject receiver, ATSymbol selector, ATTable arguments) Normally, call frames are not used in receiverful method invocation expressions.
ATObject	NATCallframe.meta_doesNotUnderstand(ATSymbol selector) By default, when a selection is not understood by an AmbientTalk object or call frame, an error is raised.
ATObject	NATCallframe.meta_select(ATObject receiver, ATSymbol selector) This method is used in the evaluation of the code o.m.
ATObject	NATCallframe.meta_lookup(ATSymbol selector) This method is used to evaluate code of the form selector within the scope of this call frame.
ATObject	NATCallframe.meta_clone()
ATObject	NATCallframe.meta_newInstance(ATTable initargs)
ATObject	NATCallframe.meta_extend(ATClosure code)
ATObject	NATCallframe.meta_share(ATClosure code)
ATObject	NATCallframe.meta_getDynamicParent()
ATObject	NATCallframe.meta_getLexicalParent()
protected ATObject	NATCallframe.getLocalField(ATSymbol selector) Reads out the value of either a native or a custom field.
ATObject	NATByRef.meta_pass() By reference objects serialize to a proxy representation.
ATObject	NATByRef.meta_resolve() By reference objects cannot be deserialized, by definition.
ATObject	NATByCopy.meta_pass() When a by-copy object is asked which object to serialize in its stead, the by-copy object returns itself, so that it itself will be serialized.
ATObject	NATByCopy.meta_resolve() When a by-copy object is asked which object it represents when it is deserialized, the object returns itself.
ATObject	NATBoolean.NATTrue.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)
ATObject	NATBoolean.NATFalse.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)

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

ATNil	OBJSystem.base_print(ATObject[] objs) def print(@obj) { print obj to standard output }
ATNil	OBJSystem.base_println(ATObject[] objs) def println(@obj) { self.print(#[@obj, '\n']) }
private static ATObject	OBJLexicalRoot.performImport(ATObject sourceObject, ATContext ctx, java.util.Hashtable aliases, java.util.HashSet exclude) Performs the actual copying of the slots from the source object to the importing object.
ATObject	OBJLexicalRoot.base_export_as_(ATObject object, ATStripe topic) export: object as: topic => object becomes discoverable by objects in other actors via topic returns a publication object that can be used to cancel the export
ATObject	OBJLexicalRoot.base_extend_with_(ATObject parent, ATClosure code) The extend:with: primitive, which delegates to the extend meta operation on the parent object.
ATObject	OBJLexicalRoot.base_share_with_(ATObject parent, ATClosure code) The share:with: primitive, which delegates to the share meta operation on the parent object.
ATObject	OBJLexicalRoot.base_reflect_(ATObject reflectee) The reflect: primitive, which returns a mirror on an object.
ATObject	OBJLexicalRoot.base_clone_(ATObject original) The clone: primitive, which returns a clone of an object.
ATObject	OBJLexicalRoot.base_extend_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
ATObject	OBJLexicalRoot.base_share_with_mirroredBy_(ATObject parent, ATClosure code, NATIntercessiveMirror mirror)
ATBoolean	OBJLexicalRoot.base_is_stripedWith_(ATObject object, ATStripe stripe) is: object stripedWith: stripe => returns true if the given object is striped with the given stripe
ATTable	OBJLexicalRoot.base_stripesOf_(ATObject object) stripesOf: object => returns all of the stripes of an object
ATNil	OBJLexicalRoot.base_raise_(ATObject anExceptionObject) raise: exception Raises an exception which can be caught by dynamically installed try-catch-using blocks.
ATObject	OBJLexicalRoot.base_eval_in_(ATAbstractGrammar ast, ATObject obj) eval: ast in: obj => evaluates the given AST in the context of the given object, returning its value
ATText	OBJLexicalRoot.base_print_(ATObject obj) print: expression => string representing the expression
ATBoolean	OBJLexicalRoot.base__opeql__opeql_(ATObject comparand)
ATObject	OBJLexicalRoot.base_new(ATObject[] initargs) Invoking root.new(args) results in an exception for reasons of safety.
ATText	NATText.base__oppls_(ATObject other)
static NATTable	NATTable.atValue(ATObject[] array) Table factory method.
static NATTable	NATTable.of(ATObject one)
static NATTable	NATTable.of(ATObject one, ATObject two)
static NATTable	NATTable.of(ATObject one, ATObject two, ATObject three)
ATObject	NATTable.base_atPut(ATNumber index, ATObject value)
ATObject	NATTable.base_with_collect_(ATObject init, ATClosure clo)
static ATObject[]	NATTable.collate(ATObject[] ary1, ATObject[] ary2) Auxiliary method to collate two Java arrays
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_select(ATObject receiver, ATSymbol selector) meta_select is used to evaluate code of the form o.m.
ATNil	NATObject.meta_defineField(ATSymbol name, ATObject value) When a new field is defined in an object, it is important to check whether or not the field map is shared between clones or not.
ATNil	NATObject.meta_assignField(ATObject receiver, ATSymbol selector, ATObject value) meta_assignField is used to evaluate code of the form o.m := v.
protected NATObject	NATObject.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList originalCustomFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATBoolean	NATObject.meta_isCloneOf(ATObject original)
ATBoolean	NATObject.meta_isRelatedTo(ATObject object)
static ATField[]	NATObject.listTransitiveFields(ATObject obj) Auxiliary method to access the fields of an object and all of its super-objects up to (but excluding) nil.
static ATMethod[]	NATObject.listTransitiveMethods(ATObject obj) Auxiliary method to access the methods of an object and all of its super-objects up to (but excluding) nil.
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_select(ATObject receiver, ATSymbol selector) It is possible to select a method from any ambienttalk value provided that it offers the method in its provided interface.
ATNil	NATNil.meta_defineField(ATSymbol name, ATObject value)
ATNil	NATNil.meta_assignVariable(ATSymbol name, ATObject value) Normally, a variable assignment cannot be performed on a native AmbientTalk object.
ATNil	NATNil.meta_assignField(ATObject receiver, ATSymbol name, ATObject value)
ATBoolean	NATNil.base__opeql__opeql_(ATObject comparand)
ATObject	NATNil.base_new(ATObject[] initargs)
ATObject	NATNil.base_init(ATObject[] initargs)
ATBoolean	NATNil.meta_isCloneOf(ATObject original)
ATBoolean	NATNil.meta_isRelatedTo(ATObject object)
protected NATObject	NATNamespace.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
ATObject	NATMethodInvocation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a method invocation, invoke the method corresponding to the encapsulated selector to the given receiver with the encapsulated arguments.
ATBoolean	NATHandler.base_canHandle(ATObject anException)
ATObject	NATHandler.base_handle(ATObject anException)
ATNil	NATField.base_writeField(ATObject newValue)
ATBoolean	NATException.meta_isRelatedTo(ATObject object)
ATObject	NATDelegation.base_sendTo(ATObject receiver, ATObject sender) To evaluate a delegating message send, invoke the method corresponding to the encapsulated selector with the encapsulated arguments.
ATContext	NATContext.base_withLexicalEnvironment(ATObject scope)
ATContext	NATContext.base_withDynamicReceiver(ATObject self)
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_select(ATObject receiver, ATSymbol selector) This method is used in the evaluation of the code o.m.
ATNil	NATCallframe.meta_defineField(ATSymbol name, ATObject value) A field can be added to either a call frame or an object.
ATNil	NATCallframe.meta_assignVariable(ATSymbol name, ATObject value) A field can be assigned in either a call frame or an object.
ATNil	NATCallframe.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Assigning a call frame's field externally is possible and is treated as if it were a variable assignment.
ATBoolean	NATCallframe.meta_isCloneOf(ATObject original)
ATBoolean	NATCallframe.meta_isRelatedTo(ATObject object)
protected boolean	NATCallframe.setLocalField(ATSymbol selector, ATObject value) Set a given field if it exists.
private void	ExceptionHandlingTest.setUpTestStripes(ATObject testScope)

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

NATTable(ATObject[] elements)

NATObjectClosureTest.AGScopeTest(ATObject scope, ATObject self, ATObject zuper)

NATObject(ATObject lexicalParent)
Constructs a new ambienttalk object parametrised by a lexical scope.

NATObject(ATObject lexicalParent, ATStripe[] stripes)
Constructs a new ambienttalk object parametrised by a lexical scope.

NATObject(ATObject dynamicParent, boolean parentType)
Constructs a new ambienttalk object with the given dynamic parent.

NATObject(ATObject dynamicParent, ATObject lexicalParent, boolean parentType)
Constructs a new ambienttalk object based on a set of parent pointers.

NATObject(ATObject dynamicParent, ATObject lexicalParent, boolean parentType, ATStripe[] stripes)
Constructs a new ambienttalk object based on a set of parent pointers.

NATObject(FieldMap map, java.util.Vector state, java.util.LinkedList originalCustomFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
Constructs a new ambienttalk object as a clone of an existing object.

NATNamespace(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, java.io.File path, java.lang.String name)
Private constructor used only for cloning

NATDelegation(ATObject delegator, ATSymbol sel, ATTable arg)

NATContext(ATObject scope, ATObject self)

NATClosureMethod(ATObject scope, ATMethod method)

NATClosure(ATMethod method, ATObject implementor, ATObject receiver)
This constructor creates a closure with a bound dynamic receiver, and it is called after the succesful lookup of a receiverful message.

NATCallframe(ATObject lexicalParent)

NATCallframe(FieldMap varMap, java.util.Vector stateVector, ATObject lexicalParent, java.util.LinkedList customFields)
Used internally for cloning a callframe/object.

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

Classes in edu.vub.at.objects.natives.grammar that implement ATObject

class	AGApplication
class	AGAssignField
class	AGAssignTable
class	AGAssignVariable
class	AGAsyncMessageCreation AGAsyncMessageCreation implements the ATAsyncMessageCreation interface natively.
class	AGBegin AGBegin represents the abstract grammar element of a list of statements.
class	AGClosureLiteral The native implementation of a literal closure AG element.
class	AGDefExternalField Represents the abstract grammar for defining external fields.
class	AGDefExternalMethod The native implementation of an external method definition abstract grammar element.
class	AGDefField
class	AGDefFunction The native implementation of a function definition abstract grammar element.
class	AGDefStripe The native AST node for the code: def stripename; def stripename < superstripename;
class	AGDefTable
class	AGDelegationCreation The native implementation of a first-class delegating message send.
class	AGExpression
class	AGMessageCreation
class	AGMessageSend
class	AGMethodInvocationCreation
class	AGMultiAssignment
class	AGMultiDefinition
class	AGQuote
class	AGSelection
class	AGSelf
class	AGSplice
class	AGSymbol
class	AGTabulation
class	AGUnquote
class	AGUnquoteSplice
class	NATAbstractGrammar

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

ATObject	AGUnquoteSplice.meta_eval(ATContext ctx) An unquotation cannot be evaluated, but rather gives rise to an XIllegalUnquote exception.
ATObject	AGUnquoteSplice.meta_quote(ATContext ctx) Quoting a spliced unquotation means evaluating its contained expression, and returning its value as the result of the quote.
ATObject	AGUnquote.meta_eval(ATContext ctx) An unquotation cannot be evaluated, but rather gives rise to an XIllegalUnquote exception.
ATObject	AGUnquote.meta_quote(ATContext ctx) Quoting an unquotation means evaluating its contained expression, and returning its value as the result of the quote.
ATObject	AGTabulation.meta_eval(ATContext ctx) To evaluate a tabulation, evaluate the tabulation expression to a table, evaluate the index expression into a valid index, and then access the table at the given index slot.
ATObject	AGTabulation.meta_quote(ATContext ctx) Quoting a tabulation results in a new quoted tabulation AGTBL(tbl,idx).quote(ctx) = AGTBL(tbl.quote(ctx),idx.quote(ctx))
ATObject	AGSymbol.meta_eval(ATContext ctx) To evaluate a symbol reference, look up the symbol in the lexical scope.
ATObject	AGSymbol.meta_quote(ATContext ctx) Quoting a symbol results in the same symbol.
ATObject	AGSymbol.meta_resolve() After deserialization, ensure that the symbol remains unique.
ATObject	AGSplice.meta_eval(ATContext ctx) A spliced element cannot be evaluated, but rather gives rise to an XIllegalSplice exception.
ATObject	AGSplice.meta_quote(ATContext ctx) Quoting a splice means quoting its contained expression, and returning a new splice.
ATObject	AGSelf.meta_eval(ATContext ctx) To evaluate a self reference, simply select the current self from the current evaluation context.
ATObject	AGSelf.meta_quote(ATContext ctx) Quoting a self reference results in the same self reference.
ATObject	AGSelection.meta_eval(ATContext ctx) To evaluate a selection, evaluate the receiver expression to an object and select the slot with the given name from that object.
ATObject	AGSelection.meta_quote(ATContext ctx) Quoting a selection results in a new quoted selection.
ATObject	AGQuote.meta_eval(ATContext ctx) To evaluate a quotation, start quoting its contained statement.
ATObject	AGQuote.meta_quote(ATContext ctx) Quoting a quotation results in a bare quotation, where quotations and unquotations are left unexpanded.
ATObject	AGMultiDefinition.meta_eval(ATContext ctx) To evaluate a multiple definition, evaluate the right hand side to a table and bind the parameters on the left hand side to the 'arguments' of the right hand side, exactly as if they were bound during a function call.
ATObject	AGMultiDefinition.meta_quote(ATContext ctx) AGMULTIDEF(par,val).quote(ctx) = AGMULTIDEF(par.quote(ctx), val.quote(ctx))
ATObject	AGMultiAssignment.meta_eval(ATContext ctx) To evaluate a multiple assignment, evaluate the right hand side to a table and assign the parameters on the left hand side to the 'arguments' of the right hand side, almost as if they were bound during a function call (the parameters are assigned instead of defined).
ATObject	AGMultiAssignment.meta_quote(ATContext ctx) AGMULTIASS(par,val).quote(ctx) = AGMULTIASS(par.quote(ctx), val.quote(ctx))
ATObject	AGMethodInvocationCreation.meta_eval(ATContext ctx) To evaluate a first-class synchronous message creation AG element, transform the selector and evaluated arguments into a first-class MethodInvocation.
protected ATObject	AGMethodInvocationCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)
ATObject	AGMessageSend.meta_eval(ATContext ctx) To evaluate a message send, evaluate the receiver expression into an object.
ATObject	AGMessageSend.meta_quote(ATContext ctx) Quoting a message send returns a new quoted message send.
ATObject	AGMessageCreation.meta_quote(ATContext ctx) Quoting a message creation element returns a new quoted message creation element.
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.
ATObject	AGDelegationCreation.meta_eval(ATContext ctx) To evaluate a first-class delegation message creation AG element, transform the selector and evaluated arguments into a first-class NATDelegation object.
protected ATObject	AGDelegationCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)
ATObject	AGDefTable.meta_eval(ATContext ctx) Defining a table requires evaluating its index expression to a size s, then allocating a new table of size s and finally initializing it by evaluating its initializer body s times.
ATObject	AGDefTable.meta_quote(ATContext ctx) Quoting a table definition results in a new quoted table definition.
ATObject	AGDefStripe.meta_eval(ATContext ctx) Defines a new stripe in the current scope.
ATObject	AGDefStripe.meta_quote(ATContext ctx) Quoting a stripe definition results in a new quoted stripe definition.
ATObject	AGDefFunction.meta_eval(ATContext ctx) Defines a new function (method or closure) in the current scope.
ATObject	AGDefFunction.meta_quote(ATContext ctx) Quoting a function definition results in a new quoted function definition.
ATObject	AGDefField.meta_eval(ATContext ctx) Defines a new field in the current scope.
ATObject	AGDefField.meta_quote(ATContext ctx) Quoting a field definition results in a new quoted field definition.
ATObject	AGDefExternalMethod.meta_eval(ATContext ctx) Evaluates the receiver symbol to an object to which a new 'closure method' will be added.
ATObject	AGDefExternalMethod.meta_quote(ATContext ctx) Quoting an external method definition results in a new quoted external method definition.
ATObject	AGDefExternalField.meta_eval(ATContext ctx) Defines a new field in the object denoted by the receiver symbol.
ATObject	AGDefExternalField.meta_quote(ATContext ctx) Quoting an external field definition results in a new quoted external field definition.
ATObject	AGClosureLiteral.meta_eval(ATContext ctx) To evaluate a closure literal, construct a closure pairing the literal's arguments and body with the current evaluation context.
ATObject	AGClosureLiteral.meta_quote(ATContext ctx) Quoting a closure literal results in a new quoted closure literal.
ATObject	AGBegin.meta_eval(ATContext ctx) AGBEGIN encapsulates a sequence of statements and evaluates each of these statements in turn.
ATObject	AGBegin.meta_quote(ATContext ctx) AGBEGIN(statements*).quote(ctx) = AGBEGIN((statements*).quote(ctx))
ATObject	AGAsyncMessageCreation.meta_eval(ATContext ctx) To evaluate an async message creation element, simply return a new native asynchronous message.
protected ATObject	AGAsyncMessageCreation.newQuoted(ATSymbol quotedSel, ATTable quotedArgs)
ATObject	AGAssignVariable.meta_eval(ATContext ctx) To evaluate a variable assignment, evaluate the right hand side and ask the current object to assign that value to the field corresponding to the left hand side.
ATObject	AGAssignVariable.meta_quote(ATContext ctx) AGASSVAR(nam,val).quote(ctx) = AGASSVAR(nam.quote(ctx), val.quote(ctx))
ATObject	AGAssignTable.meta_eval(ATContext ctx) To evaluate a table assignment, evaluate its table expression to a valid ATTable.
ATObject	AGAssignTable.meta_quote(ATContext ctx) Quoting a table assignment results in a new quoted table assignment.
ATObject	AGAssignField.meta_eval(ATContext ctx) To evaluate a field assignment, evaluate the receiver expression, evaluate the right hand side and ask the receiver object to assign the RHS value to the field corresponding to the given field name.
ATObject	AGAssignField.meta_quote(ATContext ctx) AGASSFIELD(rcv,nam,val).quote(ctx) = AGASSFIELD(rcv.quote(ctx), nam.quote(ctx), val.quote(ctx))
ATObject	AGApplication.meta_eval(ATContext ctx) To evaluate a function application, evaluate the receiver expression to a function, then evaluate the arguments to the function application eagerly and apply the function.
ATObject	AGApplication.meta_quote(ATContext ctx) Quoting an application results in a new quoted application.

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

private void	TestParameterBinding.ensureBound(ATSymbol var, ATObject value)
private void	TestParameterBinding.ensureBoundToTable(ATSymbol var, ATObject[] expected)
ATTable	AGSymbol.base__opmns__opgtx_(ATObject obj)

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

Subinterfaces of ATObject in edu.vub.at.objects.symbiosis

interface

ATJavaClosure The public interface to a closure pairing a Java wrapper object with a symbiotic Java method.

Classes in edu.vub.at.objects.symbiosis that implement ATObject

class	JavaClass A JavaClass instance represents a Java Class under symbiosis.
class	JavaClosure A JavaClosure pairs a JavaMethod (a bundle of native overloaded java.lang.reflect.Method objects) together with a Java object receiver.
class	JavaField A JavaField is a simple wrapper around a native java.lang.reflect.Field
class	JavaMethod JavaMethod is a wrapper class encapsulating one or more java.lang.reflect.Method objects.
class	JavaObject JavaObject instances represent java objects under symbiosis.
class	JavaPackage A JavaPackage represents (part of) a Java package name and serves the same purpose as AmbientTalk Namespace objects, but for loading Java classes rather than AT objects.

Fields in edu.vub.at.objects.symbiosis declared as ATObject

private ATObject

JavaClosure.scope_

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

static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.Class ofClass, java.lang.String selector, ATObject[] atArgs)
static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.String selector, JavaMethod jMethod, ATObject[] atArgs) The Java method invocation algorithm is as follows: case of # of methods matching selector: 0 => XSelectorNotFound 1 => invoke the method OR XIllegalArgument, XArityMismatch, XReflectionFailure * => (case of # of methods with matching arity OR taking varargs: 0 => XSymbiosisFailure 1 => invoke the method OR XIllegalArgument, XReflectionFailure * => (case of # of methods matching 'default type' of the actual arguments: 0 => XSymbiosisFailure 1 => invoke OR XReflectionFailure * => XSymbiosisFailure)) A Java method takes a variable number of AT arguments <=> it has one formal parameter of type ATObject[]
static ATObject	Symbiosis.symbioticInstanceCreation(java.lang.Class ofClass, ATObject[] atArgs) Creates a new instance of a Java class.
static ATObject	Symbiosis.readField(java.lang.Object fromObject, java.lang.Class ofClass, java.lang.String fieldName) Read a field from the given Java object reflectively.
static ATObject	Symbiosis.readField(java.lang.Object fromObject, java.lang.reflect.Field f) Read a field from the given Java object reflectively.
static ATObject	Symbiosis.javaToAmbientTalk(java.lang.Object jObj) Convert a Java object into an AmbientTalk object.
private static ATObject	Symbiosis.invokeUniqueSymbioticMethod(java.lang.Object symbiont, java.lang.reflect.Method javaMethod, java.lang.Object[] jArgs)
private static ATObject	Symbiosis.invokeUniqueSymbioticConstructor(java.lang.reflect.Constructor ctor, java.lang.Object[] jArgs)
ATObject	JavaPackage.meta_doesNotUnderstand(ATSymbol selector) For a JavaPackage object, doesNotUnderstand triggers the querying of the Java classpath to load classes corresponding to the missing selector.
ATObject	JavaPackage.base_class(ATSymbol selector) Allows the AT programmer to explicitly load a class.
ATObject	JavaPackage.base_package(ATSymbol selector) Allows the AT programmer to explicitly load a package.
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_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java object, if the Java symbiont object's class has a non-static field with a matching selector, it is automatically read; if it has a corresponding method, the method is returned in a closure.
ATObject	JavaObject.meta_lookup(ATSymbol selector) A variable lookup is resolved by first checking whether the Java object has a field with a matching name.
ATObject	JavaObject.meta_clone() Cloning a symbiotic object is not always possible as Java has no uniform cloning semantics.
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	JavaObject.meta_pass() Passing a Java Object wrapper to another actor has the following effect: - if the wrapped Java object is serializable, the symbiotic AmbientTalk object is treated as by copy (i.e. as an isolate)
ATObject	JavaObject.meta_resolve() If the wrapped object was serializable, we may be asked to resolve ourselves.
ATObject	JavaMethod.base_apply(ATTable arguments, ATContext ctx)
ATObject	JavaMethod.base_applyInScope(ATTable arguments, ATContext ctx)
ATObject	JavaField.base_readField()
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_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java class object, if the object's class has a static field with a matching selector, it is automatically read; if it has methods corresponding to the selector, they are returned in a JavaMethod wrapper, otherwise, the fields of its AT symbiont are checked.
ATObject	JavaClass.meta_lookup(ATSymbol selector) A variable lookup is resolved by first checking whether the Java object has an appropriate static field with a matching name.
ATObject	JavaClass.meta_clone() Symbiotic Java class objects are singletons.
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.
ATObject	JavaClass.meta_resolve() A Java Class object remains unique within an actor.

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

java.lang.Object	SymbiosisTest.overloadedvararg(ATObject[] varargs)
static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.Class ofClass, java.lang.String selector, ATObject[] atArgs)
static ATObject	Symbiosis.symbioticInvocation(ATObject wrapper, java.lang.Object symbiont, java.lang.String selector, JavaMethod jMethod, ATObject[] atArgs) The Java method invocation algorithm is as follows: case of # of methods matching selector: 0 => XSelectorNotFound 1 => invoke the method OR XIllegalArgument, XArityMismatch, XReflectionFailure * => (case of # of methods with matching arity OR taking varargs: 0 => XSymbiosisFailure 1 => invoke the method OR XIllegalArgument, XReflectionFailure * => (case of # of methods matching 'default type' of the actual arguments: 0 => XSymbiosisFailure 1 => invoke OR XReflectionFailure * => XSymbiosisFailure)) A Java method takes a variable number of AT arguments <=> it has one formal parameter of type ATObject[]
static ATObject	Symbiosis.symbioticInstanceCreation(java.lang.Class ofClass, ATObject[] atArgs) Creates a new instance of a Java class.
static void	Symbiosis.writeField(java.lang.Object toObject, java.lang.Class ofClass, java.lang.String fieldName, ATObject value) Write a field in the given Java object reflectively.
static void	Symbiosis.writeField(java.lang.Object toObject, java.lang.reflect.Field f, ATObject value) Write a field in the given Java object reflectively.
static java.lang.Object	Symbiosis.ambientTalkToJava(ATObject atObj, java.lang.Class targetType) Convert an AmbientTalk object into an equivalent Java object.
private static java.lang.Object[]	Symbiosis.atArgsToJavaArgs(ATObject[] args, java.lang.Class[] types)
protected NATObject	JavaPackage.createClone(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes)
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_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java object, if the Java symbiont object's class has a non-static field with a matching selector, it is automatically read; if it has a corresponding method, the method is returned in a closure.
ATNil	JavaObject.meta_defineField(ATSymbol name, ATObject value) Fields can be defined within a symbiotic Java object.
ATNil	JavaObject.meta_assignVariable(ATSymbol name, ATObject value) Variables can be assigned within a symbiotic Java object if that object's class has a mutable field with a matching name.
ATNil	JavaObject.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Fields can be assigned within a symbiotic Java object if that object's class has a mutable field with a matching name.
ATBoolean	JavaObject.meta_isCloneOf(ATObject original)
ATNil	JavaField.base_writeField(ATObject newValue)
ATClosure	JavaClosure.base_cast(ATObject[] types) For each Method in the wrapped JavaMethod's choices_, check whether it is compatible with the given types.
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_select(ATObject receiver, ATSymbol selector) When selecting a field from a symbiotic Java class object, if the object's class has a static field with a matching selector, it is automatically read; if it has methods corresponding to the selector, they are returned in a JavaMethod wrapper, otherwise, the fields of its AT symbiont are checked.
ATNil	JavaClass.meta_defineField(ATSymbol name, ATObject value) Fields can be defined within a symbiotic Java class object.
ATNil	JavaClass.meta_assignVariable(ATSymbol name, ATObject value) Variables can be assigned within a symbiotic Java class object if that class object has a mutable static field with a matching name.
ATNil	JavaClass.meta_assignField(ATObject receiver, ATSymbol name, ATObject value) Fields can be assigned within a symbiotic Java class object if that class has a mutable field with a matching name.
ATBoolean	JavaClass.meta_isCloneOf(ATObject original)
ATClosure	ATJavaClosure.base_cast(ATObject[] types) Using this method, AmbientTalk symbiotic code is able to perform manual overloaded method disambiguation.

Constructors in edu.vub.at.objects.symbiosis with parameters of type ATObject

JavaPackage(FieldMap map, java.util.Vector state, java.util.LinkedList customFields, MethodDictionary methodDict, ATObject dynamicParent, ATObject lexicalParent, byte flags, ATStripe[] stripes, java.lang.String path)
Private constructor used only for cloning

JavaClosure(ATObject scope, JavaMethod meth)

Uses of ATObject in edu.vub.at.parser

Classes in edu.vub.at.parser that implement ATObject

class

NATParser The class NATParser is a front-end (or Facade) to hide the details of the parser from the ambienttalk core interpreter.

Methods in edu.vub.at.parser that return ATObject

ATObject

NATParser.meta_resolve() After deserialization, ensure that the parser remains unique.