Java DataOutputPlus.writeUnsignedVInt方法代码示例

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
void serializeValuesWithoutSize(ClusteringPrefix clustering, DataOutputPlus out, int version, List<AbstractType<?>> types) throws IOException
{
    int offset = 0;
    int clusteringSize = clustering.size();
    // serialize in batches of 32, to avoid garbage when deserializing headers
    while (offset < clusteringSize)
    {
        // we micro-batch the headers, so that we can incur fewer method calls,
        // and generate no garbage on deserialization;
        // we piggyback on vint encoding so that, typically, only 1 byte is used per 32 clustering values,
        // i.e. more than we ever expect to see
        int limit = Math.min(clusteringSize, offset + 32);
        out.writeUnsignedVInt(makeHeader(clustering, offset, limit));
        while (offset < limit)
        {
            ByteBuffer v = clustering.get(offset);
            if (v != null && v.hasRemaining())
                types.get(offset).writeValue(v, out);
            offset++;
        }
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(ColumnFilter selection, DataOutputPlus out, int version) throws IOException
{
    out.writeByte(makeHeaderByte(selection));

    if (selection.queried != null)
    {
        Columns.serializer.serialize(selection.queried.statics, out);
        Columns.serializer.serialize(selection.queried.regulars, out);
    }

    if (selection.subSelections != null)
    {
        out.writeUnsignedVInt(selection.subSelections.size());
        for (ColumnSubselection subSel : selection.subSelections.values())
            ColumnSubselection.serializer.serialize(subSel, out, version);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
private void serialize(RangeTombstoneMarker marker, SerializationHeader header, DataOutputPlus out, long previousUnfilteredSize, int version)
throws IOException
{
    out.writeByte((byte)IS_MARKER);
    ClusteringBoundOrBoundary.serializer.serialize(marker.clustering(), out, version, header.clusteringTypes());

    if (header.isForSSTable())
    {
        out.writeUnsignedVInt(serializedMarkerBodySize(marker, header, previousUnfilteredSize, version));
        out.writeUnsignedVInt(previousUnfilteredSize);
    }

    if (marker.isBoundary())
    {
        RangeTombstoneBoundaryMarker bm = (RangeTombstoneBoundaryMarker)marker;
        header.writeDeletionTime(bm.endDeletionTime(), out);
        header.writeDeletionTime(bm.startDeletionTime(), out);
    }
    else
    {
        header.writeDeletionTime(((RangeTombstoneBoundMarker)marker).deletionTime(), out);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(ColumnFilter selection, DataOutputPlus out, int version) throws IOException
{
    out.writeByte(makeHeaderByte(selection));

    if (selection.selection != null)
    {
        Columns.serializer.serialize(selection.selection.statics, out);
        Columns.serializer.serialize(selection.selection.regulars, out);
    }

    if (selection.subSelections != null)
    {
        out.writeUnsignedVInt(selection.subSelections.size());
        for (ColumnSubselection subSel : selection.subSelections.values())
            ColumnSubselection.serializer.serialize(subSel, out, version);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(DataLimits limits, DataOutputPlus out, int version) throws IOException
{
    out.writeByte(limits.kind().ordinal());
    switch (limits.kind())
    {
        case CQL_LIMIT:
        case CQL_PAGING_LIMIT:
            CQLLimits cqlLimits = (CQLLimits)limits;
            out.writeUnsignedVInt(cqlLimits.rowLimit);
            out.writeUnsignedVInt(cqlLimits.perPartitionLimit);
            out.writeBoolean(cqlLimits.isDistinct);
            if (limits.kind() == Kind.CQL_PAGING_LIMIT)
            {
                CQLPagingLimits pagingLimits = (CQLPagingLimits)cqlLimits;
                ByteBufferUtil.writeWithVIntLength(pagingLimits.lastReturnedKey, out);
                out.writeUnsignedVInt(pagingLimits.lastReturnedKeyRemaining);
            }
            break;
        case THRIFT_LIMIT:
        case SUPER_COLUMN_COUNTING_LIMIT:
            ThriftLimits thriftLimits = (ThriftLimits)limits;
            out.writeUnsignedVInt(thriftLimits.partitionLimit);
            out.writeUnsignedVInt(thriftLimits.cellPerPartitionLimit);
            break;
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
private void serialize(RangeTombstoneMarker marker, SerializationHeader header, DataOutputPlus out, long previousUnfilteredSize, int version)
throws IOException
{
    out.writeByte((byte)IS_MARKER);
    RangeTombstone.Bound.serializer.serialize(marker.clustering(), out, version, header.clusteringTypes());

    if (header.isForSSTable())
    {
        out.writeUnsignedVInt(serializedMarkerBodySize(marker, header, previousUnfilteredSize, version));
        out.writeUnsignedVInt(previousUnfilteredSize);
    }

    if (marker.isBoundary())
    {
        RangeTombstoneBoundaryMarker bm = (RangeTombstoneBoundaryMarker)marker;
        header.writeDeletionTime(bm.endDeletionTime(), out);
        header.writeDeletionTime(bm.startDeletionTime(), out);
    }
    else
    {
        header.writeDeletionTime(((RangeTombstoneBoundMarker)marker).deletionTime(), out);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(Slices slices, DataOutputPlus out, int version) throws IOException
{
    int size = slices.size();
    out.writeUnsignedVInt(size);

    if (size == 0)
        return;

    List<AbstractType<?>> types = slices == ALL
                                ? Collections.<AbstractType<?>>emptyList()
                                : ((ArrayBackedSlices)slices).comparator.subtypes();

    for (Slice slice : slices)
        Slice.serializer.serialize(slice, out, version, types);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
@Override
public void serializeForCache(DataOutputPlus out) throws IOException
{
    out.writeUnsignedVInt(position);
    out.writeByte(CACHE_INDEXED);

    out.writeUnsignedVInt(headerLength);
    DeletionTime.serializer.serialize(deletionTime, out);
    out.writeUnsignedVInt(columnsIndexCount());

    for (IndexInfo indexInfo : columnsIndex)
        idxInfoSerializer.serialize(indexInfo, out);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
@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);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(Version version, Component header, DataOutputPlus out) throws IOException
{
    EncodingStats.serializer.serialize(header.stats, out);

    writeType(header.keyType, out);
    out.writeUnsignedVInt(header.clusteringTypes.size());
    for (AbstractType<?> type : header.clusteringTypes)
        writeType(type, out);

    writeColumnsWithTypes(header.staticColumns, out);
    writeColumnsWithTypes(header.regularColumns, out);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
private void writeColumnsWithTypes(Map<ByteBuffer, AbstractType<?>> columns, DataOutputPlus out) throws IOException
{
    out.writeUnsignedVInt(columns.size());
    for (Map.Entry<ByteBuffer, AbstractType<?>> entry : columns.entrySet())
    {
        ByteBufferUtil.writeWithVIntLength(entry.getKey(), out);
        writeType(entry.getValue(), out);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
/**
 * If both ends have a pre-shared superset of the columns we are serializing, we can send them much
 * more efficiently. Both ends must provide the identically same set of columns.
 */
public void serializeSubset(Collection<ColumnDefinition> columns, Columns superset, DataOutputPlus out) throws IOException
{
    /**
     * We weight this towards small sets, and sets where the majority of items are present, since
     * we expect this to mostly be used for serializing result sets.
     *
     * For supersets with fewer than 64 columns, we encode a bitmap of *missing* columns,
     * which equates to a zero (single byte) when all columns are present, and otherwise
     * a positive integer that can typically be vint encoded efficiently.
     *
     * If we have 64 or more columns, we cannot neatly perform a bitmap encoding, so we just switch
     * to a vint encoded set of deltas, either adding or subtracting (whichever is most efficient).
     * We indicate this switch by sending our bitmap with every bit set, i.e. -1L
     */
    int columnCount = columns.size();
    int supersetCount = superset.size();
    if (columnCount == supersetCount)
    {
        out.writeUnsignedVInt(0);
    }
    else if (supersetCount < 64)
    {
        out.writeUnsignedVInt(encodeBitmap(columns, superset, supersetCount));
    }
    else
    {
        serializeLargeSubset(columns, columnCount, superset, supersetCount, out);
    }
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
protected void serializeInternal(DataOutputPlus out, int version) throws IOException
{
    ClusteringComparator comparator = (ClusteringComparator)clusterings.comparator();
    out.writeUnsignedVInt(clusterings.size());
    for (Clustering clustering : clusterings)
        Clustering.serializer.serialize(clustering, out, version, comparator.subtypes());
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(EncodedHintMessage message, DataOutputPlus out, int version) throws IOException
{
    if (version != message.version)
        throw new IllegalArgumentException("serialize() called with non-matching version " + version);

    UUIDSerializer.serializer.serialize(message.hostId, out, version);
    out.writeUnsignedVInt(message.hint.remaining());
    out.write(message.hint);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(HintMessage message, DataOutputPlus out, int version) throws IOException
{
    Objects.requireNonNull(message.hint); // we should never *send* a HintMessage with null hint

    UUIDSerializer.serializer.serialize(message.hostId, out, version);

    /*
     * We are serializing the hint size so that the receiver of the message could gracefully handle
     * deserialize failure when a table had been dropped, by simply skipping the unread bytes.
     */
    out.writeUnsignedVInt(Hint.serializer.serializedSize(message.hint, version));

    Hint.serializer.serialize(message.hint, out, version);
}