How to use

org.apache.cassandra.db.RangeTombstoneList

constructor

public RangeTombstoneList copy()
{
  return new RangeTombstoneList(comparator,
                 Arrays.copyOf(starts, size),
                 Arrays.copyOf(ends, size),
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
}

public RangeTombstoneList copy()
{
  return new RangeTombstoneList(comparator,
                 Arrays.copyOf(starts, size),
                 Arrays.copyOf(ends, size),
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
}

public RangeTombstoneList copy()
{
  return new RangeTombstoneList(comparator,
                 Arrays.copyOf(starts, size),
                 Arrays.copyOf(ends, size),
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
}

public RangeTombstoneList copy()
{
  return new RangeTombstoneList(comparator,
                 Arrays.copyOf(starts, size),
                 Arrays.copyOf(ends, size),
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
}

public RangeTombstoneList copy()
{
  return new RangeTombstoneList(comparator,
                 Arrays.copyOf(starts, size),
                 Arrays.copyOf(ends, size),
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
}

public void add(RangeTombstone tombstone, ClusteringComparator comparator)
{
  if (ranges == null)
    ranges = new RangeTombstoneList(comparator, 1);
  ranges.add(tombstone);
}

public void add(RangeTombstone tombstone, ClusteringComparator comparator)
{
  if (ranges == null)
    ranges = new RangeTombstoneList(comparator, 1);
  ranges.add(tombstone);
}

public void add(RangeTombstone tombstone, ClusteringComparator comparator)
{
  if (ranges == null)
    ranges = new RangeTombstoneList(comparator, 1);
  ranges.add(tombstone);
}

public void add(RangeTombstone tombstone, ClusteringComparator comparator)
{
  if (ranges == null)
    ranges = new RangeTombstoneList(comparator, 1);
  ranges.add(tombstone);
}

public DeletionInfo(Composite start, Composite end, Comparator<Composite> comparator, long markedForDeleteAt, int localDeletionTime)
{
  this(DeletionTime.LIVE, new RangeTombstoneList(comparator, 1));
  ranges.add(start, end, markedForDeleteAt, localDeletionTime);
}

public void add(RangeTombstone tombstone, Comparator<Composite> comparator)
{
  if (ranges == null)
    ranges = new RangeTombstoneList(comparator, 1);
  ranges.add(tombstone);
}

public RangeTombstoneList copy(AbstractAllocator allocator)
{
  RangeTombstoneList copy =  new RangeTombstoneList(comparator,
                           new ClusteringBound[size],
                           new ClusteringBound[size],
                           Arrays.copyOf(markedAts, size),
                           Arrays.copyOf(delTimes, size),
                           boundaryHeapSize, size);
  for (int i = 0; i < size; i++)
  {
    copy.starts[i] = clone(starts[i], allocator);
    copy.ends[i] = clone(ends[i], allocator);
  }
  return copy;
}

public RangeTombstoneList copy(AbstractAllocator allocator)
{
  RangeTombstoneList copy =  new RangeTombstoneList(comparator,
                           new ClusteringBound[size],
                           new ClusteringBound[size],
                           Arrays.copyOf(markedAts, size),
                           Arrays.copyOf(delTimes, size),
                           boundaryHeapSize, size);
  for (int i = 0; i < size; i++)
  {
    copy.starts[i] = clone(starts[i], allocator);
    copy.ends[i] = clone(ends[i], allocator);
  }
  return copy;
}

public RangeTombstoneList copy(AbstractAllocator allocator)
{
  RangeTombstoneList copy =  new RangeTombstoneList(comparator,
                           new ClusteringBound[size],
                           new ClusteringBound[size],
                           Arrays.copyOf(markedAts, size),
                           Arrays.copyOf(delTimes, size),
                           boundaryHeapSize, size);
  for (int i = 0; i < size; i++)
  {
    copy.starts[i] = clone(starts[i], allocator);
    copy.ends[i] = clone(ends[i], allocator);
  }
  return copy;
}

public RangeTombstoneList copy(AbstractAllocator allocator)
{
  RangeTombstoneList copy =  new RangeTombstoneList(comparator,
                           new ClusteringBound[size],
                           new ClusteringBound[size],
                           Arrays.copyOf(markedAts, size),
                           Arrays.copyOf(delTimes, size),
                           boundaryHeapSize, size);
  for (int i = 0; i < size; i++)
  {
    copy.starts[i] = clone(starts[i], allocator);
    copy.ends[i] = clone(ends[i], allocator);
  }
  return copy;
}

public RangeTombstoneList copy(AbstractAllocator allocator)
{
  RangeTombstoneList copy =  new RangeTombstoneList(comparator,
                 new Composite[size],
                 new Composite[size],
                 Arrays.copyOf(markedAts, size),
                 Arrays.copyOf(delTimes, size),
                 boundaryHeapSize, size);
  for (int i = 0; i < size; i++)
  {
    assert !(starts[i] instanceof AbstractNativeCell || ends[i] instanceof AbstractNativeCell); //this should never happen
    copy.starts[i] = starts[i].copy(null, allocator);
    copy.ends[i] = ends[i].copy(null, allocator);
  }
  return copy;
}

    diff = new RangeTombstoneList(comparator, superset.size - i);
  diff = new RangeTombstoneList(comparator, Math.min(8, superset.size - i));
diff.add(superset.starts[i], superset.ends[i], superset.markedAts[i], superset.delTimes[i]);

public RangeTombstoneList deserialize(DataInput in, int version) throws IOException
{
  int size = in.readInt();
  if (size == 0)
    return null;
  RangeTombstoneList tombstones = new RangeTombstoneList(type, size);
  for (int i = 0; i < size; i++)
  {
    Composite start = type.serializer().deserialize(in);
    Composite end = type.serializer().deserialize(in);
    int delTime =  in.readInt();
    long markedAt = in.readLong();
    if (version >= MessagingService.VERSION_20)
    {
      tombstones.setInternal(i, start, end, markedAt, delTime);
    }
    else
    {
      /*
       * The old implementation used to have range sorted by left value, but with potentially
       * overlapping range. So we need to use the "slow" path.
       */
      tombstones.add(start, end, markedAt, delTime);
    }
  }
  // The "slow" path take care of updating the size, but not the fast one
  if (version >= MessagingService.VERSION_20)
    tombstones.size = size;
  return tombstones;
}