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

Packages that use ATClosure

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

Uses of ATClosure in edu.vub.at

Fields in edu.vub.at declared as ATClosure

protected ATClosure

AmbientTalkTestCase.unittest_

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

ATObject

OBJUnit.base_unittest_(ATClosure code) The unittest: primitive, implemented as base-level code.

Uses of ATClosure in edu.vub.at.actors

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

ATClosure

ATObservable.base_upon_do_(ATSymbol event, ATClosure observer) Installs an observer on this object

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

ATClosure	ATObservable.base_upon_do_(ATSymbol event, ATClosure observer) Installs an observer on this object
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.

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

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

void	NATRemoteFarRef.onDisconnection(ATClosure listener)
void	NATRemoteFarRef.onReconnection(ATClosure listener)
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	NATActorMirror.base_require(ATStripe topic, ATClosure handler, ATBoolean isPermanent)
ATObject	NATActorMirror.base_install_(ATClosure code) def install: { code }

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

NATFarReference.NATDisconnectionSubscription(NATFarReference reference, ATClosure handler)

NATFarReference.NATReconnectionSubscription(NATFarReference reference, ATClosure handler)

NATActorMirror.NATSubscription(ELDiscoveryActor discoveryActor, ATStripe topic, ATClosure handler, DiscoveryManager.Subscription sub)

Uses of ATClosure in edu.vub.at.eval

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

void	InvocationStack.functionCalled(ATExpression funCall, ATClosure fun, ATTable evaluatedArgs)

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

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

ATClosure

SignalEscape.originatingBlock

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

SignalEscape(ATClosure originatingBlock, ATObject returnedValue)

Uses of ATClosure in edu.vub.at.objects

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

ATObject	ATBoolean.base_ifTrue_(ATClosure cons)
ATObject	ATBoolean.base_ifFalse_(ATClosure alt)
ATObject	ATBoolean.base_ifTrue_ifFalse_(ATClosure cons, ATClosure alt)
ATBoolean	ATBoolean.base_and_(ATClosure other)
ATBoolean	ATBoolean.base_or_(ATClosure other)
ATNil	ATNumber.base_doTimes_(ATClosure code)
ATNil	ATNumber.base_to_do_(ATNumber end, ATClosure code)
ATNil	ATNumber.base_to_step_do_(ATNumber end, ATNumber inc, ATClosure code)
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.
ATNil	ATTable.base_each_(ATClosure clo) Apply a closure to each element of the table
ATTable	ATTable.base_map_(ATClosure clo) Map a closure over each element of the table, resulting in a new table.
ATObject	ATTable.base_with_collect_(ATObject init, ATClosure clo) Collect all elements of the table by combining them using the given closure.
ATTable	ATTable.base_filter_(ATClosure clo) Keep only those elements of the table for which the closure evaluates to true.
ATObject	ATTable.base_find_(ATClosure clo) Return the index of the first element for which the given predicate returns true.
ATNil	ATText.base_find_do_(ATText regexp, ATClosure consumer)
ATText	ATText.base_replace_by_(ATText regexp, ATClosure transformer)
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.

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

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

ATClosure

ATConversions.base_asClosure()

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

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

class

NativeClosure A NativeClosure is a wrapper class for a piece of Java code.

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

protected ATObject	OBJMirrorRoot.createChild(ATClosure code, boolean parentPointerType)
ATObject	NATMirage.magic_extend(ATClosure code)
ATObject	NATMirage.magic_share(ATClosure code)
ATObject	NATMirage.meta_extend(ATClosure code)
ATObject	NATMirage.meta_share(ATClosure code)
protected ATObject	NATIntercessiveMirror.createChild(ATClosure code, boolean parentPointerType)

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

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

class

NATClosure A NATClosure instance represents a first-class AmbientTalk closure.

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

private ATClosure

NATHandler.handler_

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

ATClosure	NATObject.base_asClosure()
ATClosure	NATNil.base_asClosure()
ATClosure	NATClosure.base_asClosure()

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

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_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_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.
ATNil	NATText.base_find_do_(ATText regexp, ATClosure consumer)
ATText	NATText.base_replace_by_(ATText regexp, ATClosure transformer)
ATNil	NATTable.base_each_(ATClosure clo)
ATTable	NATTable.base_map_(ATClosure clo)
ATObject	NATTable.base_with_collect_(ATObject init, ATClosure clo)
ATTable	NATTable.base_filter_(ATClosure clo)
ATObject	NATTable.base_find_(ATClosure clo)
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.
ATNil	NATNumber.base_doTimes_(ATClosure code) NBR(n).doTimes: { |i| code } => for i = 1 to n do code.eval(i) ; nil
ATNil	NATNumber.base_to_do_(ATNumber end, ATClosure code) NBR(start).to: NBR(stop) do: { |i| code } => for i = start to stop do code.eval(i) ; nil Also works if stop > start, in which case it becomes a downTo.
ATNil	NATNumber.base_to_step_do_(ATNumber end, ATNumber inc, ATClosure code) NBR(start).to: NBR(stop) step: NBR(inc) do: { |i| code } => for i = start; i < stop; i++ do code.eval(i) ; nil Also works if stop > start, in which case it becomes a downTo.
protected ATObject	NATNil.createChild(ATClosure code, boolean parentPointerType)
ATObject	NATNil.meta_extend(ATClosure code)
ATObject	NATNil.meta_share(ATClosure code)
ATObject	NATClosure.base_whileTrue_(ATClosure body) receiver is a zero-argument block closure returning a boolean
ATObject	NATCallframe.meta_extend(ATClosure code)
ATObject	NATCallframe.meta_share(ATClosure code)
ATObject	NATBoolean.NATTrue.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATTrue.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)
ATBoolean	NATBoolean.NATTrue.base_and_(ATClosure other)
ATBoolean	NATBoolean.NATTrue.base_or_(ATClosure other)
ATObject	NATBoolean.NATFalse.base_ifTrue_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifFalse_(ATClosure clo)
ATObject	NATBoolean.NATFalse.base_ifTrue_ifFalse_(ATClosure consequent, ATClosure alternative)
ATBoolean	NATBoolean.NATFalse.base_and_(ATClosure other)
ATBoolean	NATBoolean.NATFalse.base_or_(ATClosure other)

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

NATHandler(ATStripe filter, ATClosure handler)

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

Subinterfaces of ATClosure 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 ATClosure

class

JavaClosure A JavaClosure pairs a JavaMethod (a bundle of native overloaded java.lang.reflect.Method objects) together with a Java object receiver.

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

ATClosure	JavaClosure.base_cast(ATObject[] types) For each Method in the wrapped JavaMethod's choices_, check whether it is compatible with the given types.
ATClosure	ATJavaClosure.base_cast(ATObject[] types) Using this method, AmbientTalk symbiotic code is able to perform manual overloaded method disambiguation.