Java MemoryOutputStream类代码示例

import org.apache.cassandra.io.util.MemoryOutputStream; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner, boolean haveSamplingLevel, int expectedIndexInterval) throws IOException
{
    int indexInterval = in.readInt();
    if (indexInterval != expectedIndexInterval)
    {
        throw new IOException(String.format("Cannot read index summary because Index Interval changed from %d to %d.",
                                                   indexInterval, expectedIndexInterval));
    }
    int summarySize = in.readInt();
    long offheapSize = in.readLong();
    int samplingLevel, fullSamplingSummarySize;
    if (haveSamplingLevel)
    {
        samplingLevel = in.readInt();
        fullSamplingSummarySize = in.readInt();
    }
    else
    {
        samplingLevel = BASE_SAMPLING_LEVEL;
        fullSamplingSummarySize = summarySize;
    }
    Memory memory = Memory.allocate(offheapSize);
    FBUtilities.copy(in, new MemoryOutputStream(memory), offheapSize);
    return new IndexSummary(partitioner, memory, summarySize, fullSamplingSummarySize, indexInterval, samplingLevel);
}
 

import org.apache.cassandra.io.util.MemoryOutputStream; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner) throws IOException
{
    int indexInterval = in.readInt();
    int summary_size = in.readInt();
    long offheap_size = in.readLong();
    Memory memory = Memory.allocate(offheap_size);
    FBUtilities.copy(in, new MemoryOutputStream(memory), offheap_size);
    return new IndexSummary(partitioner, memory, summary_size, indexInterval);
}
 

import org.apache.cassandra.io.util.MemoryOutputStream; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner, boolean haveSamplingLevel, int expectedMinIndexInterval, int maxIndexInterval) throws IOException
{
    int minIndexInterval = in.readInt();
    if (minIndexInterval != expectedMinIndexInterval)
    {
        throw new IOException(String.format("Cannot read index summary because min_index_interval changed from %d to %d.",
                                            minIndexInterval, expectedMinIndexInterval));
    }

    int summarySize = in.readInt();
    long offheapSize = in.readLong();
    int samplingLevel, fullSamplingSummarySize;
    if (haveSamplingLevel)
    {
        samplingLevel = in.readInt();
        fullSamplingSummarySize = in.readInt();
    }
    else
    {
        samplingLevel = BASE_SAMPLING_LEVEL;
        fullSamplingSummarySize = summarySize;
    }

    int effectiveIndexInterval = (int) Math.ceil((BASE_SAMPLING_LEVEL / (double) samplingLevel) * minIndexInterval);
    if (effectiveIndexInterval > maxIndexInterval)
    {
        throw new IOException(String.format("Rebuilding index summary because the effective index interval (%d) is higher than" +
                                            " the current max index interval (%d)", effectiveIndexInterval, maxIndexInterval));
    }

    RefCountedMemory memory = new RefCountedMemory(offheapSize);
    FBUtilities.copy(in, new MemoryOutputStream(memory), offheapSize);
    return new IndexSummary(partitioner, memory, summarySize, fullSamplingSummarySize, minIndexInterval, samplingLevel);
}
 

import org.apache.cassandra.io.util.MemoryOutputStream; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner, boolean haveSamplingLevel, int expectedMinIndexInterval, int maxIndexInterval) throws IOException
{
    int minIndexInterval = in.readInt();
    if (minIndexInterval != expectedMinIndexInterval)
    {
        throw new IOException(String.format("Cannot read index summary because min_index_interval changed from %d to %d.",
                                            minIndexInterval, expectedMinIndexInterval));
    }

    int summarySize = in.readInt();
    long offheapSize = in.readLong();
    int samplingLevel, fullSamplingSummarySize;
    if (haveSamplingLevel)
    {
        samplingLevel = in.readInt();
        fullSamplingSummarySize = in.readInt();
    }
    else
    {
        samplingLevel = BASE_SAMPLING_LEVEL;
        fullSamplingSummarySize = summarySize;
    }

    int effectiveIndexInterval = (int) Math.ceil((BASE_SAMPLING_LEVEL / (double) samplingLevel) * minIndexInterval);
    if (effectiveIndexInterval > maxIndexInterval)
    {
        throw new IOException(String.format("Rebuilding index summary because the effective index interval (%d) is higher than" +
                                            " the current max index interval (%d)", effectiveIndexInterval, maxIndexInterval));
    }

    Memory memory = Memory.allocate(offheapSize);
    FBUtilities.copy(in, new MemoryOutputStream(memory), offheapSize);
    return new IndexSummary(partitioner, memory, summarySize, fullSamplingSummarySize, minIndexInterval, samplingLevel);
}
 

import org.apache.cassandra.io.util.MemoryOutputStream; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner, boolean haveSamplingLevel, int expectedMinIndexInterval, int maxIndexInterval) throws IOException
{
    int minIndexInterval = in.readInt();
    if (minIndexInterval != expectedMinIndexInterval)
    {
        throw new IOException(String.format("Cannot read index summary because min_index_interval changed from %d to %d.",
                                            minIndexInterval, expectedMinIndexInterval));
    }

    int offsetCount = in.readInt();
    long offheapSize = in.readLong();
    int samplingLevel, fullSamplingSummarySize;
    if (haveSamplingLevel)
    {
        samplingLevel = in.readInt();
        fullSamplingSummarySize = in.readInt();
    }
    else
    {
        samplingLevel = BASE_SAMPLING_LEVEL;
        fullSamplingSummarySize = offsetCount;
    }

    int effectiveIndexInterval = (int) Math.ceil((BASE_SAMPLING_LEVEL / (double) samplingLevel) * minIndexInterval);
    if (effectiveIndexInterval > maxIndexInterval)
    {
        throw new IOException(String.format("Rebuilding index summary because the effective index interval (%d) is higher than" +
                                            " the current max index interval (%d)", effectiveIndexInterval, maxIndexInterval));
    }

    Memory offsets = Memory.allocate(offsetCount * 4);
    Memory entries = Memory.allocate(offheapSize - offsets.size());
    FBUtilities.copy(in, new MemoryOutputStream(offsets), offsets.size());
    FBUtilities.copy(in, new MemoryOutputStream(entries), entries.size());
    // our on-disk representation treats the offsets and the summary data as one contiguous structure,
    // in which the offsets are based from the start of the structure. i.e., if the offsets occupy
    // X bytes, the value of the first offset will be X. In memory we split the two regions up, so that
    // the summary values are indexed from zero, so we apply a correction to the offsets when de/serializing.
    // In this case subtracting X from each of the offsets.
    for (int i = 0 ; i < offsets.size() ; i += 4)
        offsets.setInt(i, (int) (offsets.getInt(i) - offsets.size()));
    return new IndexSummary(partitioner, offsets, offsetCount, entries, entries.size(), fullSamplingSummarySize, minIndexInterval, samplingLevel);
}