Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Rice Pastry API
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
rice.pastry.NodeHandle

Packages that use NodeHandle
rice.p2p.commonapi.testing |
rice.p2p.multiring.testing |
rice.pastry |
rice.pastry.client |
rice.pastry.commonapi |
rice.pastry.direct |
rice.pastry.dist |
rice.pastry.join |
rice.pastry.leafset |
rice.pastry.leafset.testing |
rice.pastry.messaging |
rice.pastry.peerreview |
rice.pastry.pns |
rice.pastry.pns.messages |
rice.pastry.routing |
rice.pastry.socket |
rice.pastry.socket.nat.rendezvous |
rice.pastry.standard |
rice.pastry.testing |
rice.pastry.transport |

Uses of NodeHandle in rice.p2p.commonapi.testing

Methods in rice.p2p.commonapi.testing that return NodeHandle
`protected NodeHandle` | `CommonAPITest.getBootstrap()` Gets a handle to a bootstrap node.

Uses of NodeHandle in rice.p2p.multiring.testing

Methods in rice.p2p.multiring.testing that return NodeHandle
`protected NodeHandle` | `MultiringRegrTest.getBootstrap(Node bootstrap)` Gets a handle to a bootstrap node.

Uses of NodeHandle in rice.pastry

Classes in rice.pastry with type parameters of type NodeHandle
`interface` | `NodeHandleFactory<NH extends NodeHandle>`
`interface` | `NodeHandleFactoryListener<NH extends NodeHandle>` Notified when ever we hear of a Node Add the listener to the NodeHandleFactory

Fields in rice.pastry declared as NodeHandle
`protected NodeHandle` | `PastryNode.localhandle`

Fields in rice.pastry with type parameters of type NodeHandle
`protected LivenessProvider<NodeHandle>` | `PastryNode.livenessProvider`
`protected ProximityProvider<NodeHandle>` | `PastryNode.proxProvider`
`protected TransportLayer<NodeHandle,RawMessage>` | `PastryNode.tl` The top level transport layer.

Methods in rice.pastry that return NodeHandle
`NodeHandle` | `PastryNode.coalesce(NodeHandle newHandle)`
`NodeHandle` | `NodeSet.get(Id nid)` Finds the NodeHandle associated with a NodeId.
`NodeHandle` | `NodeSetI.get(Id nid)` Finds the NodeHandle associated with the NodeId.
`NodeHandle` | `NodeSet.get(int i)` Gets the ith element in the set.
`NodeHandle` | `NodeSetI.get(int i)` Gets the ith element in the set.
`NodeHandle` | `PastryNode.getLocalHandle()`
`NodeHandle` | `NodeSetUpdate.handle()` The handle that changed.
`NodeHandle` | `PastryNode.readNodeHandle(InputBuffer buf)`
`NodeHandle` | `NodeSet.remove(Id nid)` Removes a node id and its handle from the set.
`NodeHandle` | `NodeSet.remove(NodeHandle handle)` remove a member
`NodeHandle` | `NodeSetI.remove(NodeHandle nh)` Removes a node id and its handle from the set.

Methods in rice.pastry that return types with arguments of type NodeHandle
`java.util.Collection<NodeHandle>` | `NodeSet.getCollection()`
`java.util.Iterator<NodeHandle>` | `NodeSet.getIterator()` return an iterator that iterates over the elements of this set
`LivenessProvider<NodeHandle>` | `PastryNode.getLivenessProvider()`
`ProximityProvider<NodeHandle>` | `PastryNode.getProxProvider()`
`TransportLayer<NodeHandle,RawMessage>` | `PastryNode.getTL()`
`java.util.Iterator<NodeHandle>` | `NodeSet.iterator()`

Methods in rice.pastry with parameters of type NodeHandle
`boolean` | `PastryNode.checkLiveness(NodeHandle i, java.util.Map<java.lang.String,java.lang.Object> options)`
`void` | `PastryNode.clearState(NodeHandle i)`
`NodeHandle` | `PastryNode.coalesce(NodeHandle newHandle)`
`SocketRequestHandle` | `PastryNode.connect(NodeHandle i, AppSocketReceiver deliverSocketToMe, PastryAppl appl, int timeout)` Called by PastryAppl to ask the transport layer to open a Socket to its counterpart on another node.
`int` | `NodeSet.getIndex(NodeHandle nh)`
`int` | `NodeSetI.getIndex(NodeHandle nh)`
`int` | `PastryNode.getLiveness(NodeHandle i)`
`int` | `PastryNode.getLiveness(NodeHandle i, java.util.Map<java.lang.String,java.lang.Object> options)`
`int` | `NodeSet.indexOf(NodeHandle handle)` determine rank of a member
`boolean` | `NodeSet.insert(int index, NodeHandle handle)` insert a member at the given index
`boolean` | `PastryNode.isAlive(NodeHandle i)`
`void` | `PastryNode.livenessChanged(NodeHandle i, int val, java.util.Map<java.lang.String,java.lang.Object> options)`
`boolean` | `NodeSet.member(NodeHandle handle)` test membership
`boolean` | `NodeSetI.member(NodeHandle nh)` Verifies if the set contains this particular id.
`void` | `PastryNode.messageReceived(NodeHandle i, RawMessage m, java.util.Map<java.lang.String,java.lang.Object> options)`
`abstract PastryNode` | `PastryNodeFactory.newNode(NodeHandle bootstrap)` Deprecated. use newNode() then call PastryNode.boot(address);
`abstract PastryNode` | `PastryNodeFactory.newNode(NodeHandle bootstrap, Id nodeId)` Deprecated. use newNode(nodeId) then call PastryNode.boot(address);
`void` | `NodeSetListener.nodeSetUpdate(NodeSetEventSource nodeSetEventSource, NodeHandle handle, boolean added)`
`protected void` | `PastryNode.notifyLivenessListeners(NodeHandle i, int val, java.util.Map<java.lang.String,java.lang.Object> options)`
`int` | `PastryNode.proximity(NodeHandle nh)` The proximity of the node handle.
`int` | `PastryNode.proximity(NodeHandle nh, java.util.Map<java.lang.String,java.lang.Object> options)`
`void` | `PastryNode.proximityChanged(NodeHandle handle, int val, java.util.Map<java.lang.String,java.lang.Object> options)`
`boolean` | `NodeSet.put(NodeHandle handle)` Appends a member to the ordered set.
`boolean` | `NodeSetI.put(NodeHandle handle)` Puts a NodeHandle into the set.
`NodeHandle` | `NodeSet.remove(NodeHandle handle)` remove a member
`NodeHandle` | `NodeSetI.remove(NodeHandle nh)` Removes a node id and its handle from the set.
`PMessageReceipt` | `PastryNode.send(NodeHandle handle, Message msg, PMessageNotification deliverAckToMe, java.util.Map<java.lang.String,java.lang.Object> tempOptions)` Deliver message to the NodeHandle.
`void` | `PastryNode.setElements(NodeHandle lh, MessageDispatch md, LeafSet ls, RoutingTable rt, Router router)` Combined accessor method for various members of PastryNode.

Method parameters in rice.pastry with type arguments of type NodeHandle
`void` | `PastryNode.addLivenessListener(LivenessListener<NodeHandle> name)`
`void` | `PastryNode.addProximityListener(ProximityListener<NodeHandle> listener)`
`void` | `PastryNode.doneNode(java.util.Collection<NodeHandle> bootstrap)` Called after the node is initialized.
`Cancellable` | `NodeHandleFetcher.getNodeHandle(java.lang.Object o, Continuation<NodeHandle,java.lang.Exception> c)`
`void` | `PastryNode.getNodeHandle(java.lang.Object o, Continuation<NodeHandle,java.lang.Exception> c)`
`void` | `PastryNode.incomingSocket(P2PSocket<NodeHandle> s)`
`boolean` | `PastryNode.removeLivenessListener(LivenessListener<NodeHandle> name)`
`boolean` | `PastryNode.removeProximityListener(ProximityListener<NodeHandle> listener)`
`void` | `PastryNode.setSocketElements(int lsmf, int rsmf, TransportLayer<NodeHandle,RawMessage> tl, LivenessProvider<NodeHandle> livenessProvider, ProximityProvider<NodeHandle> proxProvider, NodeHandleFactory handleFactory)`
`void` | `PastryNode.setSocketElements(int lsmf, int rsmf, TransportLayer<NodeHandle,RawMessage> tl, LivenessProvider<NodeHandle> livenessProvider, ProximityProvider<NodeHandle> proxProvider, NodeHandleFactory handleFactory)`
`void` | `PastryNode.setSocketElements(int lsmf, int rsmf, TransportLayer<NodeHandle,RawMessage> tl, LivenessProvider<NodeHandle> livenessProvider, ProximityProvider<NodeHandle> proxProvider, NodeHandleFactory handleFactory)`

Constructors in rice.pastry with parameters of type NodeHandle
`NodeSetUpdate(NodeHandle which, boolean how)` Constructor.

Constructor parameters in rice.pastry with type arguments of type NodeHandle
`NodeSet(java.util.Vector<NodeHandle> s)` Constructor.

Uses of NodeHandle in rice.pastry.client

Methods in rice.pastry.client that return NodeHandle
`NodeHandle` | `PastryAppl.getNodeHandle()` Gets the handle of the Pastry node associated with this client

Methods in rice.pastry.client with parameters of type NodeHandle
`boolean` | `PastryAppl.enrouteMessage(Message msg, Id key, NodeHandle nextHop, SendOptions opt)` Called by pastry when a message is enroute and is passing through this node.
`void` | `CommonAPIAppl.leafSetChange(NodeHandle nh, boolean wasAdded)` Called by pastry when the leaf set changes.
`void` | `PastryAppl.leafSetChange(NodeHandle nh, boolean wasAdded)` Called by pastry when the leaf set changes.
`IdRange` | `CommonAPIAppl.range(NodeHandle n, int r, Id key)` This method provides information about ranges of keys for which the node n is currently a r-root.
`IdRange` | `CommonAPIAppl.range(NodeHandle n, int r, Id key, boolean cumulative)` This method provides information about ranges of keys for which the node n is currently a r-root.
`void` | `CommonAPIAppl.route(Id key, Message msg, NodeHandle hint)` This operation forwards a message towards the root of key.
`boolean` | `PastryAppl.routeMsgDirect(NodeHandle dest, Message msg, SendOptions opt)` Sends a message to the Pastry node identified by dest.
`void` | `PastryAppl.routeSetChange(NodeHandle nh, boolean wasAdded)` Called by pastry when the route set changes.
`void` | `CommonAPIAppl.update(NodeHandle nh, boolean joined)` Called by pastry when the neighbor set changes.

Constructors in rice.pastry.client with parameters of type NodeHandle
`NodeIsNotReadyException(NodeHandle handle)`

Uses of NodeHandle in rice.pastry.commonapi

Methods in rice.pastry.commonapi with parameters of type NodeHandle
`boolean` | `PastryEndpoint.enrouteMessage(Message msg, Id key, NodeHandle nextHop, SendOptions opt)`
`void` | `PastryEndpoint.leafSetChange(NodeHandle nh, boolean wasAdded)`

Constructors in rice.pastry.commonapi with parameters of type NodeHandle
`PastryEndpointMessage(int address, InputBuffer buf, MessageDeserializer md, short type, int priority, NodeHandle sender)`
`PastryEndpointMessage(int address, Message message, NodeHandle sender)` Constructor.
`PastryEndpointMessage(int address, RawMessage message, NodeHandle sender)`

Uses of NodeHandle in rice.pastry.direct

Subclasses of NodeHandle in rice.pastry.direct
`class` | `DirectNodeHandle` the node handle used with the direct network

Fields in rice.pastry.direct with type parameters of type NodeHandle
`protected java.util.Collection<NodeHandleFactoryListener<NodeHandle>>` | `DirectPastryNodeFactory.listeners`

Methods in rice.pastry.direct that return NodeHandle
`protected NodeHandle` | `DirectPastryNodeFactory.getLocalHandle(PastryNode pn, NodeHandleFactory handleFactory)`

Methods in rice.pastry.direct that return types with arguments of type NodeHandle
`protected TransportLayer<NodeHandle,RawMessage>` | `DirectPastryNodeFactory.getDirectTransportLayer(PastryNode pn, NodeRecord nr)` Override me

Methods in rice.pastry.direct with parameters of type NodeHandle
`LeafSet` | `DirectPastryNodeFactory.getLeafSet(NodeHandle handle)` This method returns the remote leafset of the provided handle to the caller, in a protocol-dependent fashion.
`CancellableTask` | `DirectPastryNodeFactory.getLeafSet(NodeHandle handle, Continuation<LeafSet,java.lang.Exception> c)`
`int` | `DirectPastryNodeFactory.getProximity(NodeHandle local, NodeHandle remote)` This method determines and returns the proximity of the current local node the provided NodeHandle.
`RouteSet[]` | `DirectPastryNodeFactory.getRouteRow(NodeHandle handle, int row)` This method returns the remote route row of the provided handle to the caller, in a protocol-dependent fashion.
`CancellableTask` | `DirectPastryNodeFactory.getRouteRow(NodeHandle handle, int row, Continuation<RouteSet[],java.lang.Exception> c)`
`PastryNode` | `DirectPastryNodeFactory.newNode(NodeHandle bootstrap)` Manufacture a new Pastry node.
`PastryNode` | `DirectPastryNodeFactory.newNode(NodeHandle bootstrap, Id nodeId)`

Uses of NodeHandle in rice.pastry.dist

Subclasses of NodeHandle in rice.pastry.dist
`class` | `DistNodeHandle<Identifier>` Abstract class for handles to "real" remote nodes.

Uses of NodeHandle in rice.pastry.join

Fields in rice.pastry.join declared as NodeHandle
`protected NodeHandle` | `JoinRequest.handle`
`protected NodeHandle` | `JoinRequest.joinHandle`

Methods in rice.pastry.join that return NodeHandle
`NodeHandle` | `InitiateJoin.getHandle()` Gets the handle for the join.
`NodeHandle` | `JoinRequest.getHandle()` Gets the handle of the node trying to join.
`NodeHandle` | `JoinRequest.getJoinHandle()` Gets the handle of the node that accepted the join request;

Methods in rice.pastry.join with parameters of type NodeHandle
`void` | `JoinRequest.acceptJoin(NodeHandle nh, LeafSet ls)` Accept join request.

Method parameters in rice.pastry.join with type arguments of type NodeHandle
`void` | `JoinProtocol.initiateJoin(java.util.Collection<NodeHandle> bootstrap)`

Constructors in rice.pastry.join with parameters of type NodeHandle
`JoinRequest(InputBuffer buf, NodeHandleFactory nhf, NodeHandle sender, PastryNode localNode)`
`JoinRequest(NodeHandle nh, byte rtBaseBitLength)` Constructor.
`JoinRequest(NodeHandle nh, byte rtBaseBitLength, long timestamp)`
`JoinRequest(NodeHandle nh, java.util.Date stamp, byte rtBaseBitLength)` Constructor.

Constructor parameters in rice.pastry.join with type arguments of type NodeHandle
`InitiateJoin(java.util.Collection<NodeHandle> nh)` Constructor.
`InitiateJoin(java.util.Date stamp, java.util.Collection<NodeHandle> nh)` Constructor.

Uses of NodeHandle in rice.pastry.leafset

Methods in rice.pastry.leafset that return NodeHandle
`NodeHandle` | `BroadcastLeafSet.from()` Returns the node id of the node that broadcast its leaf set.
`NodeHandle` | `SimilarSet.get(Id nid)` Finds the NodeHandle associated with the Id.
`NodeHandle` | `LeafSet.get(int index)` Finds the NodeHandle at a given index.
`NodeHandle` | `SimilarSet.get(int i)` Gets the ith element in the set.
`NodeHandle` | `SimilarSet.get(NodeHandle nh)`
`NodeHandle` | `SimilarSet.remove(Id nid)` Removes a node id and its handle from the set.
`protected NodeHandle` | `SimilarSet.remove(int i)` Removes a node id and its handle from the set.
`NodeHandle` | `SimilarSet.remove(NodeHandle nh)`
`NodeHandle` | `RequestLeafSet.returnHandle()` The return handle for the message

Methods in rice.pastry.leafset that return types with arguments of type NodeHandle
`java.util.List<NodeHandle>` | `LeafSet.asList()` If overlaps() a NodeHandle may show up twice.
`java.util.Collection<NodeHandle>` | `SimilarSet.getCollection()` This is thread safe, in that it won't throw an error if not properly synchronized.
`java.util.Collection<NodeHandle>` | `LeafSet.getUniqueSet()` Set of nodes in the leafset, not the local node, each node only once.
`java.util.Iterator<NodeHandle>` | `LeafSet.iterator()` Unordered iterator, does not contain local node.

Methods in rice.pastry.leafset with parameters of type NodeHandle
`boolean` | `LeafSet.contains(NodeHandle nh)`
`boolean` | `LeafSet.directTest(NodeHandle handle)`
`NodeHandle` | `SimilarSet.get(NodeHandle nh)`
`int` | `LeafSet.getIndex(NodeHandle nh)` There are 2 possible indexes (if the ring is small), the cw index and the ccw, this returns the nearest index, and if they are the same, the cw index.
`int` | `SimilarSet.getIndex(NodeHandle nh)`
`protected boolean` | `LeafSet.isProperlyRemoved(NodeHandle handle)`
`boolean` | `LeafSet.member(NodeHandle nid)` Verifies if the set contains this particular handle.
`boolean` | `SimilarSet.member(NodeHandle nid)` Verifies if the set contains this particular id.
`boolean` | `LeafSet.merge(LeafSet remotels, NodeHandle from, RoutingTable routeTable, boolean testOnly, java.util.Set<NodeHandle> insertedHandles)` Merge a remote leafset into this
`protected void` | `SimilarSet.notifyListeners(NodeHandle handle, boolean added)`
`boolean` | `LeafSet.put(NodeHandle handle)` Puts a NodeHandle into the set.
`boolean` | `SimilarSet.put(NodeHandle handle)` Puts a NodeHandle into the set.
`boolean` | `LeafSet.put(NodeHandle handle, boolean suppressNotification)`
`boolean` | `SimilarSet.put(NodeHandle handle, boolean suppressNotify)`
`IdRange` | `LeafSet.range(NodeHandle n, int r)` range computes the range of keys for which node n is a i-root, 0<=i<=r a node is the r-root for a key of the node becomes the numerically closest node to the key when i-roots for the key fail, O<=i
`IdRange` | `LeafSet.range(NodeHandle n, int r, boolean cw)` range computes the ranges of keys for which node n is a r-root a node is the r-root for a key of the node becomes the numerically closest node to the key when i-roots for the key fail, O<=i
`void` | `LeafSet.remove(NodeHandle nh)` Removes a node id and its handle from the set.
`NodeHandle` | `SimilarSet.remove(NodeHandle nh)`
`boolean` | `LeafSet.test(NodeHandle handle)` Test if a put of the given NodeHandle would succeed.
`boolean` | `SimilarSet.test(NodeHandle handle)` Test if a NodeHandle belongs into the set.
`protected boolean` | `LeafSet.testOtherSet(SimilarSet set, NodeHandle handle)`

Method parameters in rice.pastry.leafset with type arguments of type NodeHandle
`boolean` | `LeafSet.merge(LeafSet remotels, NodeHandle from, RoutingTable routeTable, boolean testOnly, java.util.Set<NodeHandle> insertedHandles)` Merge a remote leafset into this

Constructors in rice.pastry.leafset with parameters of type NodeHandle
`BroadcastLeafSet(java.util.Date stamp, NodeHandle from, LeafSet leafSet, int type, long requestTimeStamp)` Constructor.
`BroadcastLeafSet(NodeHandle from, LeafSet leafSet, int type, long requestTimeStamp)` Constructor.
`LeafSet(NodeHandle localNode, int size, boolean observe)`
`LeafSet(NodeHandle localNode, int size, boolean observe, NodeHandle[] cwTable, NodeHandle[] ccwTable)`
`LeafSet(NodeHandle localNode, int size, boolean observe, NodeHandle[] cwTable, NodeHandle[] ccwTable)`
`LeafSet(NodeHandle localNode, int size, boolean observe, NodeHandle[] cwTable, NodeHandle[] ccwTable)`
`LeafSet(NodeHandle localNode, int size, RoutingTable rt)` Constructor.
`RequestLeafSet(java.util.Date stamp, NodeHandle nh, long timeStamp)` Constructor.
`RequestLeafSet(NodeHandle sender, InputBuffer buf)`
`RequestLeafSet(NodeHandle nh, long timeStamp)` Constructor.
`SimilarSet(LeafSet leafSet, NodeHandle localNode, int size, boolean cw)` Constructor.
`SimilarSet(LeafSet leafSet, NodeHandle localNode, int size, boolean cw, NodeHandle[] handles)`
`SimilarSet(LeafSet leafSet, NodeHandle localNode, int size, boolean cw, NodeHandle[] handles)`

Uses of NodeHandle in rice.pastry.leafset.testing

Subclasses of NodeHandle in rice.pastry.leafset.testing
`static class` | `MergeTest.TestNodeHandle`

Methods in rice.pastry.leafset.testing that return NodeHandle
`static NodeHandle[]` | `MergeTest.getHandles(java.lang.String str)` Input of the form: <0xD74D4F..><0xD7B075..><0xD98A9D..><0xDAC7F0..><0xDB39A6..>

Methods in rice.pastry.leafset.testing with parameters of type NodeHandle
`static void` | `MergeTest.flip(NodeHandle[] nds)`

Uses of NodeHandle in rice.pastry.messaging

Methods in rice.pastry.messaging that return NodeHandle
`NodeHandle` | `Message.getSender()` Get sender.

Methods in rice.pastry.messaging with parameters of type NodeHandle
`abstract Message` | `PJavaSerializedDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`void` | `Message.setSender(NodeHandle nh)` Set sender Id.

Uses of NodeHandle in rice.pastry.peerreview

Fields in rice.pastry.peerreview with type parameters of type NodeHandle
`java.util.Map<PastryNode,NodeHandle>` | `CallbackFactory.localHandleTable`
`protected java.util.Map<Id,Tuple<TimerTask,java.util.Collection<Continuation<java.util.Collection<NodeHandle>,java.lang.Exception>>>>` | `FetchLeafsetApp.pendingLookups`

Methods in rice.pastry.peerreview that return NodeHandle
`NodeHandle` | `CallbackFactory.getLocalHandle(PastryNode pn, NodeHandleFactory nhf)`

Method parameters in rice.pastry.peerreview with type arguments of type NodeHandle
`void` | `FetchLeafsetApp.getNeighbors(Id subject, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> continuation)` Add to the pendingLookups.

Constructors in rice.pastry.peerreview with parameters of type NodeHandle
`FetchLeafsetRequest(NodeHandle sender, Id subject)`
`FetchLeafsetResponse(InputBuffer buf, NodeHandleFactory nhf, NodeHandle sender)`

Uses of NodeHandle in rice.pastry.pns

Fields in rice.pastry.pns with type parameters of type NodeHandle
`protected java.util.Map<NodeHandle,java.lang.Integer>` | `PNSApplication.pingCache` Hashtable which keeps track of temporary ping values, which are only used during the getNearest() method

Methods in rice.pastry.pns that return types with arguments of type NodeHandle
`protected java.util.List<NodeHandle>` | `PNSApplication.getNearHandlesHelper(java.util.List<NodeHandle> handles)` Helper for getNearHandles Can be overridden to select out any handles that shouldn't be returned.
`java.util.List<NodeHandle>` | `PNSApplication.sortedProximityCache()`

Methods in rice.pastry.pns with parameters of type NodeHandle
`protected void` | `PNSApplication.addToWaitingForLeafSet(NodeHandle handle, Continuation<LeafSet,java.lang.Exception> c, Cancellable cancelMeWhenSuccess)`
`protected void` | `PNSApplication.addToWaitingForRouteRow(NodeHandle handle, int row, Continuation<RouteSet[],java.lang.Exception> c, Cancellable cancelMeWhenSuccess)`
`Cancellable` | `PNSApplication.getLeafSet(NodeHandle handle, Continuation<LeafSet,java.lang.Exception> c)` This method returns the remote leafset of the provided handle to the caller, in a protocol-dependent fashion.
`Cancellable` | `PNSApplication.getNearest(NodeHandle seed, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> retToMe)` This method implements the algorithm in the Pastry locality paper for finding a close node the the current node through iterative leafset and route row requests.
`Cancellable` | `PNSApplication.getProximity(NodeHandle handle, Continuation<java.lang.Integer,java.io.IOException> c, int timeout)` Non-blocking version, no timeout.
`Cancellable` | `PNSApplication.getRouteRow(NodeHandle handle, short row, Continuation<RouteSet[],java.lang.Exception> c)` Non-blocking version.
`void` | `PNSApplication.proximityChanged(NodeHandle i, int newProximity, java.util.Map<java.lang.String,java.lang.Object> options)`
`protected boolean` | `PNSApplication.removeFromWaitingForLeafSet(NodeHandle handle, Continuation<LeafSet,java.lang.Exception> c)`
`protected boolean` | `PNSApplication.removeFromWaitingForRouteRow(NodeHandle handle, int row, Continuation<RouteSet[],java.lang.Exception> c)`

Method parameters in rice.pastry.pns with type arguments of type NodeHandle
`Cancellable` | `PNSApplication.getNearest(NodeHandle seed, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> retToMe)` This method implements the algorithm in the Pastry locality paper for finding a close node the the current node through iterative leafset and route row requests.
`Cancellable` | `PNSApplication.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)`
`Cancellable` | `PNSApplication.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)`
`protected java.util.List<NodeHandle>` | `PNSApplication.getNearHandlesHelper(java.util.List<NodeHandle> handles)` Helper for getNearHandles Can be overridden to select out any handles that shouldn't be returned.

Uses of NodeHandle in rice.pastry.pns.messages

Methods in rice.pastry.pns.messages with parameters of type NodeHandle
`static LeafSetRequest` | `LeafSetRequest.build(InputBuffer buf, NodeHandle sender, int dest)`
`static Message` | `RouteRowRequest.build(InputBuffer buf, NodeHandle sender, int dest)`

Constructors in rice.pastry.pns.messages with parameters of type NodeHandle
`LeafSetRequest(NodeHandle nodeHandle, int dest)`
`RouteRowRequest(NodeHandle nodeHandle, short index, int dest)`
`RouteRowResponse(InputBuffer buf, PastryNode localNode, NodeHandle sender, int dest)`
`RouteRowResponse(NodeHandle sender, short index, RouteSet[] row, int address)`

Uses of NodeHandle in rice.pastry.routing

Fields in rice.pastry.routing declared as NodeHandle
`NodeHandle` | `RoutingTable.myNodeHandle`

Methods in rice.pastry.routing that return NodeHandle
`NodeHandle` | `RoutingTable.bestAlternateRoute(Id key)` Determines an alternate hop numerically closer to the key than the one we are at.
`NodeHandle` | `RoutingTable.bestAlternateRoute(int minLiveness, Id key)` Determines an alternate hop numerically closer to the key than the one we are at.
`NodeHandle` | `RouteSet.closestNode()` Return the closest live node in the set.
`NodeHandle` | `RouteSet.closestNode(int minLiveness)` Return the closest live node in the set.
`NodeHandle` | `BroadcastRouteRow.from()` Gets the from node.
`NodeHandle` | `RouteSet.get(Id nid)` Returns the node handle with the matching node id or null if none exists.
`NodeHandle` | `RoutingTable.get(Id nid)` Gets the node handle associated with a given id.
`NodeHandle` | `RouteSet.get(int i)` Returns the node in the ith position in the set.
`NodeHandle` | `RouteMessage.getDestinationHandle()`
`NodeHandle` | `RouteMessage.getNextHop()`
`NodeHandle` | `RouteMessage.getPrevNode()`
`NodeHandle` | `RouterStrategy.pickNextHop(RouteMessage msg, java.util.Iterator<NodeHandle> i)`
`NodeHandle` | `RouteSet.remove(Id nid)` Removes a node from a set.
`NodeHandle` | `RouteSet.remove(NodeHandle nh)` Removes a node from a set.
`NodeHandle` | `RoutingTable.remove(NodeHandle nh)` Removes a node id from the table.
`NodeHandle` | `RequestRouteRow.returnHandle()` The return handle for the message

Methods in rice.pastry.routing that return types with arguments of type NodeHandle
`java.util.Iterator<NodeHandle>` | `RoutingTable.alternateRoutesIterator(Id key)` More efficient implementation, but less accurate, doesn't include lower levels of rt.
`java.util.List<NodeHandle>` | `RoutingTable.asList()` Does not return self
`java.util.Iterator<NodeHandle>` | `Router.getBestRoutingCandidates(Id key)` Returns an ordered list of the best candidates for the next to the key.
`java.util.Iterator<NodeHandle>` | `RouteSet.iterator()`

Methods in rice.pastry.routing with parameters of type NodeHandle
`static RouteMessage` | `RouteMessage.build(InputBuffer buf, byte priority, PastryNode pn, NodeHandle prev, byte outputVersion)` version 1: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + int auxAddress + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + bool hasHndle + // if it has a destinationHandle instead of an Id +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + Id target + + (only existis if the hasHandle boolean is false + + + + + + + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + NodeHandle destinationHandle + + (used if the RouteMessage is intended for a specific node) + + (only exists if the hasHandle boolean is true) + ...
`int` | `RouteSet.getIndex(NodeHandle nh)` Get the index of the node id.
`boolean` | `RouteSet.member(NodeHandle nh)` Membership test.
`void` | `RoutingTable.nodeSetUpdate(java.lang.Object o, NodeHandle handle, boolean added)` Is called by the Observer pattern whenever a RouteSet in this table has changed.
`boolean` | `RouteSet.put(NodeHandle handle)` Puts a node into the set.
`boolean` | `RoutingTable.put(NodeHandle handle)` Puts a handle into the routing table.
`NodeHandle` | `RouteSet.remove(NodeHandle nh)` Removes a node from a set.
`NodeHandle` | `RoutingTable.remove(NodeHandle nh)` Removes a node id from the table.
`void` | `RouteMessage.sendSuccess(NodeHandle nextHop)`
`void` | `RouteMessageNotification.sendSuccess(RouteMessage message, NodeHandle nextHop)`
`void` | `RouteMessage.setDestinationHandle(NodeHandle handle)`
`void` | `RouteMessage.setNextHop(NodeHandle nh)`
`void` | `RouteMessage.setPrevNode(NodeHandle n)`
`int` | `RoutingTable.test(NodeHandle handle)`

Method parameters in rice.pastry.routing with type arguments of type NodeHandle
`NodeHandle` | `RouterStrategy.pickNextHop(RouteMessage msg, java.util.Iterator<NodeHandle> i)`

Constructors in rice.pastry.routing with parameters of type NodeHandle
`BroadcastRouteRow(java.util.Date stamp, NodeHandle from, RouteSet[] r)` Constructor.
`BroadcastRouteRow(NodeHandle from, RouteSet[] r)` Constructor.
`RequestRouteRow(java.util.Date stamp, NodeHandle nh, short r)` Constructor.
`RequestRouteRow(NodeHandle sender, InputBuffer buf)`
`RequestRouteRow(NodeHandle nh, short r)` Constructor.
`RouteMessage(Id target, int auxAddress, NodeHandle prev, InputBuffer buf, byte priority, PastryNode pn, NodeHandle destinationHandle, byte serializeVersion)`
`RouteMessage(Id target, Message msg, NodeHandle firstHop, byte serializeVersion)` Constructor.
`RouteMessage(Id target, Message msg, NodeHandle firstHop, SendOptions opts, byte serializeVersion)` Constructor.
`RouteMessage(Id target, PRawMessage msg, NodeHandle firstHop, SendOptions opts, byte serializeVersion)`
`RouteMessage(NodeHandle dest, Message msg, SendOptions opts, byte serializeVersion)` Constructor.
`RouteSet(int maxSize, int row, int col, PastryNode local, NodeHandle initialVal)` Constructor.
`RoutingTable(NodeHandle me, int max, byte base, PastryNode pn)` Constructor.

Uses of NodeHandle in rice.pastry.socket

Subclasses of NodeHandle in rice.pastry.socket
`class` | `SocketNodeHandle`
`class` | `TransportLayerNodeHandle<Identifier>` Parallel interface to the CommonAPI NodeHandle, because it is an abstract object to gain the observer pattern.

Methods in rice.pastry.socket that return NodeHandle
`NodeHandle` | `SocketPastryNodeFactory.getLocalHandle(PastryNode pn, NodeHandleFactory nhf)`
`NodeHandle` | `SocketPastryNodeFactory.getNodeHandle(java.net.InetSocketAddress bootstrap)`
`NodeHandle` | `SocketPastryNodeFactory.getNodeHandle(java.net.InetSocketAddress[] bootstraps, int int1)`
`NodeHandle` | `SocketPastryNodeFactory.getNodeHandle(java.net.InetSocketAddress bootstrap, int i)`

Methods in rice.pastry.socket with parameters of type NodeHandle
`PastryNode` | `SocketPastryNodeFactory.newNode(NodeHandle bootstrap)` Method which creates a Pastry node from the next port with a randomly generated NodeId.
`PastryNode` | `SocketPastryNodeFactory.newNode(NodeHandle bootstrap, Id nodeId)` Method which creates a Pastry node from the next port with the specified nodeId (or one generated from the NodeIdFactory if not specified)
`PastryNode` | `SocketPastryNodeFactory.newNode(NodeHandle nodeHandle, Id id, java.net.InetSocketAddress proxyAddress)` Method which creates a Pastry node from the next port with the specified nodeId (or one generated from the NodeIdFactory if not specified)
`PastryNode` | `SocketPastryNodeFactory.newNode(NodeHandle bootstrap, java.net.InetSocketAddress proxy)` Method which creates a Pastry node from the next port with the specified nodeId (or one generated from the NodeIdFactory if not specified)

Method parameters in rice.pastry.socket with type arguments of type NodeHandle
`void` | `SocketPastryNodeFactory.getNodeHandle(java.net.InetSocketAddress[] bootstraps, Continuation<NodeHandle,java.lang.Exception> c)`

Uses of NodeHandle in rice.pastry.socket.nat.rendezvous

Subclasses of NodeHandle in rice.pastry.socket.nat.rendezvous
`class` | `RendezvousSocketNodeHandle` Maintains RendezvousInfo with the NodeHandle

Fields in rice.pastry.socket.nat.rendezvous declared as NodeHandle
`protected NodeHandle` | `RendezvousJoinRequest.pilot` The joiner has created a pilot connection to the pilot node.

Methods in rice.pastry.socket.nat.rendezvous that return NodeHandle
`NodeHandle` | `NodeIsFirewalledException.getHandle()`
`NodeHandle` | `RendezvousSocketPastryNodeFactory.getLocalHandle(PastryNode pn, NodeHandleFactory nhf)`
`NodeHandle` | `RendezvousJoinRequest.getPilot()`
`NodeHandle` | `RendezvousRouterStrategy.pickNextHop(RouteMessage msg, java.util.Iterator<NodeHandle> i)`

Methods in rice.pastry.socket.nat.rendezvous that return types with arguments of type NodeHandle
`protected java.util.List<NodeHandle>` | `RendezvousPNSApplication.getNearHandlesHelper(java.util.List<NodeHandle> handles)` Don't return any non-contactDirect handles unless all of them are.

Methods in rice.pastry.socket.nat.rendezvous with parameters of type NodeHandle
`protected void` | `RendezvousJoinProtocol.getJoinRequest(NodeHandle b, Continuation<JoinRequest,java.lang.Exception> deliverJRToMe)` Use RendezvousJoinRequest if local node is NATted
`Cancellable` | `RendezvousPNSApplication.getLeafSet(NodeHandle input, Continuation<LeafSet,java.lang.Exception> c)`
`Cancellable` | `RendezvousPNSApplication.getNearest(NodeHandle seed, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> retToMe)`
`protected java.util.Map<java.lang.String,java.lang.Object>` | `RendezvousRouterStrategy.getOptions(NodeHandle nh)`
`Cancellable` | `RendezvousPNSApplication.getProximity(NodeHandle handle, Continuation<java.lang.Integer,java.io.IOException> c, int timeout)`
`Cancellable` | `RendezvousPNSApplication.getRouteRow(NodeHandle input, short row, Continuation<RouteSet[],java.lang.Exception> c)`
`protected boolean` | `RendezvousPNSApplication.ignore(NodeHandle handle, Continuation c)` This method decides who to bother trying to connect to.
`void` | `LeafSetPilotStrategy.nodeSetUpdate(NodeSetEventSource nodeSetEventSource, NodeHandle handle, boolean added)`
`protected int` | `RendezvousRouterStrategy.routingQuality(NodeHandle nh)` Returns the quality of the nh for routing 0 is optimal 0 if connected and alive Suspected is a 1 (if connected or directly connectable) Alive and connected/directly contactable = 0 not directly connectable = 5 (unless connected) 10 if faulty
`protected boolean` | `RendezvousPNSApplication.useHandle(NodeHandle handle)` Separate this out to make it super easy to change the policy.

Method parameters in rice.pastry.socket.nat.rendezvous with type arguments of type NodeHandle
`Cancellable` | `RendezvousPNSApplication.getNearest(NodeHandle seed, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> retToMe)`
`Cancellable` | `RendezvousPNSApplication.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)` This is the first step, cull out the bootHandles that we can't use good.
`Cancellable` | `RendezvousPNSApplication.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)` This is the first step, cull out the bootHandles that we can't use good.
`protected java.util.List<NodeHandle>` | `RendezvousPNSApplication.getNearHandlesHelper(java.util.List<NodeHandle> handles)` Don't return any non-contactDirect handles unless all of them are.
`NodeHandle` | `RendezvousRouterStrategy.pickNextHop(RouteMessage msg, java.util.Iterator<NodeHandle> i)`

Constructors in rice.pastry.socket.nat.rendezvous with parameters of type NodeHandle
`NodeIsFirewalledException(NodeHandle handle)`
`RendezvousJoinProtocol(PastryNode ln, NodeHandle lh, RoutingTable rt, LeafSet ls, ReadyStrategy nextReadyStrategy, PilotManager<RendezvousSocketNodeHandle> pilotManager)`
`RendezvousJoinRequest(InputBuffer buf, NodeHandleFactory nhf, NodeHandle sender, PastryNode localNode)`
`RendezvousJoinRequest(NodeHandle nh, byte rtBaseBitLength, long timestamp, NodeHandle pilot)`

Uses of NodeHandle in rice.pastry.standard

Fields in rice.pastry.standard declared as NodeHandle
`protected NodeHandle` | `PeriodicLeafSetProtocol.localHandle`
`protected NodeHandle` | `StandardJoinProtocol.localHandle`

Fields in rice.pastry.standard with type parameters of type NodeHandle
`protected java.util.Map<NodeHandle,java.lang.Long>` | `PeriodicLeafSetProtocol.lastTimeReceivedBLS` NodeHandle -> Long remembers the TIME when we received a BLS from that NodeHandle
`protected java.util.Map<NodeHandle,java.lang.Long>` | `PeriodicLeafSetProtocol.lastTimeSentBLS`
`protected java.util.Map<NodeHandle,java.lang.Long>` | `StandardRouter.lastTimeSentRouteTablePatch` We can end up causing a nasty feedback if we blast too many BRRs, so we're going to throttle.

Methods in rice.pastry.standard that return NodeHandle
`NodeHandle` | `PartitionHandler.getCandidateNode()` This method randomly returns a node that was once in the LeafSet or in the routing table but has since been removed.

Methods in rice.pastry.standard that return types with arguments of type NodeHandle
`java.util.Iterator<NodeHandle>` | `StandardRouter.getBestRoutingCandidates(Id target)`
`protected java.util.Iterator<NodeHandle>` | `StandardRouter.getBestRoutingCandidates(Id target, int lsPos, boolean leafSetOnly)`
`protected java.util.ArrayList<NodeHandle>` | `StandardRouter.getLSCollection(int lsPos)`
`java.util.Collection<NodeHandle>` | `ConsistentJoinProtocol.whoDoWeNeedAResponseFrom()` Returns all members of the leafset that are not in gotResponse

Methods in rice.pastry.standard with parameters of type NodeHandle
`void` | `ConsistentJoinProtocol.addToLeafSet(NodeHandle nh)` Observes all NodeHandles added to LeafSet
`protected void` | `StandardLeafSetProtocol.broadcast(LeafSet ls, NodeHandle from)` Broadcast the local leaf set to all members of the given leaf set, plus the node from which the leaf set was received.
`protected boolean` | `StandardLeafSetProtocol.checkLeafSet(LeafSet remotels, NodeHandle from, boolean notifyMissing)` Checks a received leafset advertisement for missing nodes
`Message` | `ConsistentJoinProtocol.CJPDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`Message` | `PeriodicLeafSetProtocol.PLSPMessageDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`Message` | `StandardJoinProtocol.SJPDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`protected void` | `StandardJoinProtocol.getJoinRequest(NodeHandle bootstrap, Continuation<JoinRequest,java.lang.Exception> deliverJRToMe)`
`boolean` | `PeriodicLeafSetProtocol.hasLease(NodeHandle nh)` Do we have a lease from this node? Returns true if nh is null.
`void` | `PeriodicLeafSetProtocol.leafSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `StandardLeafSetProtocol.leafSetChange(NodeHandle nh, boolean wasAdded)` We manage the leafset now.
`void` | `RapidRerouter.livenessChanged(NodeHandle i, int val, java.util.Map<java.lang.String,java.lang.Object> options)`
`protected boolean` | `StandardLeafSetProtocol.mergeLeafSet(LeafSet remotels, NodeHandle from)` Merge a remote leafset into our own
`void` | `ConsistentJoinProtocol.nodeSetUpdate(NodeSetEventSource set, NodeHandle handle, boolean added)`
`void` | `PartitionHandler.nodeSetUpdate(NodeSetEventSource nodeSetEventSource, NodeHandle handle, boolean added)`
`void` | `PeriodicLeafSetProtocol.nodeSetUpdate(NodeSetEventSource nodeSetEventSource, NodeHandle handle, boolean added)`
`void` | `PartitionHandler.rejoin(NodeHandle target)` Manually kicks off a probe to a given target node.
`void` | `PeriodicLeafSetProtocol.removeFromLeafsetIfPossible(NodeHandle nh)`
`protected void` | `RapidRerouter.rerouteMe(RouteMessage rm, NodeHandle oldDest, java.lang.Exception ioe)`
`void` | `ConsistentJoinProtocol.sendTheMessage(NodeHandle nh, boolean reply)` Sends a consistent join protocol message.
`protected void` | `RapidRerouter.sendTheMessage(RouteMessage rm, NodeHandle handle)`
`protected void` | `StandardRouter.sendTheMessage(RouteMessage rm, NodeHandle handle)`

Method parameters in rice.pastry.standard with type arguments of type NodeHandle
`Cancellable` | `ProximityNeighborSelector.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)`
`Cancellable` | `ProximityNeighborSelector.getNearHandles(java.util.Collection<NodeHandle> bootHandles, Continuation<java.util.Collection<NodeHandle>,java.lang.Exception> deliverResultToMe)`
`void` | `StandardJoinProtocol.initiateJoin(java.util.Collection<NodeHandle> bootstrap)`

Constructors in rice.pastry.standard with parameters of type NodeHandle
`ConsistentJoinMsg(InputBuffer buf, NodeHandleFactory nhf, NodeHandle sender)`
`ConsistentJoinProtocol(PastryNode ln, NodeHandle lh, RoutingTable rt, LeafSet ls, ReadyStrategy nextReadyStrategy)`
`ConsistentJoinProtocol(PastryNode ln, NodeHandle lh, RoutingTable rt, LeafSet ls, ReadyStrategy nextReadyStrategy, MessageDeserializer md)` Constructor takes in the usual suspects.
`PeriodicLeafSetProtocol(PastryNode ln, NodeHandle local, LeafSet ls, RoutingTable rt)` Builds a periodic leafset protocol
`StandardJoinProtocol(PastryNode ln, NodeHandle lh, RoutingTable rt, LeafSet ls)` Constructor.
`StandardJoinProtocol(PastryNode ln, NodeHandle lh, RoutingTable rt, LeafSet ls, MessageDeserializer md)`
`StandardLeafSetProtocol(PastryNode ln, NodeHandle local, LeafSet ls, RoutingTable rt)`

Constructor parameters in rice.pastry.standard with type arguments of type NodeHandle
`ConsistentJoinMsg(LeafSet ls, java.util.HashSet<NodeHandle> failed, boolean request)`

Uses of NodeHandle in rice.pastry.testing

Subclasses of NodeHandle in rice.pastry.testing
`static class` | `LeafSetTest.TestNodeHandle`

Methods in rice.pastry.testing that return NodeHandle
`protected NodeHandle` | `ClosestRegrTest.getBootstrap()` Get pastryNodes.last() to bootstrap with, or return null.
`protected NodeHandle` | `DirectPastryRegrTest.getBootstrap(boolean firstNode)` Get pastryNodes.last() to bootstrap with, or return null.
`protected NodeHandle` | `DistHelloWorld.getBootstrap(boolean firstNode)` Gets a handle to a bootstrap node.
`protected NodeHandle` | `DistPastryRegrTest.getBootstrap(boolean firstNode)` Gets a handle to a bootstrap node.
`protected abstract NodeHandle` | `PastryRegrTest.getBootstrap(boolean firstNode)` get a node handle to bootstrap from.

Methods in rice.pastry.testing with parameters of type NodeHandle
`boolean` | `HelloWorldApp.enrouteMessage(Message msg, Id key, NodeHandle nextHop, SendOptions opt)` Invoked on intermediate nodes in routing path.
`boolean` | `Ping.enrouteMessage(Message msg, Id from, NodeHandle nextHop, SendOptions opt)`
`boolean` | `PingClient.enrouteMessage(Message msg, Id from, NodeHandle nextHop, SendOptions opt)`
`protected PastryNode` | `PastryRegrTest.generateNode(NodeHandle bootstrap)`
`protected LeafSet` | `PartitionChecker.getLeafSet(NodeHandle nh)`
`protected boolean` | `DirectPastryRegrTest.isReallyAlive(NodeHandle nh)` get authoritative information about liveness of node.
`boolean` | `DistPastryRegrTest.isReallyAlive(NodeHandle nh)`
`protected abstract boolean` | `PastryRegrTest.isReallyAlive(NodeHandle nh)` determine whether this node is really alive.
`void` | `HelloWorldApp.leafSetChange(NodeHandle nh, boolean wasAdded)` Invoked upon change to leafset.
`void` | `Ping.leafSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `PingClient.leafSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `RoutingTableTest.MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `HelloWorldApp.routeSetChange(NodeHandle nh, boolean wasAdded)` Invoked upon change to routing table.
`void` | `Ping.routeSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `PingClient.routeSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `RegrTestApp.routeSetChange(NodeHandle nh, boolean wasAdded)`
`void` | `RegrTestApp.update(NodeHandle nh, boolean wasAdded)`

Constructors in rice.pastry.testing with parameters of type NodeHandle
`HelloMsg(int addr, NodeHandle src, Id tgt, int mid)`
`PingMessageNew(int pingAddress, NodeHandle src, Id tgt)`

Uses of NodeHandle in rice.pastry.transport

Subclasses of NodeHandle in rice.pastry.transport
`class` | `BogusNodeHandle`

Methods in rice.pastry.transport that return NodeHandle
`NodeHandle` | `PMessageReceipt.getIdentifier()`
`NodeHandle` | `PMessageReceiptImpl.getIdentifier()`
`protected abstract NodeHandle` | `TransportPastryNodeFactory.getLocalHandle(PastryNode pn, NodeHandleFactory handleFactory)`
`NodeHandle` | `NodeHandleAdapter.getLocalIdentifier()`

Methods in rice.pastry.transport that return types with arguments of type NodeHandle
`MessageRequestHandle<NodeHandle,RawMessage>` | `PMessageReceiptImpl.getInternal()`
`SocketRequestHandle<NodeHandle>` | `NodeHandleAdapter.openSocket(NodeHandle i, SocketCallback<NodeHandle> deliverSocketToMe, java.util.Map<java.lang.String,java.lang.Object> options)`
`MessageRequestHandle<NodeHandle,RawMessage>` | `NodeHandleAdapter.sendMessage(NodeHandle i, RawMessage m, MessageCallback<NodeHandle,RawMessage> deliverAckToMe, java.util.Map<java.lang.String,java.lang.Object> options)`

Methods in rice.pastry.transport with parameters of type NodeHandle
`boolean` | `NodeHandleAdapter.checkLiveness(NodeHandle i, java.util.Map<java.lang.String,java.lang.Object> options)`
`void` | `NodeHandleAdapter.clearState(NodeHandle i)`
`int` | `NodeHandleAdapter.getLiveness(NodeHandle i, java.util.Map<java.lang.String,java.lang.Object> options)`
`SocketRequestHandle<NodeHandle>` | `NodeHandleAdapter.openSocket(NodeHandle i, SocketCallback<NodeHandle> deliverSocketToMe, java.util.Map<java.lang.String,java.lang.Object> options)`
`int` | `NodeHandleAdapter.proximity(NodeHandle i, java.util.Map<java.lang.String,java.lang.Object> options)`
`MessageRequestHandle<NodeHandle,RawMessage>` | `NodeHandleAdapter.sendMessage(NodeHandle i, RawMessage m, MessageCallback<NodeHandle,RawMessage> deliverAckToMe, java.util.Map<java.lang.String,java.lang.Object> options)`

Method parameters in rice.pastry.transport with type arguments of type NodeHandle
`void` | `NodeHandleAdapter.addLivenessListener(LivenessListener<NodeHandle> name)`
`void` | `NodeHandleAdapter.addProximityListener(ProximityListener<NodeHandle> listener)`
`SocketRequestHandle<NodeHandle>` | `NodeHandleAdapter.openSocket(NodeHandle i, SocketCallback<NodeHandle> deliverSocketToMe, java.util.Map<java.lang.String,java.lang.Object> options)`
`boolean` | `NodeHandleAdapter.removeLivenessListener(LivenessListener<NodeHandle> name)`
`boolean` | `NodeHandleAdapter.removeProximityListener(ProximityListener<NodeHandle> listener)`
`MessageRequestHandle<NodeHandle,RawMessage>` | `NodeHandleAdapter.sendMessage(NodeHandle i, RawMessage m, MessageCallback<NodeHandle,RawMessage> deliverAckToMe, java.util.Map<java.lang.String,java.lang.Object> options)`
`void` | `NodeHandleAdapter.setCallback(TransportLayerCallback<NodeHandle,RawMessage> callback)`
`void` | `NodeHandleAdapter.setErrorHandler(ErrorHandler<NodeHandle> handler)`
`void` | `PMessageReceiptImpl.setInternal(MessageRequestHandle<NodeHandle,RawMessage> name)` See synchronization note on cancel()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Rice Pastry API
PREV NEXT | FRAMES NO FRAMES

Copyright © 2001-2005 - Rice Pastry.