org.jgroups.util

## Class Digest

- java.lang.Object
- - org.jgroups.util.Digest

- All Implemented Interfaces:
    java.io.Externalizable, java.io.Serializable, Streamable
  Direct Known Subclasses:
    MutableDigest

      public class Digest
      extends java.lang.Object
      implements java.io.Externalizable, Streamable

  A message digest, which is used by the PBCAST layer for gossiping (also used by NAKACK for keeping track of current seqnos for all members). It contains pairs of senders and a range of seqnos (low and high), where each sender is associated with its highest and lowest seqnos seen so far. That is, the lowest seqno which was not yet garbage-collected and the highest that was seen so far and is deliverable (or was already delivered) to the application. A range of [0 - 0] means no messages have been received yet.

  April 3 2001 (bela): Added high_seqnos_seen member. It is used to disseminate information about the last (highest) message M received from a sender P. Since we might be using a negative acknowledgment message numbering scheme, we would never know if the last message was lost. Therefore we periodically gossip and include the last message seqno. Members who haven't seen it (e.g. because msg was dropped) will request a retransmission. See DESIGN for details.

  Author:
    Bela Ban
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Digest.Entry` Class keeping track of the lowest and highest sequence numbers delivered, and the highest sequence numbers received, per member.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Digest` | `EMPTY_DIGEST`
    `protected static Log` | `log`
    `protected java.util.Map<Address,Digest.Entry>` | `senders` Map<Address, Entry>

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Digest()` Used for externalization
    `Digest(Address sender, long low, long highest_delivered)`
    `Digest(Address sender, long low, long highest_delivered, long highest_received)`
    `Digest(Digest d)`
    `Digest(int size)`
    `Digest(java.util.Map<Address,Digest.Entry> map)` Creates a new digest from an existing map by copying the keys and values from map

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `contains(Address sender)`
    `Digest` | `copy()`
    `Digest` | `difference(Digest other)`
    `boolean` | `equals(java.lang.Object obj)`
    `Digest.Entry` | `get(Address sender)` Returns the Entry for the given sender.
    `java.util.Map<Address,Digest.Entry>` | `getSenders()` Returns an unmodifiable map, so modifications will result in exceptions
    `long` | `highestDeliveredSeqnoAt(Address sender)`
    `long` | `highestReceivedSeqnoAt(Address sender)`
    `Digest` | `highestSequence(Digest other)`
    `boolean` | `isGreaterThanOrEqual(Digest other)` Returns true if all senders of the current digest have their seqnos >= the ones from other
    `long` | `lowSeqnoAt(Address sender)`
    `java.lang.String` | `printHighestDeliveredSeqnos()`
    `java.lang.String` | `printHighestReceivedSeqnos()`
    `void` | `readExternal(java.io.ObjectInput in)`
    `void` | `readFrom(java.io.DataInputStream in)` Read the state of the current object (including superclasses) from instream Note that the input stream must not be closed
    `boolean` | `sameSenders(Digest other)` Compares two digests and returns true if the senders are the same, otherwise false.
    `long` | `serializedSize()`
    `int` | `size()`
    `java.lang.String` | `toString()`
    `java.lang.String` | `toStringSorted()`
    `void` | `writeExternal(java.io.ObjectOutput out)`
    `void` | `writeTo(java.io.DataOutputStream out)` Write the entire state of the current object (including superclasses) to outstream.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### EMPTY_DIGEST

          public static final Digest EMPTY_DIGEST

    - #### senders

          protected final java.util.Map<Address,Digest.Entry> senders

      Map<Address, Entry>

    - #### log

          protected static final Log log

  - ### Constructor Detail

    - #### Digest

          public Digest()

      Used for externalization

    - #### Digest

          public Digest(int size)

    - #### Digest

          public Digest(java.util.Map<Address,Digest.Entry> map)

      Creates a new digest from an existing map by copying the keys and values from map

    - #### Digest

          public Digest(Digest d)

    - #### Digest

          public Digest(Address sender,
                long low,
                long highest_delivered,
                long highest_received)

    - #### Digest

          public Digest(Address sender,
                long low,
                long highest_delivered)

  - ### Method Detail

    - #### getSenders

          public java.util.Map<Address,Digest.Entry> getSenders()

      Returns an unmodifiable map, so modifications will result in exceptions

    - #### equals

          public boolean equals(java.lang.Object obj)

      Overrides:
        `equals` in class `java.lang.Object`

    - #### contains

          public boolean contains(Address sender)

    - #### get

          public Digest.Entry get(Address sender)

      Returns the Entry for the given sender. Note that Entry is immutable

    - #### sameSenders

          public boolean sameSenders(Digest other)

      Compares two digests and returns true if the senders are the same, otherwise false.
      Parameters:
        `other` -
      Returns:
        True if senders are the same, otherwise false.

    - #### difference

          public Digest difference(Digest other)

    - #### highestSequence

          public Digest highestSequence(Digest other)

    - #### size

          public int size()

    - #### lowSeqnoAt

          public long lowSeqnoAt(Address sender)

    - #### highestDeliveredSeqnoAt

          public long highestDeliveredSeqnoAt(Address sender)

    - #### highestReceivedSeqnoAt

          public long highestReceivedSeqnoAt(Address sender)

    - #### isGreaterThanOrEqual

          public boolean isGreaterThanOrEqual(Digest other)

      Returns true if all senders of the current digest have their seqnos >= the ones from other
      Parameters:
        `other` -
      Returns:

    - #### copy

          public Digest copy()

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.Object`

    - #### toStringSorted

          public java.lang.String toStringSorted()

    - #### printHighestDeliveredSeqnos

          public java.lang.String printHighestDeliveredSeqnos()

    - #### printHighestReceivedSeqnos

          public java.lang.String printHighestReceivedSeqnos()

    - #### writeExternal

          public void writeExternal(java.io.ObjectOutput out)
                             throws java.io.IOException

      Specified by:
        `writeExternal` in interface `java.io.Externalizable`
      Throws:
        `java.io.IOException`

    - #### readExternal

          public void readExternal(java.io.ObjectInput in)
                            throws java.io.IOException,
                                   java.lang.ClassNotFoundException

      Specified by:
        `readExternal` in interface `java.io.Externalizable`
      Throws:
        `java.io.IOException`
        `java.lang.ClassNotFoundException`

    - #### writeTo

          public void writeTo(java.io.DataOutputStream out)
                       throws java.io.IOException

      Description copied from interface: `Streamable`
      Write the entire state of the current object (including superclasses) to outstream. Note that the output stream must not be closed
      Specified by:
        `writeTo` in interface `Streamable`
      Throws:
        `java.io.IOException`

    - #### readFrom

          public void readFrom(java.io.DataInputStream in)
                        throws java.io.IOException,
                               java.lang.IllegalAccessException,
                               java.lang.InstantiationException

      Description copied from interface: `Streamable`
      Read the state of the current object (including superclasses) from instream Note that the input stream must not be closed
      Specified by:
        `readFrom` in interface `Streamable`
      Throws:
        `java.io.IOException`
        `java.lang.IllegalAccessException`
        `java.lang.InstantiationException`

    - #### serializedSize

          public long serializedSize()

Copyright © 1998-2009 Bela Ban / Red Hat. All Rights Reserved.