Java DataOutputPlus.writeBoolean方法代码示例

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(RepairJobDesc desc, DataOutputPlus out, int version) throws IOException
{
    if (version >= MessagingService.VERSION_21)
    {
        out.writeBoolean(desc.parentSessionId != null);
        if (desc.parentSessionId != null)
            UUIDSerializer.serializer.serialize(desc.parentSessionId, out, version);
    }
    UUIDSerializer.serializer.serialize(desc.sessionId, out, version);
    out.writeUTF(desc.keyspace);
    out.writeUTF(desc.columnFamily);
    MessagingService.validatePartitioner(desc.ranges);
    out.writeInt(desc.ranges.size());
    for (Range<Token> rt : desc.ranges)
        AbstractBounds.tokenSerializer.serialize(rt, out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(DataRange range, DataOutputPlus out, int version, CFMetaData metadata) throws IOException
{
    AbstractBounds.rowPositionSerializer.serialize(range.keyRange, out, version);
    ClusteringIndexFilter.serializer.serialize(range.clusteringIndexFilter, out, version);
    boolean isPaging = range instanceof Paging;
    out.writeBoolean(isPaging);
    if (isPaging)
    {
        Clustering.serializer.serialize(((Paging)range).lastReturned, out, version, metadata.comparator.subtypes());
        out.writeBoolean(((Paging)range).inclusive);
    }
}
 

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

    out.writeByte(filter.kind().ordinal());
    out.writeBoolean(filter.isReversed());

    filter.serializeInternal(out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(SnapshotCommand snapshot_command, DataOutputPlus out, int version) throws IOException
{
    out.writeUTF(snapshot_command.keyspace);
    out.writeUTF(snapshot_command.column_family);
    out.writeUTF(snapshot_command.snapshot_name);
    out.writeBoolean(snapshot_command.clear_snapshot);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(PrepareResponse response, DataOutputPlus out, int version) throws IOException
{
    out.writeBoolean(response.promised);
    ByteBufferUtil.writeWithShortLength(response.inProgressCommit.key, out);
    UUIDSerializer.serializer.serialize(response.inProgressCommit.ballot, out, version);
    ColumnFamily.serializer.serialize(response.inProgressCommit.update, out, version);
    UUIDSerializer.serializer.serialize(response.mostRecentCommit.ballot, out, version);
    ColumnFamily.serializer.serialize(response.mostRecentCommit.update, out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(KeyCacheKey key, DataOutputPlus out) throws IOException
{
    RowIndexEntry entry = CacheService.instance.keyCache.get(key);
    if (entry == null)
        return;

    CFMetaData cfm = Schema.instance.getCFMetaData(key.cfId);
    if (cfm == null)
        return; // the table no longer exists.

    ByteBufferUtil.writeWithLength(key.key, out);
    out.writeInt(key.desc.generation);
    out.writeBoolean(true);
    cfm.comparator.rowIndexEntrySerializer().serialize(entry, out);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(RepairJobDesc desc, DataOutputPlus out, int version) throws IOException
{
    if (version >= MessagingService.VERSION_21)
    {
        out.writeBoolean(desc.parentSessionId != null);
        if (desc.parentSessionId != null)
            UUIDSerializer.serializer.serialize(desc.parentSessionId, out, version);
    }
    UUIDSerializer.serializer.serialize(desc.sessionId, out, version);
    out.writeUTF(desc.keyspace);
    out.writeUTF(desc.columnFamily);
    AbstractBounds.serializer.serialize(desc.range, out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(ValidationComplete message, DataOutputPlus out, int version) throws IOException
{
    RepairJobDesc.serializer.serialize(message.desc, out, version);
    out.writeBoolean(message.success);
    if (message.success)
        MerkleTree.serializer.serialize(message.tree, out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(PagedRangeCommand cmd, DataOutputPlus out, int version) throws IOException
{
    out.writeUTF(cmd.keyspace);
    out.writeUTF(cmd.columnFamily);
    out.writeLong(cmd.timestamp);

    AbstractBounds.serializer.serialize(cmd.keyRange, out, version);

    CFMetaData metadata = Schema.instance.getCFMetaData(cmd.keyspace, cmd.columnFamily);

    // SliceQueryFilter (the count is not used)
    SliceQueryFilter filter = (SliceQueryFilter)cmd.predicate;
    metadata.comparator.sliceQueryFilterSerializer().serialize(filter, out, version);

    // The start and stop of the page
    metadata.comparator.serializer().serialize(cmd.start, out);
    metadata.comparator.serializer().serialize(cmd.stop, out);

    out.writeInt(cmd.rowFilter.size());
    for (IndexExpression expr : cmd.rowFilter)
    {
        expr.writeTo(out);;
    }

    out.writeInt(cmd.limit);
    if (version >= MessagingService.VERSION_21)
        out.writeBoolean(cmd.countCQL3Rows);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(ReadResponse response, DataOutputPlus out, int version) throws IOException
{
    out.writeInt(response.isDigestQuery() ? response.digest().remaining() : 0);
    ByteBuffer buffer = response.isDigestQuery() ? response.digest() : ByteBufferUtil.EMPTY_BYTE_BUFFER;
    out.write(buffer);
    out.writeBoolean(response.isDigestQuery());
    if (!response.isDigestQuery())
        Row.serializer.serialize(response.row(), out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(RangeSliceCommand sliceCommand, DataOutputPlus out, int version) throws IOException
{
    out.writeUTF(sliceCommand.keyspace);
    out.writeUTF(sliceCommand.columnFamily);
    out.writeLong(sliceCommand.timestamp);

    CFMetaData metadata = Schema.instance.getCFMetaData(sliceCommand.keyspace, sliceCommand.columnFamily);

    metadata.comparator.diskAtomFilterSerializer().serialize(sliceCommand.predicate, out, version);

    if (sliceCommand.rowFilter == null)
    {
        out.writeInt(0);
    }
    else
    {
        out.writeInt(sliceCommand.rowFilter.size());
        for (IndexExpression expr : sliceCommand.rowFilter)
        {
            expr.writeTo(out);
        }
    }
    AbstractBounds.serializer.serialize(sliceCommand.keyRange, out, version);
    out.writeInt(sliceCommand.maxResults);
    out.writeBoolean(sliceCommand.countCQL3Rows);
    out.writeBoolean(sliceCommand.isPaging);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(ReadCommand rm, DataOutputPlus out, int version) throws IOException
{
    SliceFromReadCommand realRM = (SliceFromReadCommand)rm;
    out.writeBoolean(realRM.isDigestQuery());
    out.writeUTF(realRM.ksName);
    ByteBufferUtil.writeWithShortLength(realRM.key, out);
    out.writeUTF(realRM.cfName);
    out.writeLong(realRM.timestamp);
    CFMetaData metadata = Schema.instance.getCFMetaData(realRM.ksName, realRM.cfName);
    metadata.comparator.sliceQueryFilterSerializer().serialize(realRM.filter, out, version);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(RowFilter filter, DataOutputPlus out, int version) throws IOException
{
    out.writeBoolean(filter instanceof ThriftFilter);
    out.writeUnsignedVInt(filter.expressions.size());
    for (Expression expr : filter.expressions)
        Expression.serializer.serialize(expr, out, version);

}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
private void serializeSliceCommand(SinglePartitionReadCommand command, DataOutputPlus out) throws IOException
{
    CFMetaData metadata = command.metadata();
    ClusteringIndexSliceFilter filter = (ClusteringIndexSliceFilter)command.clusteringIndexFilter();

    Slices slices = filter.requestedSlices();
    boolean makeStaticSlice = !command.columnFilter().fetchedColumns().statics.isEmpty() && !slices.selects(Clustering.STATIC_CLUSTERING);
    serializeSlices(out, slices, filter.isReversed(), makeStaticSlice, metadata);

    out.writeBoolean(filter.isReversed());

    boolean selectsStatics = !command.columnFilter().fetchedColumns().statics.isEmpty() || slices.selects(Clustering.STATIC_CLUSTERING);
    DataLimits limits = command.limits();
    if (limits.isDistinct())
        out.writeInt(1);  // the limit is always 1 for DISTINCT queries
    else
        out.writeInt(updateLimitForQuery(command.limits().count(), filter.requestedSlices()));

    int compositesToGroup;
    if (limits.kind() == DataLimits.Kind.THRIFT_LIMIT || metadata.isDense())
        compositesToGroup = -1;
    else if (limits.isDistinct() && !selectsStatics)
        compositesToGroup = -2;  // for DISTINCT queries (CASSANDRA-8490)
    else
        compositesToGroup = metadata.clusteringColumns().size();

    out.writeInt(compositesToGroup);
}
 

import org.apache.cassandra.io.util.DataOutputPlus; //导入方法依赖的package包/类
public void serialize(SliceQueryFilter f, DataOutputPlus out, int version) throws IOException
{
    out.writeInt(f.slices.length);
    for (ColumnSlice slice : f.slices)
        type.sliceSerializer().serialize(slice, out, version);
    out.writeBoolean(f.reversed);
    int count = f.count;
    out.writeInt(count);

    out.writeInt(f.compositesToGroup);
}