How to use

org.jgroups.util.Digest$Entry

constructor

public Entry next() {
  if(index >= capacity())
    throw new NoSuchElementException("index=" + index + ", capacity=" + capacity());
  Address mbr=members != null? members[index] : null;
  long hd=seqnos != null? seqnos[index*2] : 0, hr=seqnos != null? seqnos[index*2+1] : 0;
  Entry entry=new Entry(mbr, hd, hr);
  index++;
  return entry;
}

public void readFrom(DataInputStream in) throws IOException, IllegalAccessException, InstantiationException {
  short size=in.readShort();
  Map<Address,Entry> tmp=new HashMap<Address, Entry>(size);
  Address key;
  for(int i=0; i < size; i++) {
    key=Util.readAddress(in);
    tmp.put(key, new Entry(in.readLong(), in.readLong(), in.readLong()));
  }
  senders.clear();
  senders.putAll(tmp);
}

/**
 * Resets the seqnos for the sender at 'index' to 0. This happens when a member has left the group,
 * but it is still in the digest. Resetting its seqnos ensures that no-one will request a message
 * retransmission from the dead member.
 */
public void resetAt(Address sender) {
  Entry entry=senders.get(sender);
  if(entry != null)
    checkSealed();
    senders.put(sender, new Entry());
}

public Digest(Address sender, long low, long highest_delivered) {
  senders=createSenders(1);
  senders.put(sender, new Entry(low, highest_delivered));
}

public Entry next() {
  if(index >= capacity())
    throw new NoSuchElementException("index=" + index + ", capacity=" + capacity());
  Address mbr=members != null? members[index] : null;
  long hd=seqnos != null? seqnos[index*2] : 0, hr=seqnos != null? seqnos[index*2+1] : 0;
  Entry entry=new Entry(mbr, hd, hr);
  index++;
  return entry;
}

public void add(Address sender, long low_seqno, long highest_delivered_seqno, long highest_received_seqno) {
  checkSealed();
  add(sender, new Digest.Entry(low_seqno, highest_delivered_seqno, highest_received_seqno));
}

public boolean set(Address sender, long low_seqno, long highest_delivered_seqno, long highest_received_seqno) {
  checkSealed();
  Entry entry=senders.put(sender, new Entry(low_seqno, highest_delivered_seqno, highest_received_seqno));
  return entry == null;
}

public void setHighestDeliveredAndSeenSeqnos(Address sender, long low_seqno, long highest_delivered_seqno, long highest_received_seqno) {
  Entry entry=senders.get(sender);
  if(entry != null) {
    checkSealed();
    Entry new_entry=new Entry(low_seqno, highest_delivered_seqno, highest_received_seqno);
    senders.put(sender, new_entry);
  }
}

public Digest(Address sender, long low, long highest_delivered, long highest_received) {
  senders=createSenders(1);
  senders.put(sender, new Entry(low, highest_delivered, highest_received));
}

/**
 * Similar to add(), but if the sender already exists, its seqnos will be modified (no new entry) as follows:
 * <ol>
 * <li>this.low_seqno=min(this.low_seqno, low_seqno)
 * <li>this.highest_delivered_seqno=max(this.highest_delivered_seqno, highest_delivered_seqno)
 * <li>this.highest_received_seqno=max(this.highest_received_seqno, highest_received_seqno)
 * </ol>
 * If the sender doesn not exist, a new entry will be added (provided there is enough space)
 */
public void merge(Address sender, long low_seqno, long highest_delivered_seqno, long highest_received_seqno) {
  if(sender == null) {
    if(log.isErrorEnabled()) log.error("sender == null");
    return;
  }
  checkSealed();
  Entry entry=senders.get(sender);
  if(entry == null) {
    add(sender, low_seqno, highest_delivered_seqno, highest_received_seqno);
  }
  else {
    Entry new_entry=new Entry(Math.min(entry.getLow(), low_seqno),
                 Math.max(entry.getHighestDeliveredSeqno(), highest_delivered_seqno),
                 Math.max(entry.getHighestReceivedSeqno(), highest_received_seqno));
    senders.put(sender, new_entry);
  }
}

Entry r=new Entry(0, high);
resultMap.put(address, r);                
thisMinusInteresection.removeAll(intersection);
for(Address address : thisMinusInteresection) {
  resultMap.put(address, new Entry(this.get(address)));
otherMinusInteresection.removeAll(intersection);
for(Address address : otherMinusInteresection) {
  resultMap.put(address, new Entry(other.get(address)));

  long low=Math.min(e1.highest_delivered_seqno, e2.highest_delivered_seqno);
  long high=max(e1.highest_delivered_seqno, e2.highest_delivered_seqno);
  Entry r=new Entry(low, high);
  resultMap.put(address, r);
thisMinusInteresection.removeAll(intersection);
for(Address address : thisMinusInteresection) {
  resultMap.put(address, new Entry(this.get(address)));
otherMinusInteresection.removeAll(intersection);
for(Address address : otherMinusInteresection) {
  resultMap.put(address, new Entry(other.get(address)));

    highest_delivered=win.getHighestDelivered(),
    highest_received=win.getHighestReceived();
return new Digest.Entry(low, highest_delivered, highest_received);

/**
 * Increments the sender's high_seqno by 1.
 */
public void incrementHighestDeliveredSeqno(Address sender) {
  Entry entry=senders.get(sender);
  if(entry == null)
    return;
  checkSealed();
  Entry new_entry=new Entry(entry.getLow(), entry.getHighestDeliveredSeqno() +1, entry.getHighestReceivedSeqno());
  senders.put(sender, new_entry);
}