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

## Uses of Class
rice.p2p.commonapi.NodeHandle

Packages that use NodeHandle
org.mpisws.p2p.testing.transportlayer.replay |
org.mpisws.p2p.transport.commonapi |
org.mpisws.p2p.transport.security |
rice.p2p.aggregation |
rice.p2p.aggregation.messaging |
rice.p2p.commonapi |
rice.p2p.commonapi.rawserialization |
rice.p2p.glacier.v2 |
rice.p2p.glacier.v2.messaging |
rice.p2p.multiring |
rice.p2p.multiring.testing |
rice.p2p.past |
rice.p2p.past.gc |
rice.p2p.past.gc.messaging |
rice.p2p.past.gc.rawserialization |
rice.p2p.past.messaging |
rice.p2p.past.rawserialization |
rice.p2p.past.testing |
rice.p2p.replication |
rice.p2p.replication.manager |
rice.p2p.replication.manager.testing |
rice.p2p.replication.messaging |
rice.p2p.replication.testing |
rice.p2p.scribe |
rice.p2p.scribe.javaserialized |
rice.p2p.scribe.maintenance |
rice.p2p.scribe.messaging |
rice.p2p.scribe.rawserialization |
rice.p2p.scribe.testing |
rice.p2p.splitstream |
rice.p2p.util |
rice.p2p.util.rawserialization |
rice.pastry |
rice.pastry.client |
rice.pastry.commonapi |
rice.pastry.direct |
rice.pastry.dist |
rice.pastry.leafset |
rice.pastry.leafset.testing |
rice.pastry.messaging |
rice.pastry.routing |
rice.pastry.socket |
rice.pastry.socket.nat.rendezvous |
rice.pastry.testing |
rice.pastry.transport |
rice.tutorial.appsocket |
rice.tutorial.direct |
rice.tutorial.forwarding |
rice.tutorial.gtitm |
rice.tutorial.lesson3 |
rice.tutorial.lesson4 |
rice.tutorial.rawserialization |
rice.tutorial.rawserialization2 |
rice.tutorial.scribe |
rice.tutorial.splitstream |
rice.tutorial.timer |
rice.tutorial.transportdirect |
rice.tutorial.transportlayer |

Uses of NodeHandle in org.mpisws.p2p.testing.transportlayer.replay

Methods in org.mpisws.p2p.testing.transportlayer.replay that return NodeHandle
`NodeHandle[]` | `MyScribeClient.getChildren()`
`NodeHandle` | `MyScribeClient.getParent()`
`static NodeHandle` | `Recorder.getRoot(NodeHandle seed, java.util.Hashtable appTable)` Recursively crawl up the tree to find the root.

Methods in org.mpisws.p2p.testing.transportlayer.replay with parameters of type NodeHandle
`void` | `MyScribeClient.childAdded(Topic topic, NodeHandle child)`
`void` | `MyScribeClient.childRemoved(Topic topic, NodeHandle child)`
`static NodeHandle` | `Recorder.getRoot(NodeHandle seed, java.util.Hashtable appTable)` Recursively crawl up the tree to find the root.
`static void` | `Recorder.recursivelyPrintChildren(NodeHandle curNode, int recursionDepth, java.util.Hashtable appTable)` Print's self, then children.
`void` | `MyScribeClient.update(NodeHandle handle, boolean joined)`

Constructors in org.mpisws.p2p.testing.transportlayer.replay with parameters of type NodeHandle
`MyScribeContent(NodeHandle from, int seq)` Simple constructor.

Uses of NodeHandle in org.mpisws.p2p.transport.commonapi

Classes in org.mpisws.p2p.transport.commonapi with type parameters of type NodeHandle
`interface` | `CommonAPITransportLayer<Identifier extends NodeHandle>` TransportLayer for the rice.p2p.commonapi.
`class` | `CommonAPITransportLayerImpl<Identifier extends NodeHandle>`

Subclasses of NodeHandle in org.mpisws.p2p.transport.commonapi
`class` | `TransportLayerNodeHandle<Identifier>` Parallel interface to the CommonAPI NodeHandle, because it is an abstract object to gain the observer pattern.

Methods in org.mpisws.p2p.transport.commonapi with parameters of type NodeHandle
`RawMessage` | `RawMessageDeserializer.deserialize(InputBuffer b, NodeHandle sender)`

Uses of NodeHandle in org.mpisws.p2p.transport.security

Methods in org.mpisws.p2p.transport.security with parameters of type NodeHandle
`Certificate` | `CertificateTransportLayer.getCertificate(NodeHandle handle)`
`void` | `CertificateFactory.getCertificate(NodeHandle handle, Continuation<Certificate,java.lang.Exception> response)`

Uses of NodeHandle in rice.p2p.aggregation

Fields in rice.p2p.aggregation declared as NodeHandle
`protected NodeHandle` | `AggregateHandle.handle`

Methods in rice.p2p.aggregation that return NodeHandle
`NodeHandle` | `AggregationImpl.getLocalNodeHandle()`
`NodeHandle` | `Moraine.getLocalNodeHandle()`
`NodeHandle` | `AggregateHandle.getNodeHandle()`

Methods in rice.p2p.aggregation with parameters of type NodeHandle
`void` | `AggregationImpl.lookupHandle(Id id, NodeHandle handle, Continuation command)`
`void` | `Moraine.lookupHandle(Id id, NodeHandle handle, Continuation command)`
`void` | `AggregationImpl.update(NodeHandle handle, boolean joined)`

Constructors in rice.p2p.aggregation with parameters of type NodeHandle
`AggregateHandle(NodeHandle handle, Id id, long version, long expiration)`

Uses of NodeHandle in rice.p2p.aggregation.messaging

Fields in rice.p2p.aggregation.messaging declared as NodeHandle
`protected NodeHandle` | `AggregationMessage.source`

Methods in rice.p2p.aggregation.messaging that return NodeHandle
`NodeHandle` | `AggregationMessage.getSource()` Method which returns this messages' source address

Constructors in rice.p2p.aggregation.messaging with parameters of type NodeHandle
`AggregationMessage(int id, NodeHandle source, Id dest)` Constructor which takes a unique integer Id
`AggregationTimeoutMessage(int uid, NodeHandle local)`

Uses of NodeHandle in rice.p2p.commonapi

Methods in rice.p2p.commonapi that return NodeHandle
`NodeHandle` | `NodeHandleSet.getHandle(Id id)` Finds the NodeHandle associated with the NodeId.
`NodeHandle` | `NodeHandleSet.getHandle(int i)` Gets the ith element in the set.
`NodeHandle` | `MessageReceipt.getHint()`
`NodeHandle` | `Endpoint.getLocalNodeHandle()` Returns a handle to the local node below this endpoint.
`NodeHandle` | `Node.getLocalNodeHandle()` Returns a handle to the local node.
`NodeHandle` | `RouteMessage.getNextHopHandle()` Returns the next hop handle for this message
`NodeHandle` | `NodeHandleSet.removeHandle(Id id)` Removes a node id and its handle from the set.

Methods in rice.p2p.commonapi with parameters of type NodeHandle
`void` | `Endpoint.connect(NodeHandle handle, AppSocketReceiver receiver, int timeout)` Opens a connection to this application on a remote node.
`int` | `Endpoint.proximity(NodeHandle nh)` This replaces NodeHandle.proximity(), so that you don't have to have a "coalesced" NodeHandle.
`boolean` | `NodeHandleSet.putHandle(NodeHandle handle)` Puts a NodeHandle into the set.
`IdRange` | `Endpoint.range(NodeHandle handle, int rank, Id lkey)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`IdRange` | `Endpoint.range(NodeHandle handle, int rank, Id lkey, boolean cumulative)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`NodeHandleSet` | `Endpoint.replicaSet(Id id, int maxRank, NodeHandle root, NodeHandleSet set)` This methods returns an ordered set of nodehandles on which replicas of an object with a given id can be stored.
`MessageReceipt` | `Endpoint.route(Id id, Message message, NodeHandle hint)` This method makes an attempt to route the message to the root of the given id.
`MessageReceipt` | `Endpoint.route(Id id, Message message, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`MessageReceipt` | `Endpoint.route(Id id, RawMessage message, NodeHandle hint)` Same as the other call, but uses the Raw serialization rather than java serialization.
`MessageReceipt` | `Endpoint.route(Id id, RawMessage message, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`void` | `RouteMessage.setNextHopHandle(NodeHandle nextHop)` Sets the next hop handle for this message
`void` | `Application.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Uses of NodeHandle in rice.p2p.commonapi.rawserialization

Methods in rice.p2p.commonapi.rawserialization that return NodeHandle
`NodeHandle` | `NodeHandleReader.coalesce(NodeHandle handle)`
`NodeHandle` | `NodeHandleReader.readNodeHandle(InputBuffer buf)` To use Raw Serialization

Methods in rice.p2p.commonapi.rawserialization with parameters of type NodeHandle
`NodeHandle` | `NodeHandleReader.coalesce(NodeHandle handle)`
`Message` | `MessageDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)` Typical implementation: RawMessage ret = super.deserialize(); if (ret != null) return ret; Endpoint endpoint; switch(type) { case 1: return new MyMessage(buf, endpoint); }

Uses of NodeHandle in rice.p2p.glacier.v2

Fields in rice.p2p.glacier.v2 declared as NodeHandle
`protected NodeHandle` | `DebugContentHandle.myNodeHandle`
`protected NodeHandle` | `GlacierContentHandle.nodeHandle`

Methods in rice.p2p.glacier.v2 that return NodeHandle
`NodeHandle` | `GlacierImpl.getLocalNodeHandle()`
`NodeHandle` | `DebugContentHandle.getNodeHandle()`
`NodeHandle` | `GlacierContentHandle.getNodeHandle()`

Methods in rice.p2p.glacier.v2 with parameters of type NodeHandle
`void` | `GlacierImpl.lookupHandle(Id id, NodeHandle handle, Continuation command)`
`void` | `GlacierImpl.sendMessage(Id id, GlacierMessage message, NodeHandle hint)`
`void` | `GlacierImpl.update(NodeHandle handle, boolean joined)`

Constructors in rice.p2p.glacier.v2 with parameters of type NodeHandle
`GlacierContentHandle(Id id, long version, NodeHandle nodeHandle, Manifest manifest)`

Uses of NodeHandle in rice.p2p.glacier.v2.messaging

Fields in rice.p2p.glacier.v2.messaging declared as NodeHandle
`protected NodeHandle` | `GlacierRangeForwardMessage.requestor`
`protected NodeHandle` | `GlacierMessage.source`

Methods in rice.p2p.glacier.v2.messaging that return NodeHandle
`NodeHandle` | `GlacierRangeForwardMessage.getRequestor()`
`NodeHandle` | `GlacierMessage.getSource()` Method which returns this messages' source address

Constructors in rice.p2p.glacier.v2.messaging with parameters of type NodeHandle
`GlacierDataMessage(int uid, FragmentKey[] keys, Fragment[] fragments, Manifest[] manifests, NodeHandle source, Id dest, boolean isResponse, char tag)`
`GlacierDataMessage(int uid, FragmentKey key, Fragment fragment, Manifest manifest, NodeHandle source, Id dest, boolean isResponse, char tag)`
`GlacierFetchMessage(int uid, FragmentKey[] keys, int request, NodeHandle source, Id dest, char tag)`
`GlacierFetchMessage(int uid, FragmentKey key, int request, NodeHandle source, Id dest, char tag)`
`GlacierMessage(int id, NodeHandle source, Id dest, boolean isResponse, char tag)` Constructor which takes a unique integer Id
`GlacierNeighborRequestMessage(int uid, IdRange requestedRange, NodeHandle source, Id dest, char tag)`
`GlacierNeighborResponseMessage(int uid, Id[] neighbors, long[] lastSeen, NodeHandle source, Id dest, char tag)`
`GlacierQueryMessage(int uid, FragmentKey[] keys, NodeHandle source, Id dest, char tag)`
`GlacierRangeForwardMessage(int uid, IdRange requestedRange, NodeHandle requestor, NodeHandle source, Id dest, char tag)`
`GlacierRangeQueryMessage(int uid, IdRange requestedRange, NodeHandle source, Id dest, char tag)`
`GlacierRangeResponseMessage(int uid, IdRange commonRange, NodeHandle source, Id dest, char tag)`
`GlacierRefreshCompleteMessage(int uid, VersionKey[] keys, int[] updates, NodeHandle source, Id dest, char tag)`
`GlacierRefreshPatchMessage(int uid, VersionKey[] keys, long[] lifetimes, byte[][] signatures, NodeHandle source, Id dest, char tag)`
`GlacierRefreshProbeMessage(int uid, Id requestedId, NodeHandle source, Id dest, char tag)`
`GlacierRefreshResponseMessage(int uid, IdRange range, boolean online, NodeHandle source, Id dest, char tag)`
`GlacierResponseMessage(int uid, FragmentKey[] keys, boolean[] haveIt, long[] lifetimes, boolean[] authoritative, NodeHandle source, Id dest, boolean isResponse, char tag)`
`GlacierResponseMessage(int uid, FragmentKey key, boolean haveIt, long lifetime, boolean authoritative, NodeHandle source, Id dest, boolean isResponse, char tag)`
`GlacierSyncMessage(int uid, IdRange range, int offsetFID, BloomFilter BloomFilter, NodeHandle source, Id dest, char tag)`
`GlacierTimeoutMessage(int uid, NodeHandle local)` Constructor which takes a unique integer Id and the local id

Uses of NodeHandle in rice.p2p.multiring

Subclasses of NodeHandle in rice.p2p.multiring
`class` | `MultiringNodeHandle`

Fields in rice.p2p.multiring declared as NodeHandle
`protected NodeHandle` | `MultiringNodeHandle.handle` The internal handle

Methods in rice.p2p.multiring that return NodeHandle
`NodeHandle` | `MultiringEndpoint.coalesce(NodeHandle handle)`
`protected NodeHandle` | `MultiringNodeHandle.getHandle()` Returns the internal handle
`NodeHandle` | `MultiringNodeHandleSet.getHandle(Id id)` Finds the NodeHandle associated with the NodeId.
`NodeHandle` | `MultiringNodeHandleSet.getHandle(int i)` Gets the ith element in the set.
`NodeHandle` | `MultiringEndpoint.getLocalNodeHandle()` Returns a handle to the local node below this endpoint.
`NodeHandle` | `MultiringNode.getLocalNodeHandle()`
`NodeHandle` | `MultiringRouteMessage.getNextHopHandle()` Returns the next hop handle for this message
`NodeHandle` | `MultiringEndpoint.readNodeHandle(InputBuffer buf)`
`NodeHandle` | `MultiringNodeHandleSet.removeHandle(Id id)` Removes a node id and its handle from the set.

Methods in rice.p2p.multiring with parameters of type NodeHandle
`void` | `MultiringNode.childAdded(Topic topic, NodeHandle child)` Informs this client that a child was added to a topic in which it was interested in.
`void` | `MultiringNode.childRemoved(Topic topic, NodeHandle child)` Informs this client that a child was removed from a topic in which it was interested in.
`NodeHandle` | `MultiringEndpoint.coalesce(NodeHandle handle)`
`void` | `MultiringEndpoint.connect(NodeHandle handle, AppSocketReceiver receiver, int timeout)` Passthrough to sub endpoint.
`int` | `MultiringEndpoint.proximity(NodeHandle nh)`
`boolean` | `MultiringNodeHandleSet.putHandle(NodeHandle handle)` Puts a NodeHandle into the set.
`IdRange` | `MultiringEndpoint.range(NodeHandle handle, int rank, Id lkey)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`IdRange` | `MultiringEndpoint.range(NodeHandle handle, int rank, Id lkey, boolean cumulative)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`NodeHandleSet` | `MultiringEndpoint.replicaSet(Id id, int maxRank, NodeHandle root, NodeHandleSet set)` This methods returns an ordered set of nodehandles on which replicas of an object with a given id can be stored.
`MessageReceipt` | `MultiringEndpoint.route(Id id, Message message, NodeHandle hint)` This method makes an attempt to route the message to the root of the given id.
`MessageReceipt` | `MultiringEndpoint.route(Id id, Message message, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`MessageReceipt` | `MultiringEndpoint.route(Id id, RawMessage message, NodeHandle hint)`
`MessageReceipt` | `MultiringEndpoint.route(Id id, RawMessage message, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`void` | `MultiringRouteMessage.setNextHopHandle(NodeHandle nextHop)` Sets the next hop handle for this message
`void` | `MultiringApplication.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Constructors in rice.p2p.multiring with parameters of type NodeHandle
`MultiringNodeHandle(Id ringId, NodeHandle handle)` Constructor

Uses of NodeHandle in rice.p2p.multiring.testing

Methods in rice.p2p.multiring.testing with parameters of type NodeHandle
`void` | `MultiringRegrTest.MultiringTestApp.update(NodeHandle handle, boolean joined)`

Uses of NodeHandle in rice.p2p.past

Methods in rice.p2p.past that return NodeHandle
`NodeHandle` | `Past.getLocalNodeHandle()` get the nodeHandle of the local Past node
`NodeHandle` | `PastImpl.getLocalNodeHandle()` get the nodeHandle of the local Past node
`NodeHandle` | `ContentHashPastContentHandle.getNodeHandle()` Returns the NodeHandle of the Past node on which the object associated with this handle is stored
`NodeHandle` | `PastContentHandle.getNodeHandle()` get the NodeHandle of the Past node on which the object associated with this handle is stored

Methods in rice.p2p.past with parameters of type NodeHandle
`Message` | `PastImpl.PastDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`void` | `PastPolicy.fetch(Id id, NodeHandle hint, Cache backup, Past past, Continuation command)` This method is called when Past is told to fetch a key.
`void` | `PastPolicy.DefaultPastPolicy.fetch(Id id, NodeHandle hint, Cache backup, Past past, Continuation command)` This method fetches the object via a lookup() call.
`void` | `PastImpl.fetch(Id id, NodeHandle hint, Continuation command)` This upcall is invoked to tell the client to fetch the given id, and to call the given command with the boolean result once the fetch is completed.
`void` | `Past.lookupHandle(Id id, NodeHandle handle, Continuation command)` Retrieves the handle for the given object stored on the requested node.
`void` | `PastImpl.lookupHandle(Id id, NodeHandle handle, Continuation command)` Retrieves the handle for the given object stored on the requested node.
`protected void` | `PastImpl.sendRequest(Id id, PastMessage message, NodeHandle hint, Continuation command)` Sends a request message across the wire, and stores the appropriate continuation.
`protected void` | `PastImpl.sendRequest(NodeHandle handle, PastMessage message, Continuation command)` Sends a request message across the wire, and stores the appropriate continuation.
`void` | `PastImpl.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Constructors in rice.p2p.past with parameters of type NodeHandle
`ContentHashPastContentHandle(NodeHandle nh, Id id)` Constructor

Uses of NodeHandle in rice.p2p.past.gc

Methods in rice.p2p.past.gc that return NodeHandle
`NodeHandle` | `GCEndpoint.coalesce(NodeHandle handle)`
`NodeHandle` | `GCEndpoint.getLocalNodeHandle()` Returns a handle to the local node below this endpoint.
`NodeHandle` | `GCNode.getLocalNodeHandle()` Method which returns the node handle to the local node
`NodeHandle` | `GCEndpoint.readNodeHandle(InputBuffer buf)`

Methods in rice.p2p.past.gc with parameters of type NodeHandle
`void` | `GCPastImpl.ReplicaMap.addReplica(NodeHandle handle, GCId id)`
`NodeHandle` | `GCEndpoint.coalesce(NodeHandle handle)`
`void` | `GCEndpoint.connect(NodeHandle handle, AppSocketReceiver receiver, int timeout)` Passthrough to the sub endpoint.
`Message` | `GCPastImpl.GCPastDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`void` | `GCPastImpl.fetch(Id id, NodeHandle hint, Continuation command)` This upcall is invoked to tell the client to fetch the given id, and to call the given command with the boolean result once the fetch is completed.
`GCIdSet` | `GCPastImpl.ReplicaMap.getIds(NodeHandle replica)`
`int` | `GCEndpoint.proximity(NodeHandle nh)`
`IdRange` | `GCEndpoint.range(NodeHandle handle, int rank, Id lkey)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`IdRange` | `GCEndpoint.range(NodeHandle handle, int rank, Id lkey, boolean cumulative)` This operation provides information about ranges of keys for which the node is currently a rank-root.
`NodeHandleSet` | `GCEndpoint.replicaSet(Id id, int maxRank, NodeHandle root, NodeHandleSet set)` This methods returns an ordered set of nodehandles on which replicas of an object with a given id can be stored.
`MessageReceipt` | `GCEndpoint.route(Id id, Message message, NodeHandle hint)` This method makes an attempt to route the message to the root of the given id.
`MessageReceipt` | `GCEndpoint.route(Id id, Message message, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`MessageReceipt` | `GCEndpoint.route(Id id, RawMessage message, NodeHandle hint)`
`MessageReceipt` | `GCEndpoint.route(Id id, RawMessage message, NodeHandle hint, DeliveryNotification deliverAckToMe)`

Uses of NodeHandle in rice.p2p.past.gc.messaging

Constructors in rice.p2p.past.gc.messaging with parameters of type NodeHandle
`GCCollectMessage(int id, NodeHandle source, Id dest)` Constructor
`GCInsertMessage(int uid, PastContent content, long expiration, NodeHandle source, Id dest)` Constructor which takes a unique integer Id, as well as the data to be stored
`GCLookupHandlesMessage(int uid, Id id, NodeHandle source, Id dest)` Constructor
`GCRefreshMessage(int uid, GCIdSet keys, NodeHandle source, Id dest)` Constructor which takes a unique integer Id, as well as the keys to be refreshed

Uses of NodeHandle in rice.p2p.past.gc.rawserialization

Methods in rice.p2p.past.gc.rawserialization that return NodeHandle
`NodeHandle` | `JavaSerializedGCPastContentHandle.getNodeHandle()`

Uses of NodeHandle in rice.p2p.past.messaging

Fields in rice.p2p.past.messaging declared as NodeHandle
`protected NodeHandle` | `MessageLostMessage.hint`
`protected NodeHandle` | `PastMessage.source`

Methods in rice.p2p.past.messaging that return NodeHandle
`NodeHandle` | `LookupMessage.getPreviousNodeHandle()` Method which returns the previous hop (where the message was just at)
`NodeHandle` | `PastMessage.getSource()` Method which returns this messages' source address

Methods in rice.p2p.past.messaging with parameters of type NodeHandle
`void` | `LookupMessage.addHop(NodeHandle handle)` Method which is designed to be overridden by subclasses if they need to keep track of where they've been.
`void` | `PastMessage.addHop(NodeHandle handle)` Method which is designed to be overridden by subclasses if they need to keep track of where they've been.

Constructors in rice.p2p.past.messaging with parameters of type NodeHandle
`CacheMessage(int uid, PastContent content, NodeHandle source, Id dest)` Constructor which takes a unique integer Id and the local id
`CacheMessage(int uid, RawPastContent content, NodeHandle source, Id dest)`
`ContinuationMessage(int uid, NodeHandle source, Id dest)` Constructor which takes a unique integer Id, as well as the data to be stored
`FetchHandleMessage(int uid, Id id, NodeHandle source, Id dest)` Constructor
`FetchMessage(int uid, PastContentHandle handle, NodeHandle source, Id dest)` Constructor
`FetchMessage(int uid, RawPastContentHandle handle, NodeHandle source, Id dest)`
`InsertMessage(int uid, PastContent content, NodeHandle source, Id dest)` Constructor which takes a unique integer Id, as well as the data to be stored
`InsertMessage(int uid, RawPastContent content, NodeHandle source, Id dest)`
`LookupHandlesMessage(int uid, Id id, int max, NodeHandle source, Id dest)` Constructor
`LookupMessage(int uid, Id id, NodeHandle source, Id dest)` Constructor
`MessageLostMessage(int uid, NodeHandle local, Id id, Message message, NodeHandle hint)` Constructor which takes a unique integer Id and the local id
`PastMessage(int id, NodeHandle source, Id dest)` Constructor which takes a unique integer Id

Uses of NodeHandle in rice.p2p.past.rawserialization

Methods in rice.p2p.past.rawserialization that return NodeHandle
`NodeHandle` | `JavaSerializedPastContentHandle.getNodeHandle()`

Uses of NodeHandle in rice.p2p.past.testing

Fields in rice.p2p.past.testing declared as NodeHandle
`protected NodeHandle` | `PastRegrTest.TestPastContentHandle.handle`
`protected NodeHandle` | `RawPastRegrTest.TestPastContentHandle.handle`

Methods in rice.p2p.past.testing that return NodeHandle
`NodeHandle` | `PastRegrTest.TestRouteMessage.getNextHopHandle()`
`NodeHandle` | `RawPastRegrTest.TestRouteMessage.getNextHopHandle()`
`NodeHandle` | `PastRegrTest.TestPastContentHandle.getNodeHandle()`
`NodeHandle` | `RawPastRegrTest.TestPastContentHandle.getNodeHandle()`

Methods in rice.p2p.past.testing with parameters of type NodeHandle
`void` | `PastRegrTest.TestRouteMessage.setNextHopHandle(NodeHandle nextHop)`
`void` | `RawPastRegrTest.TestRouteMessage.setNextHopHandle(NodeHandle nextHop)`

Constructors in rice.p2p.past.testing with parameters of type NodeHandle
`PastRegrTest.TestRouteMessage(Id id, NodeHandle nextHop, Message message)`
`RawPastRegrTest.TestRouteMessage(Id id, NodeHandle nextHop, Message message)`

Uses of NodeHandle in rice.p2p.replication

Fields in rice.p2p.replication declared as NodeHandle
`protected NodeHandle` | `ReplicationImpl.handle` the local node handle

Methods in rice.p2p.replication with parameters of type NodeHandle
`void` | `ReplicationClient.fetch(IdSet keySet, NodeHandle hint)` This upcall is invoked to notify the application that is should fetch the cooresponding keys in this set, since the node is now responsible for these keys also.
`void` | `ReplicationImpl.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Uses of NodeHandle in rice.p2p.replication.manager

Methods in rice.p2p.replication.manager with parameters of type NodeHandle
`void` | `ReplicationManagerClient.fetch(Id id, NodeHandle hint, Continuation command)` This upcall is invoked to tell the client to fetch the given id, and to call the given command with the boolean result once the fetch is completed.
`void` | `ReplicationManagerImpl.fetch(IdSet keySet, NodeHandle hint)` This upcall is invoked to notify the application that is should fetch the cooresponding keys in this set, since the node is now responsible for these keys also.
`void` | `ReplicationManagerImpl.ReplicationManagerHelper.fetch(IdSet keySet, NodeHandle hint)` Method by which keys are added to the list of keys to fetch
`protected void` | `ReplicationManagerImpl.informClient(Id id, NodeHandle hint)` Internal method which informs the client of the next id to fetch
`void` | `ReplicationManagerImpl.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Uses of NodeHandle in rice.p2p.replication.manager.testing

Methods in rice.p2p.replication.manager.testing with parameters of type NodeHandle
`void` | `ReplicationManagerRegrTest.TestReplicationManagerClient.fetch(Id id, NodeHandle hint, Continuation command)`

Uses of NodeHandle in rice.p2p.replication.messaging

Fields in rice.p2p.replication.messaging declared as NodeHandle
`protected NodeHandle` | `ReplicationMessage.source`

Methods in rice.p2p.replication.messaging that return NodeHandle
`NodeHandle` | `ReplicationMessage.getSource()` Method which returns this messages' source address

Constructors in rice.p2p.replication.messaging with parameters of type NodeHandle
`ReminderMessage(NodeHandle source)` Constructor which takes a unique integer Id
`ReplicationMessage(NodeHandle source)` Constructor which takes a unique integer Id
`RequestMessage(NodeHandle source, IdRange[] ranges, IdBloomFilter[] filters)` Constructor which takes a unique integer Id
`ResponseMessage(NodeHandle source, IdRange[] ranges, IdSet[] setA)` Constructor which takes a unique integer Id

Uses of NodeHandle in rice.p2p.replication.testing

Methods in rice.p2p.replication.testing with parameters of type NodeHandle
`void` | `ReplicationRegrTest.TestReplicationClient.fetch(IdSet keySet, NodeHandle hint)` This upcall is invoked to notify the application that is should fetch the cooresponding keys in this set, since the node is now responsible for these keys also.

Uses of NodeHandle in rice.p2p.scribe

Fields in rice.p2p.scribe declared as NodeHandle
`protected NodeHandle` | `ScribeImpl.localHandle` the local node handle
`protected NodeHandle` | `ScribeImpl.TopicManager.parent` DESCRIBE THE FIELD

Fields in rice.p2p.scribe with type parameters of type NodeHandle
`java.util.HashMap<NodeHandle,java.util.Collection<Topic>>` | `ScribeImpl.allChildren` This contains a mapping of child - > all topics for which the local node has this node(hashtable key) as a child
`java.util.HashMap<NodeHandle,java.util.Collection<Topic>>` | `ScribeImpl.allParents` This contains a mapping of parent - > all topics for which the local node has this node(hashtable key) as a parent
`protected java.util.ArrayList<NodeHandle>` | `ScribeImpl.TopicManager.children` DESCRIBE THE FIELD

Methods in rice.p2p.scribe that return NodeHandle
`NodeHandle[]` | `BaseScribe.getChildren(Topic topic)` Deprecated. use getChildrenOfTopic
`NodeHandle[]` | `ScribeImpl.getChildren(Topic topic)` Returns the list of children for a given topic
`NodeHandle` | `ScribeImpl.TopicManager.getParent()` Gets the Parent attribute of the TopicManager object
`NodeHandle` | `BaseScribe.getParent(Topic topic)` Returns the parent node for a given topic
`NodeHandle` | `ScribeImpl.getParent(Topic topic)` Returns the parent for a given topic
`NodeHandle` | `BaseScribe.getRoot(Topic topic)` Returns the root of the topic, if we can determine it.
`NodeHandle` | `ScribeImpl.getRoot(Topic topic)`

Methods in rice.p2p.scribe that return types with arguments of type NodeHandle
`java.util.Collection<NodeHandle>` | `ScribeImpl.TopicManager.getChildren()` Gets the Children attribute of the TopicManager object
`java.util.Collection<NodeHandle>` | `BaseScribe.getChildrenOfTopic(Topic topic)`
`java.util.Collection<NodeHandle>` | `ScribeImpl.getChildrenOfTopic(Topic topic)`

Methods in rice.p2p.scribe with parameters of type NodeHandle
`void` | `ScribeImpl.TopicManager.addChild(NodeHandle child)` Adds a feature to the Child attribute of the TopicManager object Need to be holding lock: topicManagers
`void` | `BaseScribe.addChild(Topic topic, NodeHandle child)` Adds a child to the given topic
`void` | `ScribeImpl.addChild(Topic topic, NodeHandle child)` Adds a child to the given topic
`protected boolean` | `ScribeImpl.addChildHelper(Topic topic, NodeHandle child)` Adds a child to the given topic, using the specified sequence number in the ack message sent to the child.
`protected void` | `ScribeImpl.addToAllChildren(Topic t, NodeHandle child)` This method should be invoked after the state change in the Topic Manager has been made.
`protected void` | `ScribeImpl.addToAllParents(Topic t, NodeHandle parent)`
`java.util.List<Topic>` | `ScribePolicy.allowSubscribe(Scribe scribe, NodeHandle source, java.util.List<Topic> topics, ScribeContent content)` This method is called when the newChild is about to become our child, and the policy should return whether or not the child should be allowed to become our child.
`java.util.List<Topic>` | `ScribePolicy.DefaultScribePolicy.allowSubscribe(Scribe scribe, NodeHandle source, java.util.List<Topic> topics, ScribeContent content)` If you don't override the deprecated allowSubscribe(), This method always return true;
`boolean` | `ScribePolicy.DefaultScribePolicy.allowSubscribe(SubscribeMessage message, ScribeClient[] clients, NodeHandle[] children)` This method should be deprecated, but is here for reverse compatibility.
`boolean` | `ScribePolicy.LimitedScribePolicy.allowSubscribe(SubscribeMessage message, ScribeClient[] clients, NodeHandle[] children)` This method returns (children.length < maxChildren-1);
`boolean` | `ScribeImpl.allParentsContains(Topic t, NodeHandle parent)`
`boolean` | `ScribeImpl.allParentsContainsParent(NodeHandle parent)`
`void` | `ScribeImpl.anycast(Topic topic, RawScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.anycast(Topic topic, ScribeContent content, NodeHandle hint)`
`void` | `ScribeClient.childAdded(Topic topic, NodeHandle child)` Deprecated. Informs this client that a child was added to a topic in which it was interested in.
`void` | `ScribeImpl.ScribeClientConverter.childAdded(Topic topic, NodeHandle child)`
`void` | `ScribeMultiClient.childAdded(Topic topic, NodeHandle child)` Informs this client that a child was added to a topic in which it was interested in.
`void` | `ScribePolicy.childAdded(Topic topic, NodeHandle child)` Informs this policy that a child was added to a topic - the topic is free to ignore this upcall if it doesn't care.
`void` | `ScribePolicy.DefaultScribePolicy.childAdded(Topic topic, NodeHandle child)` Informs this policy that a child was added to a topic - the topic is free to ignore this upcall if it doesn't care.
`void` | `ScribeClient.childRemoved(Topic topic, NodeHandle child)` Deprecated. Informs this client that a child was removed from a topic in which it was interested in.
`void` | `ScribeImpl.ScribeClientConverter.childRemoved(Topic topic, NodeHandle child)`
`void` | `ScribeMultiClient.childRemoved(Topic topic, NodeHandle child)` Informs this client that a child was removed from a topic in which it was interested in.
`void` | `ScribePolicy.childRemoved(Topic topic, NodeHandle child)` Informs this policy that a child was removed from a topic - the topic is free to ignore this upcall if it doesn't care.
`void` | `ScribePolicy.DefaultScribePolicy.childRemoved(Topic topic, NodeHandle child)` Informs this policy that a child was removed from a topic - the topic is free to ignore this upcall if it doesn't care.
`boolean` | `ScribeImpl.TopicManager.containsChild(NodeHandle child)`
`boolean` | `BaseScribe.containsChild(Topic topic, NodeHandle child)`
`boolean` | `ScribeImpl.containsChild(Topic topic, NodeHandle child)`
`void` | `ScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> children)` This method is called when an anycast is received which is not satisfied at the local node.
`void` | `ScribePolicy.DefaultScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> theChildren)` Simply adds the parent and children in order, which implements a depth-first-search.
`protected void` | `ScribeImpl.doSubscribe(java.util.Collection<Topic> theTopics, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)` This method prevents re-subscription to topics you are already a part of.
`java.util.Collection<Topic>` | `ScribeImpl.getTopicsByChild(NodeHandle child)`
`java.util.Collection<Topic>` | `ScribeImpl.getTopicsByParent(NodeHandle parent)`
`protected void` | `ScribeImpl.recvAnycastFail(Topic topic, NodeHandle failedAtNode, ScribeContent content)`
`void` | `ScribePolicy.recvAnycastFail(Topic topic, NodeHandle failedAtNode, ScribeContent content)` This notifies us when we receive a failure for a anycast
`void` | `ScribePolicy.DefaultScribePolicy.recvAnycastFail(Topic topic, NodeHandle failedAtNode, ScribeContent content)`
`boolean` | `ScribeImpl.TopicManager.removeChild(NodeHandle child)` Removes the child from the topic.
`void` | `BaseScribe.removeChild(Topic topic, NodeHandle child)` Removes a child from the given topic
`void` | `ScribeImpl.removeChild(Topic topic, NodeHandle child)` Removes a child from the given topic
`protected void` | `ScribeImpl.removeChild(Topic topic, NodeHandle child, boolean sendDrop)` Removes a child from the given topic
`protected void` | `ScribeImpl.removeFromAllChildren(Topic t, NodeHandle child)` Need to be holding lock: topicManagers
`protected void` | `ScribeImpl.removeFromAllParents(Topic t, NodeHandle parent)`
`void` | `ScribeImpl.TopicManager.setParent(NodeHandle handle, java.util.List<Id> pathToRoot)` Sets the Parent attribute of the TopicManager object
`void` | `ScribeImpl.setParent(Topic topic, NodeHandle parent, java.util.List<Id> pathToRoot)`
`void` | `ScribeImpl.subscribe(java.util.Collection<Topic> theTopics, ScribeClient client, RawScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(java.util.Collection<Topic> theTopics, ScribeClient client, ScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(java.util.Collection<Topic> theTopics, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(java.util.Collection<Topic> theTopics, ScribeMultiClient client, ScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(Topic topic, ScribeClient client, RawScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(Topic topic, ScribeClient client, ScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(Topic topic, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.subscribe(Topic topic, ScribeMultiClient client, ScribeContent content, NodeHandle hint)`
`void` | `ScribeImpl.update(NodeHandle handle, boolean joined)` This method is invoked to inform the application that the given node has either joined or left the neighbor set of the local node, as the set would be returned by the neighborSet call.

Method parameters in rice.p2p.scribe with type arguments of type NodeHandle
`void` | `ScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> children)` This method is called when an anycast is received which is not satisfied at the local node.
`void` | `ScribePolicy.DefaultScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> theChildren)` Simply adds the parent and children in order, which implements a depth-first-search.

Uses of NodeHandle in rice.p2p.scribe.javaserialized

Methods in rice.p2p.scribe.javaserialized with parameters of type NodeHandle
`void` | `JavaScribe.anycast(Topic topic, ScribeContent content, NodeHandle hint)` Anycasts the given content to a member of the given topic The hint helps us to implement centralized algorithms where the hint is the cachedRoot for the topic.
`void` | `JavaScribe.subscribe(java.util.Collection<Topic> topics, ScribeClient client, ScribeContent content, NodeHandle hint)` Deprecated. use the version with the MultiClient
`void` | `JavaScribe.subscribe(java.util.Collection<Topic> topics, ScribeMultiClient client, ScribeContent content, NodeHandle hint)`
`void` | `JavaScribe.subscribe(Topic topic, ScribeClient client, ScribeContent content, NodeHandle hint)` Deprecated. use the version with the MultiClient
`void` | `JavaScribe.subscribe(Topic topic, ScribeMultiClient client, ScribeContent content, NodeHandle hint)`

Uses of NodeHandle in rice.p2p.scribe.maintenance

Methods in rice.p2p.scribe.maintenance with parameters of type NodeHandle
`java.util.Collection<Topic>` | `MaintainableScribe.getTopicsByChild(NodeHandle child)` This returns the topics for which the parameter 'child' is a Scribe tree child of the local node
`java.util.Collection<Topic>` | `MaintainableScribe.getTopicsByParent(NodeHandle parent)` This returns the topics for which the parameter 'parent' is a Scribe tree parent of the local node
`void` | `ScribeMaintenancePolicy.nodeFaulty(MaintainableScribe scribe, NodeHandle node, java.util.List<Topic> nodeWasParent, java.util.List<Topic> nodeWasChild)` When anyone in any Topic (child or parent) is detected faulty.
`void` | `ScribeMaintenancePolicy.DefaultScribeMaintenancePolicy.nodeFaulty(MaintainableScribe scribe, NodeHandle handle, java.util.List<Topic> nodeWasParent, java.util.List<Topic> nodeWasChild)`
`void` | `MaintainableScribe.setParent(Topic topic, NodeHandle parent, java.util.List<Id> pathToRoot)`
`void` | `MaintainableScribe.subscribe(java.util.Collection<Topic> nodeWasParent, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)`

Uses of NodeHandle in rice.p2p.scribe.messaging

Fields in rice.p2p.scribe.messaging declared as NodeHandle
`protected NodeHandle` | `AnycastMessage.initialRequestor`
`protected NodeHandle` | `AbstractSubscribeMessage.source`
`protected NodeHandle` | `ScribeMessage.source`
`protected NodeHandle` | `SubscribeMessage.subscriber` The original subscriber

Methods in rice.p2p.scribe.messaging that return NodeHandle
`NodeHandle` | `AnycastMessage.getInitialRequestor()`
`NodeHandle` | `AnycastMessage.getLastVisited()`
`NodeHandle` | `AnycastMessage.getNext()` Returns the next handle to visit and removes the node from the list.
`NodeHandle` | `AbstractSubscribeMessage.getSource()` Method which returns this messages' source address
`NodeHandle` | `ScribeMessage.getSource()` Method which returns this messages' source address
`NodeHandle` | `UnsubscribeMessage.getSource()` Method which returns this messages' source address
`NodeHandle` | `SubscribeMessage.getSubscriber()` Returns the node who is trying to subscribe
`NodeHandle` | `AnycastMessage.peekNext()` Returns the next handle to visit

Methods in rice.p2p.scribe.messaging with parameters of type NodeHandle
`void` | `AnycastMessage.addFirst(NodeHandle handle)` Adds a node the the front of the to-visit list
`void` | `AnycastMessage.addLast(NodeHandle handle)` Adds a node the the end of the to-visit list
`void` | `AnycastMessage.addVisited(NodeHandle handle)` Adds a node to the visited list
`void` | `AnycastMessage.remove(NodeHandle handle)` Removes the node handle from the to visit and visited lists
`void` | `ScribeMessage.setSource(NodeHandle source)` Method which set this messages' source address

Constructors in rice.p2p.scribe.messaging with parameters of type NodeHandle
`AbstractSubscribeMessage(NodeHandle source, java.util.List<Topic> topics, int id)` Constructor which takes a unique integer Id
`AnycastFailureMessage(NodeHandle source, Topic topic, RawScribeContent content)`
`AnycastFailureMessage(NodeHandle source, Topic topic, ScribeContent content)`
`AnycastMessage(NodeHandle source, Topic topic, RawScribeContent content)`
`AnycastMessage(NodeHandle source, Topic topic, ScribeContent content)` Constructor which takes a unique integer Id
`DropMessage(NodeHandle source, Topic topic)` Constructor which takes a unique integer Id
`PublishMessage(NodeHandle source, Topic topic, RawScribeContent content)`
`PublishMessage(NodeHandle source, Topic topic, ScribeContent content)` Constructor which takes a unique integer Id
`PublishRequestMessage(NodeHandle source, Topic topic, RawScribeContent content)`
`PublishRequestMessage(NodeHandle source, Topic topic, ScribeContent content)` Constructor which takes a unique integer Id
`ScribeMessage(NodeHandle source, Topic topic)` Constructor which takes a unique integer Id
`SubscribeAckMessage(NodeHandle source, java.util.List<Topic> topics, java.util.List<java.util.List<Id>> pathsToRoot, int id)` Constructor which takes a unique integer Id
`SubscribeFailedMessage(NodeHandle source, java.util.List<Topic> topics, int id)` Constructor which takes a unique integer Id
`SubscribeLostMessage(NodeHandle source, java.util.Collection<Topic> topics, int id, ScribeMultiClient client)` Constructor which takes a unique integer Id
`SubscribeMessage(NodeHandle source, java.util.List<Topic> topics, int id, RawScribeContent content)` Constructor which takes a unique integer Id
`SubscribeMessage(NodeHandle source, Topic topic, int id, RawScribeContent content)`
`UnsubscribeMessage(NodeHandle source, java.util.List<Topic> topics)` Constructor which takes a unique integer Id

Uses of NodeHandle in rice.p2p.scribe.rawserialization

Methods in rice.p2p.scribe.rawserialization with parameters of type NodeHandle
`void` | `RawScribe.anycast(Topic topic, RawScribeContent content, NodeHandle hint)` Anycasts the given content to a member of the given topic The hint helps us to implement centralized algorithms where the hint is the cachedRoot for the topic.
`void` | `RawScribe.subscribe(java.util.Collection<Topic> topics, ScribeClient client, RawScribeContent content, NodeHandle hint)` Deprecated. use the version with the MultiClient
`void` | `RawScribe.subscribe(java.util.Collection<Topic> topics, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)`
`void` | `RawScribe.subscribe(Topic topic, ScribeClient client, RawScribeContent content, NodeHandle hint)` Deprecated. use the version with the MultiClient
`void` | `RawScribe.subscribe(Topic topic, ScribeMultiClient client, RawScribeContent content, NodeHandle hint)`

Uses of NodeHandle in rice.p2p.scribe.testing

Methods in rice.p2p.scribe.testing that return NodeHandle
`NodeHandle` | `ScribeRegrTest.TestRouteMessage.getNextHopHandle()` Gets the NextHopHandle attribute of the TestRouteMessage object

Methods in rice.p2p.scribe.testing with parameters of type NodeHandle
`boolean` | `ScribeRegrTest.TestScribePolicy.allowSubscribe(SubscribeMessage message, ScribeClient[] clients, NodeHandle[] children)`
`void` | `ScribeRegrTest.TestScribeClient.childAdded(Topic topic, NodeHandle child)` DESCRIBE THE METHOD
`void` | `ScribeRegrTest.TestScribeClient.childRemoved(Topic topic, NodeHandle child)` DESCRIBE THE METHOD
`void` | `ScribeRegrTest.TestRouteMessage.setNextHopHandle(NodeHandle nextHop)` Sets the NextHopHandle attribute of the TestRouteMessage object

Constructors in rice.p2p.scribe.testing with parameters of type NodeHandle
`ScribeRegrTest.TestRouteMessage(Id id, NodeHandle nextHop, Message message)` Constructor for TestRouteMessage.

Uses of NodeHandle in rice.p2p.splitstream

Methods in rice.p2p.splitstream that return NodeHandle
`NodeHandle` | `SplitStreamScribePolicy.freeBandwidth(Channel channel, NodeHandle newChild, Id stripeId)` This method attempts to free bandwidth from our primary stripe.
`NodeHandle[]` | `Stripe.getChildren()` Utility method.
`NodeHandle` | `Stripe.getParent()` Utility method.

Methods in rice.p2p.splitstream with parameters of type NodeHandle
`boolean` | `SplitStreamScribePolicy.allowSubscribe(SubscribeMessage message, ScribeClient[] clients, NodeHandle[] children)` This method implements the "locating parent" algorithm of SplitStream.
`void` | `SplitStreamScribePolicy.childAdded(Topic topic, NodeHandle child)` Informs this policy that a child was added to a topic - the topic is free to ignore this upcall if it doesn't care.
`void` | `Stripe.childAdded(Topic topic, NodeHandle child)` Informs this client that a child was added to a topic in which it was interested in.
`void` | `SplitStreamScribePolicy.childRemoved(Topic topic, NodeHandle child)` Informs this policy that a child was removed from a topic - the topic is free to ignore this upcall if it doesn't care.
`void` | `Stripe.childRemoved(Topic topic, NodeHandle child)` Informs this client that a child was removed from a topic in which it was interested in.
`void` | `SplitStreamScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> children)` This method adds the parent and child in such a way that the nodes who have this stripe as their primary strpe are examined first.
`NodeHandle` | `SplitStreamScribePolicy.freeBandwidth(Channel channel, NodeHandle newChild, Id stripeId)` This method attempts to free bandwidth from our primary stripe.
`void` | `SplitStreamScribePolicy.recvAnycastFail(Topic topic, NodeHandle failedAtNode, ScribeContent content)`

Method parameters in rice.p2p.splitstream with type arguments of type NodeHandle
`void` | `SplitStreamScribePolicy.directAnycast(AnycastMessage message, NodeHandle parent, java.util.Collection<NodeHandle> children)` This method adds the parent and child in such a way that the nodes who have this stripe as their primary strpe are examined first.

Uses of NodeHandle in rice.p2p.util

Methods in rice.p2p.util that return NodeHandle
`NodeHandle` | `MRHAdapter.getIdentifier()`

Method parameters in rice.p2p.util with type arguments of type NodeHandle
`void` | `MCAdapter.ack(MessageRequestHandle<NodeHandle,RawMessage> msg)`
`void` | `MCAdapter.sendFailed(MessageRequestHandle<NodeHandle,RawMessage> msg, java.io.IOException reason)`
`void` | `MRHAdapter.setInternal(MessageRequestHandle<NodeHandle,RawMessage> name)`

Constructor parameters in rice.p2p.util with type arguments of type NodeHandle
`MCAdapter(MessageCallback<NodeHandle,Message> deliverAckToMe, MRHAdapter handle)`

Uses of NodeHandle in rice.p2p.util.rawserialization

Methods in rice.p2p.util.rawserialization with parameters of type NodeHandle
`Message` | `JavaSerializedDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`

Uses of NodeHandle in rice.pastry

Subclasses of NodeHandle in rice.pastry
`class` | `NodeHandle<Identifier>` Interface for handles to remote nodes.

Methods in rice.pastry that return NodeHandle
`NodeHandle` | `NodeSet.getHandle(Id id)` Finds the NodeHandle associated with the NodeId.
`NodeHandle` | `NodeSet.getHandle(int i)` Gets the ith element in the set.
`NodeHandle` | `PastryNode.getLocalNodeHandle()`
`NodeHandle` | `NodeSet.removeHandle(Id id)` Removes a node id and its handle from the set.

Methods in rice.pastry with parameters of type NodeHandle
`boolean` | `NodeSet.putHandle(NodeHandle handle)` Puts a NodeHandle into the set.

Uses of NodeHandle in rice.pastry.client

Methods in rice.pastry.client with parameters of type NodeHandle
`void` | `PastryAppl.connect(NodeHandle handle, AppSocketReceiver receiver, int timeout)` Called to open an ApplicationLevelSocket

Uses of NodeHandle in rice.pastry.commonapi

Methods in rice.pastry.commonapi that return NodeHandle
`NodeHandle` | `PastryEndpoint.coalesce(NodeHandle newHandle)`
`NodeHandle` | `PastryEndpoint.getLocalNodeHandle()` Returns a handle to the local node below this endpoint.
`NodeHandle` | `PastryEndpoint.readNodeHandle(InputBuffer buf)`

Methods in rice.pastry.commonapi with parameters of type NodeHandle
`NodeHandle` | `PastryEndpoint.coalesce(NodeHandle newHandle)`
`int` | `PastryEndpoint.proximity(NodeHandle nh)`
`IdRange` | `PastryEndpoint.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` | `PastryEndpoint.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.
`NodeHandleSet` | `PastryEndpoint.replicaSet(Id id, int maxRank, NodeHandle root, NodeHandleSet set)` This methods returns an ordered set of nodehandles on which replicas of an object with a given id can be stored.
`MessageReceipt` | `PastryEndpoint.route(Id key, Message msg, NodeHandle hint)` This operation forwards a message towards the root of key.
`MessageReceipt` | `PastryEndpoint.route(Id key, Message msg, NodeHandle hint, DeliveryNotification deliverAckToMe)`
`MessageReceipt` | `PastryEndpoint.route(Id key, RawMessage msg, NodeHandle hint)` This duplication of the above code is to make a fast path for the RawMessage.
`MessageReceipt` | `PastryEndpoint.route(Id key, RawMessage msg, NodeHandle hint, DeliveryNotification deliverAckToMe)`

Uses of NodeHandle in rice.pastry.direct

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

Methods in rice.pastry.direct with parameters of type NodeHandle
`void` | `SimulatorListener.messageReceived(Message m, NodeHandle from, NodeHandle to)` Called for every message received over the network.
`void` | `SimulatorListener.messageSent(Message m, NodeHandle from, NodeHandle to, int delay)` Called for every message sent over the network.

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.leafset

Fields in rice.pastry.leafset declared as NodeHandle
`NodeHandle` | `LSRangeCannotBeDeterminedException.nh`

Methods in rice.pastry.leafset that return NodeHandle
`NodeHandle` | `SimilarSet.getHandle(int i)` Gets the ith element in the set.
`NodeHandle` | `SimilarSet.removeHandle(Id id)` Removes a node id and its handle from the set.

Methods in rice.pastry.leafset with parameters of type NodeHandle
`boolean` | `SimilarSet.putHandle(NodeHandle handle)` Puts a NodeHandle into the set.

Constructors in rice.pastry.leafset with parameters of type NodeHandle
`LSRangeCannotBeDeterminedException(java.lang.String string, int r, int pos, int uniqueNodes, NodeHandle nh, LeafSet ls)`

Uses of NodeHandle in rice.pastry.leafset.testing

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

Uses of NodeHandle in rice.pastry.messaging

Methods in rice.pastry.messaging with parameters of type NodeHandle
`Message` | `JavaSerializedDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`
`Message` | `PJavaSerializedDeserializer.deserialize(InputBuffer buf, short type, int priority, NodeHandle sender)`

Uses of NodeHandle in rice.pastry.routing

Methods in rice.pastry.routing that return NodeHandle
`NodeHandle` | `RouteSet.getHandle(Id id)` Finds the NodeHandle associated with the Id.
`NodeHandle` | `RouteSet.getHandle(int i)` Gets the ith element in the set.
`NodeHandle` | `RouteMessage.getNextHopHandle()`
`NodeHandle` | `RouteSet.removeHandle(Id id)` Removes a node id and its handle from the set.

Methods in rice.pastry.routing with parameters of type NodeHandle
`boolean` | `RouteSet.putHandle(NodeHandle handle)` Puts a NodeHandle into the set.
`void` | `RouteMessage.setNextHopHandle(NodeHandle nextHop)`

Uses of NodeHandle in rice.pastry.socket

Subclasses of NodeHandle in rice.pastry.socket
`class` | `SocketNodeHandle`

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

Methods in rice.pastry.socket.nat.rendezvous with parameters of type NodeHandle
`void` | `RendezvousApp.isNatted(NodeHandle bootstrap, Continuation<java.net.InetSocketAddress,java.lang.Exception> receiveResult)` Can be called before you boot, will tell you if you are Firewalled.

Uses of NodeHandle in rice.pastry.testing

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

Methods in rice.pastry.testing with parameters of type NodeHandle
`void` | `RoutingTableTest.MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.pastry.transport

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

Methods in rice.pastry.transport with parameters of type NodeHandle
`RawMessage` | `TLDeserializer.deserialize(InputBuffer buf, NodeHandle sender)`

Uses of NodeHandle in rice.tutorial.appsocket

Methods in rice.tutorial.appsocket with parameters of type NodeHandle
`void` | `MyApp.sendMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.direct

Methods in rice.tutorial.direct with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.forwarding

Methods in rice.tutorial.forwarding with parameters of type NodeHandle
`void` | `MyMsg.addHop(NodeHandle hop)`
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.gtitm

Methods in rice.tutorial.gtitm with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.lesson3

Methods in rice.tutorial.lesson3 with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.lesson4

Methods in rice.tutorial.lesson4 with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.rawserialization

Methods in rice.tutorial.rawserialization with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.rawserialization2

Methods in rice.tutorial.rawserialization2 with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Constructors in rice.tutorial.rawserialization2 with parameters of type NodeHandle
`MyMsg(NodeHandle from, Id to)` Constructor.

Uses of NodeHandle in rice.tutorial.scribe

Methods in rice.tutorial.scribe that return NodeHandle
`NodeHandle[]` | `MyScribeClient.getChildren()`
`NodeHandle` | `MyScribeClient.getParent()`
`static NodeHandle` | `ScribeTutorial.getRoot(NodeHandle seed, java.util.Hashtable appTable)` Recursively crawl up the tree to find the root.

Methods in rice.tutorial.scribe with parameters of type NodeHandle
`void` | `MyScribeClient.childAdded(Topic topic, NodeHandle child)`
`void` | `MyScribeClient.childRemoved(Topic topic, NodeHandle child)`
`static NodeHandle` | `ScribeTutorial.getRoot(NodeHandle seed, java.util.Hashtable appTable)` Recursively crawl up the tree to find the root.
`static void` | `ScribeTutorial.recursivelyPrintChildren(NodeHandle curNode, int recursionDepth, java.util.Hashtable appTable)` Print's self, then children.
`void` | `MyScribeClient.update(NodeHandle handle, boolean joined)`

Constructors in rice.tutorial.scribe with parameters of type NodeHandle
`MyScribeContent(NodeHandle from, int seq)` Simple constructor.

Uses of NodeHandle in rice.tutorial.splitstream

Methods in rice.tutorial.splitstream with parameters of type NodeHandle
`void` | `MySplitStreamClient.update(NodeHandle handle, boolean joined)`

Uses of NodeHandle in rice.tutorial.timer

Methods in rice.tutorial.timer with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.transportdirect

Methods in rice.tutorial.transportdirect with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

Uses of NodeHandle in rice.tutorial.transportlayer

Methods in rice.tutorial.transportlayer with parameters of type NodeHandle
`void` | `MyApp.routeMyMsgDirect(NodeHandle nh)` Called to directly send a message to the nh
`void` | `MyApp.update(NodeHandle handle, boolean joined)` Called when you hear about a new neighbor.

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

Copyright © 2001-2005 - Rice Pastry.