public class Destinations

This class is a repository of wisdom regarding destinations. It also provides a messenger if there is one. Currently, the wisdom is very limited and is only about direct destinations (for which a messenger once existed). The wisdom that can be obtained is:

is there a messenger at hand (incoming or otherwise).
is it likely that one can be made from this end, should the one we have break. (the last attempt succeeded, not only incoming, and that was not long ago).
is either of the above true, (are we confident we can get a messenger as of right now one way or the other).
are we supposed to send a welcome to that destination (we can't remember having done it).

This could be extended to manage more of the life cycle, such as knowing about messengers being resolved or having failed to. This primitive interface is temporary; it is only meant to replace messengerPool without having to change the router too much.

Inner Class Summary
final static class	Destinations.Wisdom This class stores knowlege about one particular destination.

Field Summary
private EndpointService	endpoint
private Thread	gcThread
private volatile boolean	stopped
final static long	expiration How long we consider that a past outgoingMessenger is an indication that one is possible in the future.
private long	expiresAt This tells when the outgoing messenger information expires.
private Messenger	incomingMessenger The channel we last used if it happens to be an incoming messenger.
private SoftReference	messenger The channel we last used, if any.
private boolean	welcomeNeeded When a new destination is added, we're supposed to send our welcome along with the first message.
private EndpointAddress	xportDest The transport destination address of the messenger we're caching (if not incoming).
private Map	wisdoms

Constructor Summary
public	Destinations(EndpointService endpoint)
	Wisdom(Messenger messenger, boolean incoming)

Method Summary
public synchronized boolean	addIncomingMessenger(EndpointAddress destination, Messenger messenger) Here is an incoming messenger that just poped out.
public synchronized boolean	addOutgoingMessenger(EndpointAddress destination, Messenger messenger) Here is a messenger that we were able to obtain.
private void	addWisdom(EndpointAddress destination, Destinations.Wisdom wisdom)
public synchronized List	allDestinations()
public synchronized void	close() Shutdown this cache.
public synchronized Messenger	getCurrentMessenger(EndpointAddress destination) If there is a messenger at hand (incoming or otherwise), return it.
private Destinations.Wisdom	getWisdom(EndpointAddress destination)
public synchronized boolean	isCurrentlyReachable(EndpointAddress destination) Is there a messenger at hand, or is it likely that we can make one ? (This is more often true than isNormallyReachable, since it can be true even when all we have is an incoming messenger).
public synchronized boolean	isNormallyReachable(EndpointAddress destination) Is it likely that one can be made from this end.
public synchronized boolean	isWelcomeNeeded(EndpointAddress destination) Are we supposed to send a welcome to that destination (we can't remember having done it).
public synchronized void	noOutgoingMessenger(EndpointAddress destination) We tried to get a messenger but could not.
public void	run() garbage collector.
boolean	addIncomingMessenger(Messenger m)
boolean	addOutgoingMessenger(Messenger m)
Messenger	getCurrentMessenger() Returns a channel for this destination if one is there or can be obtained readily and works.
private Messenger	getIncoming() Returns an incoming messenger is there is one that works.
private Messenger	getOutgoing() Returns an outgoingMessenger if there is one or one can be made without delay.
boolean	isCurrentlyReachable() We think the destination is reachable somehow.
boolean	isExpired()
boolean	isNormallyReachable()
boolean	isWelcomeNeeded() Tells whether a welcome message is needed.
void	noOutgoingMessenger()

private EndpointService endpoint

private Thread gcThread = null

private volatile boolean stopped = false

private Map wisdoms = new HashMap(64)

public Destinations(EndpointService endpoint)

addIncomingMessenger

public synchronized boolean addIncomingMessenger(EndpointAddress destination, Messenger messenger)

Here is an incoming messenger that just poped out.

destination The destination as an endpoint address (is automatically normalized to protocol and address only).
messenger The incoming messenger for that destination.

true if this messenger was added (keep it open). false otherwise (do what you want with it).

addOutgoingMessenger

public synchronized boolean addOutgoingMessenger(EndpointAddress destination, Messenger messenger)

Here is a messenger that we were able to obtain.

destination The destination as an endpoint address (is automatically normalized to protocol and address only).
messenger The incoming messenger for that destination.

true if this messenger was added (keep it open). false otherwise (do what you want with it).

private void addWisdom(EndpointAddress destination, Destinations.Wisdom wisdom)

public synchronized List allDestinations()

public synchronized void close()

Shutdown this cache. (stop the gc)

public synchronized Messenger getCurrentMessenger(EndpointAddress destination)

If there is a messenger at hand (incoming or otherwise), return it.