How to use

DeletionTime$Serializer

in

org.apache.cassandra.db

public RangeTombstone deserializeBody(DataInput in, Composite min, Descriptor.Version version) throws IOException
{
  Composite max = type.serializer().deserialize(in);
  DeletionTime dt = DeletionTime.serializer.deserialize(in);
  // If the max equals the min.end(), we can avoid keeping an extra ByteBuffer in memory by using
  // min.end() instead of max
  Composite minEnd = min.end();
  max = minEnd.equals(max) ? minEnd : max;
  return new RangeTombstone(min, max, dt);
}

@Override
public void serialize(DataOutputPlus out, IndexInfo.Serializer idxInfoSerializer, ByteBuffer indexInfo) throws IOException
{
  out.writeUnsignedVInt(position);
  out.writeUnsignedVInt(fieldsSerializedSize + indexInfo.limit());
  out.writeUnsignedVInt(headerLength);
  DeletionTime.serializer.serialize(deletionTime, out);
  out.writeUnsignedVInt(columnsIndexCount);
  out.write(indexInfo);
}

@Override
public IndexInfoRetriever openWithIndex(FileHandle indexFile)
{
  int fieldsSize = (int) DeletionTime.serializer.serializedSize(deletionTime)
           + TypeSizes.sizeof(0); // columnIndexCount
  indexEntrySizeHistogram.update(serializedSize);
  indexInfoCountHistogram.update(offsets.length);
  return new LegacyIndexInfoRetriever(indexFilePosition +
                    TypeSizes.sizeof(0L) + // position
                    TypeSizes.sizeof(0) + // indexInfoSize
                    fieldsSize,
                    offsets, indexFile.createReader(), idxInfoSerializer);
}

  static void skipForCache(DataInputPlus in) throws IOException
  {
    /*long headerLength =*/in.readUnsignedVInt();
    /*DeletionTime deletionTime = */DeletionTime.serializer.skip(in);
    /*int columnsIndexCount = (int)*/in.readUnsignedVInt();
    /*int indexedPartSize = (int)*/in.readUnsignedVInt();
  }
}

@Override
public void serializeForCache(DataOutputPlus out) throws IOException
{
  out.writeUnsignedVInt(position);
  out.writeByte(CACHE_INDEXED_SHALLOW);
  out.writeUnsignedVInt(indexFilePosition);
  out.writeUnsignedVInt(headerLength);
  DeletionTime.serializer.serialize(deletionTime, out);
  out.writeUnsignedVInt(columnsIndexCount);
  out.writeUnsignedVInt(indexedPartSize);
}

public void serialize(IndexInfo info, DataOutputPlus out) throws IOException
{
  assert version.storeRows() : "We read old index files but we should never write them";
  clusteringSerializer.serialize(info.firstName, out);
  clusteringSerializer.serialize(info.lastName, out);
  out.writeUnsignedVInt(info.offset);
  out.writeVInt(info.width - WIDTH_BASE);
  out.writeBoolean(info.endOpenMarker != null);
  if (info.endOpenMarker != null)
    DeletionTime.serializer.serialize(info.endOpenMarker, out);
}

@Override
public void serialize(DataOutputPlus out, IndexInfo.Serializer idxInfoSerializer, ByteBuffer indexInfo) throws IOException
{
  out.writeUnsignedVInt(position);
  out.writeUnsignedVInt(fieldsSerializedSize + indexInfo.limit());
  out.writeUnsignedVInt(headerLength);
  DeletionTime.serializer.serialize(deletionTime, out);
  out.writeUnsignedVInt(columnsIndexCount);
  out.write(indexInfo);
}

private void maybeWriteRowHeader() throws IOException
{
  if (lastColumn == null)
  {
    ByteBufferUtil.writeWithShortLength(key, output);
    DeletionTime.serializer.serialize(deletionInfo.getTopLevelDeletion(), output);
  }
}

public void serialize(RowIndexEntry rie, DataOutputPlus out) throws IOException
{
  out.writeLong(rie.position);
  out.writeInt(rie.promotedSize(type));
  if (rie.isIndexed())
  {
    DeletionTime.serializer.serialize(rie.deletionTime(), out);
    out.writeInt(rie.columnsIndex().size());
    ISerializer<IndexHelper.IndexInfo> idxSerializer = type.indexSerializer();
    for (IndexHelper.IndexInfo info : rie.columnsIndex())
      idxSerializer.serialize(info, out);
  }
}

@Override
public IndexInfoRetriever openWithIndex(FileHandle indexFile)
{
  int fieldsSize = (int) DeletionTime.serializer.serializedSize(deletionTime)
           + TypeSizes.sizeof(0); // columnIndexCount
  indexEntrySizeHistogram.update(serializedSize);
  indexInfoCountHistogram.update(offsets.length);
  return new LegacyIndexInfoRetriever(indexFilePosition +
                    TypeSizes.sizeof(0L) + // position
                    TypeSizes.sizeof(0) + // indexInfoSize
                    fieldsSize,
                    offsets, indexFile.createReader(), idxInfoSerializer);
}

@Override
public void serialize(DataOutputPlus out, IndexInfo.Serializer idxInfoSerializer, ByteBuffer indexInfo) throws IOException
{
  assert indexedPartSize != Integer.MIN_VALUE;
  out.writeUnsignedVInt(position);
  out.writeUnsignedVInt(serializedSize(deletionTime, headerLength, columnsIndex.length) + indexedPartSize);
  out.writeUnsignedVInt(headerLength);
  DeletionTime.serializer.serialize(deletionTime, out);
  out.writeUnsignedVInt(columnsIndex.length);
  for (IndexInfo info : columnsIndex)
    idxInfoSerializer.serialize(info, out);
  for (int offset : offsets)
    out.writeInt(offset);
}

@Override
public IndexInfoRetriever openWithIndex(FileHandle indexFile)
{
  int fieldsSize = (int) DeletionTime.serializer.serializedSize(deletionTime)
           + TypeSizes.sizeof(0); // columnIndexCount
  indexEntrySizeHistogram.update(serializedSize);
  indexInfoCountHistogram.update(offsets.length);
  return new LegacyIndexInfoRetriever(indexFilePosition +
                    TypeSizes.sizeof(0L) + // position
                    TypeSizes.sizeof(0) + // indexInfoSize
                    fieldsSize,
                    offsets, indexFile.createReader(), idxInfoSerializer);
}

private void writePartitionHeader(UnfilteredRowIterator iterator) throws IOException
{
  ByteBufferUtil.writeWithShortLength(iterator.partitionKey().getKey(), writer);
  DeletionTime.serializer.serialize(iterator.partitionLevelDeletion(), writer);
  if (header.hasStatic())
  {
    Row staticRow = iterator.staticRow();
    UnfilteredSerializer.serializer.serializeStaticRow(staticRow, header, writer, version);
    if (!observers.isEmpty())
      observers.forEach((o) -> o.nextUnfilteredCluster(staticRow));
  }
}

  public long serializedSize(IndexInfo info)
  {
    assert version.storeRows() : "We read old index files but we should never write them";
    long size = clusteringSerializer.serializedSize(info.firstName)
          + clusteringSerializer.serializedSize(info.lastName)
          + TypeSizes.sizeofUnsignedVInt(info.offset)
          + TypeSizes.sizeofVInt(info.width - WIDTH_BASE)
          + TypeSizes.sizeof(info.endOpenMarker != null);
    if (info.endOpenMarker != null)
      size += DeletionTime.serializer.serializedSize(info.endOpenMarker);
    return size;
  }
}

private static int serializedSize(DeletionTime deletionTime, long headerLength, int columnIndexCount)
{
  return TypeSizes.sizeofUnsignedVInt(headerLength)
      + (int) DeletionTime.serializer.serializedSize(deletionTime)
      + TypeSizes.sizeofUnsignedVInt(columnIndexCount);
}

@Override
public IndexInfoRetriever openWithIndex(FileHandle indexFile)
{
  int fieldsSize = (int) DeletionTime.serializer.serializedSize(deletionTime)
           + TypeSizes.sizeof(0); // columnIndexCount
  indexEntrySizeHistogram.update(serializedSize);
  indexInfoCountHistogram.update(offsets.length);
  return new LegacyIndexInfoRetriever(indexFilePosition +
                    TypeSizes.sizeof(0L) + // position
                    TypeSizes.sizeof(0) + // indexInfoSize
                    fieldsSize,
                    offsets, indexFile.createReader(), idxInfoSerializer);
}

@Override
public int promotedSize(CType type)
{
  TypeSizes typeSizes = TypeSizes.NATIVE;
  long size = DeletionTime.serializer.serializedSize(deletionTime, typeSizes);
  size += typeSizes.sizeof(columnsIndex.size()); // number of entries
  ISerializer<IndexHelper.IndexInfo> idxSerializer = type.indexSerializer();
  for (IndexHelper.IndexInfo info : columnsIndex)
    size += idxSerializer.serializedSize(info, typeSizes);
  return Ints.checkedCast(size);
}

@Override
public void serialize(DataOutputPlus out, IndexInfo.Serializer idxInfoSerializer, ByteBuffer indexInfo) throws IOException
{
  assert indexedPartSize != Integer.MIN_VALUE;
  out.writeUnsignedVInt(position);
  out.writeUnsignedVInt(serializedSize(deletionTime, headerLength, columnsIndex.length) + indexedPartSize);
  out.writeUnsignedVInt(headerLength);
  DeletionTime.serializer.serialize(deletionTime, out);
  out.writeUnsignedVInt(columnsIndex.length);
  for (IndexInfo info : columnsIndex)
    idxInfoSerializer.serialize(info, out);
  for (int offset : offsets)
    out.writeInt(offset);
}

  static void skipForCache(DataInputPlus in) throws IOException
  {
    /*long indexFilePosition =*/in.readUnsignedVInt();
    /*long headerLength =*/in.readUnsignedVInt();
    /*DeletionTime deletionTime = */DeletionTime.serializer.skip(in);
    /*int columnsIndexCount = (int)*/in.readUnsignedVInt();
    /*int indexedPartSize = (int)*/in.readUnsignedVInt();
  }
}

  public long serializedSize(IndexInfo info)
  {
    assert version.storeRows() : "We read old index files but we should never write them";
    long size = clusteringSerializer.serializedSize(info.firstName)
          + clusteringSerializer.serializedSize(info.lastName)
          + TypeSizes.sizeofUnsignedVInt(info.offset)
          + TypeSizes.sizeofVInt(info.width - WIDTH_BASE)
          + TypeSizes.sizeof(info.endOpenMarker != null);
    if (info.endOpenMarker != null)
      size += DeletionTime.serializer.serializedSize(info.endOpenMarker);
    return size;
  }
}