Java MessagingService.VERSION_30属性代码示例

public void serialize(Inner inner, DataOutputPlus out, int version) throws IOException
{
    if (version < MessagingService.VERSION_30)
    {
        if (inner.hash == null)
            out.writeInt(-1);
        else
        {
            out.writeInt(inner.hash.length);
            out.write(inner.hash);
        }
    }
    Token.serializer.serialize(inner.token, out, version);
    Hashable.serializer.serialize(inner.lchild, out, version);
    Hashable.serializer.serialize(inner.rchild, out, version);
}
 

public StreamDeserializer(CFMetaData metadata, InputStream in, Version version, SerializationHeader header,
                          long totalSize, UUID sessionId) throws IOException
{
    this.metadata = metadata;
    // streaming pre-3.0 sstables require mark/reset support from source stream
    if (version.correspondingMessagingVersion() < MessagingService.VERSION_30)
    {
        logger.trace("Initializing rewindable input stream for reading legacy sstable with {} bytes with following " +
                     "parameters: initial_mem_buffer_size={}, max_mem_buffer_size={}, max_spill_file_size={}.",
                     totalSize, INITIAL_MEM_BUFFER_SIZE, MAX_MEM_BUFFER_SIZE, MAX_SPILL_FILE_SIZE);
        File bufferFile = getTempBufferFile(metadata, totalSize, sessionId);
        this.in = new RewindableDataInputStreamPlus(in, INITIAL_MEM_BUFFER_SIZE, MAX_MEM_BUFFER_SIZE, bufferFile, MAX_SPILL_FILE_SIZE);
    } else
        this.in = new DataInputPlus.DataInputStreamPlus(in);
    this.helper = new SerializationHelper(metadata, version.correspondingMessagingVersion(), SerializationHelper.Flag.PRESERVE_SIZE);
    this.header = header;
}
 

public PrepareResponse deserialize(DataInputPlus in, int version) throws IOException
{
    boolean success = in.readBoolean();
    Commit inProgress = Commit.serializer.deserialize(in, version);
    Commit mostRecent;
    if (version < MessagingService.VERSION_30)
    {
        UUID ballot = UUIDSerializer.serializer.deserialize(in, version);
        PartitionUpdate update = PartitionUpdate.serializer.deserialize(in, version, SerializationHelper.Flag.LOCAL, inProgress.update.partitionKey());
        mostRecent = new Commit(ballot, update);
    }
    else
    {
        mostRecent = Commit.serializer.deserialize(in, version);
    }
    return new PrepareResponse(success, inProgress, mostRecent);
}
 

public long serializedSize(PrepareResponse response, int version)
{
    long size = TypeSizes.sizeof(response.promised)
              + Commit.serializer.serializedSize(response.inProgressCommit, version);

    if (version < MessagingService.VERSION_30)
    {
        size += UUIDSerializer.serializer.serializedSize(response.mostRecentCommit.ballot, version);
        size += PartitionUpdate.serializer.serializedSize(response.mostRecentCommit.update, version);
    }
    else
    {
        size += Commit.serializer.serializedSize(response.mostRecentCommit, version);
    }
    return size;
}
 

public void serialize(AbstractBounds<T> range, DataOutputPlus out, int version) throws IOException
{
    /*
     * The first int tells us if it's a range or bounds (depending on the value) _and_ if it's tokens or keys (depending on the
     * sign). We use negative kind for keys so as to preserve the serialization of token from older version.
     */
    if (version < MessagingService.VERSION_30)
        out.writeInt(kindInt(range));
    else
        out.writeByte(kindFlags(range));
    serializer.serialize(range.left, out, version);
    serializer.serialize(range.right, out, version);
}
 

public long serializedSize(AbstractBounds<T> ab, int version)
{
    int size = version < MessagingService.VERSION_30
             ? TypeSizes.sizeof(kindInt(ab))
             : 1;
    size += serializer.serializedSize(ab.left, version);
    size += serializer.serializedSize(ab.right, version);
    return size;
}
 

public static UnfilteredDeserializer create(CFMetaData metadata,
                                            DataInputPlus in,
                                            SerializationHeader header,
                                            SerializationHelper helper,
                                            DeletionTime partitionDeletion,
                                            boolean readAllAsDynamic)
{
    if (helper.version >= MessagingService.VERSION_30)
        return new CurrentDeserializer(metadata, in, header, helper);
    else
        return new OldFormatDeserializer(metadata, in, helper, partitionDeletion, readAllAsDynamic);
}
 

public static SSTableSimpleIterator create(CFMetaData metadata, DataInputPlus in, SerializationHeader header, SerializationHelper helper, DeletionTime partitionDeletion)
{
    if (helper.version < MessagingService.VERSION_30)
        return new OldFormatIterator(metadata, in, helper, partitionDeletion);
    else
        return new CurrentFormatIterator(metadata, in, header, helper);
}
 

public static SSTableSimpleIterator createTombstoneOnly(CFMetaData metadata, DataInputPlus in, SerializationHeader header, SerializationHelper helper, DeletionTime partitionDeletion)
{
    if (helper.version < MessagingService.VERSION_30)
        return new OldFormatTombstoneIterator(metadata, in, helper, partitionDeletion);
    else
        return new CurrentFormatTombstoneIterator(metadata, in, header, helper);
}
 

BigVersion(String version)
{
    super(instance, version);

    isLatestVersion = version.compareTo(current_version) == 0;
    hasSamplingLevel = version.compareTo("ka") >= 0;
    newStatsFile = version.compareTo("ka") >= 0;

    //For a while Adler32 was in use, now the CRC32 instrinsic is very good especially after Haswell
    //PureJavaCRC32 was always faster than Adler32. See CASSANDRA-8684
    ChecksumType checksumType = ChecksumType.CRC32;
    if (version.compareTo("ka") >= 0 && version.compareTo("ma") < 0)
        checksumType = ChecksumType.Adler32;
    this.uncompressedChecksumType = checksumType;

    checksumType = ChecksumType.CRC32;
    if (version.compareTo("jb") >= 0 && version.compareTo("ma") < 0)
        checksumType = ChecksumType.Adler32;
    this.compressedChecksumType = checksumType;

    hasRepairedAt = version.compareTo("ka") >= 0;
    tracksLegacyCounterShards = version.compareTo("ka") >= 0;

    newFileName = version.compareTo("la") >= 0;

    hasOldBfHashOrder = version.compareTo("ma") < 0;
    hasCompactionAncestors = version.compareTo("ma") < 0;
    storeRows = version.compareTo("ma") >= 0;
    correspondingMessagingVersion = storeRows
                                  ? MessagingService.VERSION_30
                                  : MessagingService.VERSION_21;

    hasBoundaries = version.compareTo("ma") < 0;
    hasCommitLogLowerBound = (version.compareTo("lb") >= 0 && version.compareTo("ma") < 0)
                             || version.compareTo("mb") >= 0;
    hasCommitLogIntervals = version.compareTo("mc") >= 0;
}
 

static int messagingVersion(int hintsVersion)
{
    switch (hintsVersion)
    {
        case VERSION_30:
            return MessagingService.VERSION_30;
        default:
            throw new AssertionError();
    }
}
 

public Inner deserialize(DataInput in, IPartitioner p, int version) throws IOException
{
    if (version < MessagingService.VERSION_30)
    {
        int hashLen = in.readInt();
        byte[] hash = hashLen >= 0 ? new byte[hashLen] : null;
        if (hash != null)
            in.readFully(hash);
    }
    Token token = Token.serializer.deserialize(in, p, version);
    Hashable lchild = Hashable.serializer.deserialize(in, p, version);
    Hashable rchild = Hashable.serializer.deserialize(in, p, version);
    return new Inner(token, lchild, rchild);
}
 

public long serializedSize(Inner inner, int version)
{
    long size = 0;
    if (version < MessagingService.VERSION_30)
    {
        size += inner.hash == null
                           ? TypeSizes.sizeof(-1)
                           : TypeSizes.sizeof(inner.hash().length) + inner.hash().length;
    }

    size += Token.serializer.serializedSize(inner.token, version)
    + Hashable.serializer.serializedSize(inner.lchild, version)
    + Hashable.serializer.serializedSize(inner.rchild, version);
    return size;
}
 

public void serialize(PrepareResponse response, DataOutputPlus out, int version) throws IOException
{
    out.writeBoolean(response.promised);
    Commit.serializer.serialize(response.inProgressCommit, out, version);

    if (version < MessagingService.VERSION_30)
    {
        UUIDSerializer.serializer.serialize(response.mostRecentCommit.ballot, out, version);
        PartitionUpdate.serializer.serialize(response.mostRecentCommit.update, out, version);
    }
    else
    {
        Commit.serializer.serialize(response.mostRecentCommit, out, version);
    }
}
 

public void serialize(Commit commit, DataOutputPlus out, int version) throws IOException
{
    if (version < MessagingService.VERSION_30)
        ByteBufferUtil.writeWithShortLength(commit.update.partitionKey().getKey(), out);

    UUIDSerializer.serializer.serialize(commit.ballot, out, version);
    PartitionUpdate.serializer.serialize(commit.update, out, version);
}