org.erights.e.elib.ref
Class RemotePromise

java.lang.Object
 |
 +--org.erights.e.elib.ref.Ref
 |
 +--org.erights.e.elib.ref.Proxy
 |
 +--org.erights.e.elib.ref.RemotePromise

All Implemented Interfaces:

Amplifiable, Callable

class RemotePromise

extends Proxy

A RemotePromise is a Proxy intended to represent a promise that will be resolved remotely (in another vat).

A RemotePromise is born handled (delegating to its ProxyHandler). While it is handled, it is EVENTUAL and has no identity. It is therefore also unsettled.

Author:

Mark S. Miller

myOptHandler

ProxyHandler myOptHandler

While I'm handled, I delegate many of my decisions to my handler.

myOptTarget

Ref myOptTarget

Once I'm not handled, I'm resolved to myOptTarget

RemotePromise

RemotePromise(ProxyHandler handler)

isResolved

public boolean isResolved()

Description copied from class: Ref

Suppressed:

Specified by:

isResolved in class Ref

setTarget

void setTarget(Ref newTarget)

To set me is to commit me

Specified by:

setTarget in class Ref

optSealedDispatch

public SealedBox optSealedDispatch(Brand brand)

If handled, ask our handler; else delegate to our target.

Specified by:

optSealedDispatch in interface Amplifiable

Overrides:

optSealedDispatch in class Ref

getOptProxyHandler

public ProxyHandler getOptProxyHandler(Class handlerClass)

If this is a handled Proxy whose handler is an instance of handlerClass, then return that handler; else null.

All implementations of getOptProxyHandler/1 must be thread safe, in order for BootRefHandler.getOptBootRefHandler/1 to be thread safe: myOptHandler only makes one transition from non-null to null. This implementation samples it once, and then proceeds with the possibly slightly stale sample.

Overrides:

getOptProxyHandler in class Ref

optProblem

public Throwable optProblem()

If handled, return null; else return the target's problem.

All implementations of optProblem/0 must be thread safe, in order for Ref.state/0 to be thread safe.

Specified by:

optProblem in class Ref

See Also:

Ref.optProblem(Object)

resolutionRef

Ref resolutionRef()

If this proxy is still being handled, return this; else return whatever it's been shortened to.

All implementations of resolutionRef/0 must be thread safe, in order for Ref.resolution/0 to be thread safe: If resolutionRef/0 is called from another thread while this proxy is in the middle of being shortened, then resolutionRef/0 must return either this or what this proxy is being shortened to.

XXX Although the implementation doesn't synchronize, it is inductively thread safe given a simple memory model. Is it safe in Java's complex memory model? Do we care -- are any Java implementations not faithful to the simple memory model?

Specified by:

resolutionRef in class Ref

state

public String state()

If handled, returns EVENTUAL; else returns the target's state().

All implementations of state/0 must be thread safe, in order for Ref.isNear/1 to be thread safe.

Overrides:

state in class Ref

See Also:

Ref.state(Object)

callAll

public Object callAll(String verb,
 Object[] args)

Description copied from class: Ref

Suppressed: Use E.callAll(obj, verb, args) rather than obj.callAll(verb, args).

Specified by:

callAll in interface Callable

Specified by:

callAll in class Ref

sendAll

public Ref sendAll(String verb,
 Object[] args)

Description copied from class: Ref

Suppressed: Use E.sendAll(obj, verb, args) rather than obj.sendAll(verb, args).

Specified by:

sendAll in class Ref

sendAllOnly

public Throwable sendAllOnly(String verb,
 Object[] args)

Description copied from class: Ref

Suppressed: Use E.sendAllOnly(obj, verb, args) rather than obj.sendAllOnly(verb, args).

Specified by:

sendAllOnly in class Ref

Returns:

Why wasn't this event queued? It isn't queued if this vat or comm connection is shut down, in which case the returned problem explains why. If null is returned, then the event was queued, though it may still not arrive.

commit

void commit()

ignored

Specified by:

commit in class Ref