Java ISerializer类代码示例

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
/**
 * @param dataFilePosition  position of the partition in the {@link org.apache.cassandra.io.sstable.Component.Type#DATA} file
 * @param indexFilePosition position in the {@link org.apache.cassandra.io.sstable.Component.Type#PRIMARY_INDEX} of the {@link RowIndexEntry}
 * @param deletionTime      deletion time of {@link RowIndexEntry}
 * @param headerLength      deletion time of {@link RowIndexEntry}
 * @param columnIndexCount  number of {@link IndexInfo} entries in the {@link RowIndexEntry}
 * @param indexedPartSize   serialized size of all serialized {@link IndexInfo} objects and their offsets
 * @param indexSamples      list with IndexInfo offsets (if total serialized size is less than {@link org.apache.cassandra.config.Config#column_index_cache_size_in_kb}
 * @param offsets           offsets of IndexInfo offsets
 * @param idxInfoSerializer the {@link IndexInfo} serializer
 */
public static RowIndexEntry<IndexInfo> create(long dataFilePosition, long indexFilePosition,
                                   DeletionTime deletionTime, long headerLength, int columnIndexCount,
                                   int indexedPartSize,
                                   List<IndexInfo> indexSamples, int[] offsets,
                                   ISerializer<IndexInfo> idxInfoSerializer)
{
    // If the "partition building code" in BigTableWriter.append() via ColumnIndex returns a list
    // of IndexInfo objects, which is the case if the serialized size is less than
    // Config.column_index_cache_size_in_kb, AND we have more than one IndexInfo object, we
    // construct an IndexedEntry object. (note: indexSamples.size() and columnIndexCount have the same meaning)
    if (indexSamples != null && indexSamples.size() > 1)
        return new IndexedEntry(dataFilePosition, deletionTime, headerLength,
                                indexSamples.toArray(new IndexInfo[indexSamples.size()]), offsets,
                                indexedPartSize, idxInfoSerializer);
    // Here we have to decide whether we have serialized IndexInfo objects that exceeds
    // Config.column_index_cache_size_in_kb (not exceeding case covered above).
    // Such a "big" indexed-entry is represented as a shallow one.
    if (columnIndexCount > 1)
        return new ShallowIndexedEntry(dataFilePosition, indexFilePosition,
                                       deletionTime, headerLength, columnIndexCount,
                                       indexedPartSize, idxInfoSerializer);
    // Last case is that there are no index samples.
    return new RowIndexEntry<>(dataFilePosition);
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
/**
 * See {@link #create(long, long, DeletionTime, long, int, int, List, int[], ISerializer)} for a description
 * of the parameters.
 */
private ShallowIndexedEntry(long dataFilePosition, long indexFilePosition,
                            DeletionTime deletionTime, long headerLength, int columnIndexCount,
                            int indexedPartSize, ISerializer<IndexInfo> idxInfoSerializer)
{
    super(dataFilePosition);

    assert columnIndexCount > 1;

    this.indexFilePosition = indexFilePosition;
    this.headerLength = headerLength;
    this.deletionTime = deletionTime;
    this.columnsIndexCount = columnIndexCount;

    this.indexedPartSize = indexedPartSize;
    this.idxInfoSerializer = idxInfoSerializer;

    this.fieldsSerializedSize = serializedSize(deletionTime, headerLength, columnIndexCount);
    this.offsetsOffset = indexedPartSize + fieldsSerializedSize - columnsIndexCount * TypeSizes.sizeof(0);
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public RowIndexEntry deserialize(DataInput in, Descriptor.Version version) throws IOException
{
    long position = in.readLong();

    int size = in.readInt();
    if (size > 0)
    {
        DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);

        int entries = in.readInt();
        ISerializer<IndexHelper.IndexInfo> idxSerializer = type.indexSerializer();
        List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<IndexHelper.IndexInfo>(entries);
        for (int i = 0; i < entries; i++)
            columnsIndex.add(idxSerializer.deserialize(in));

        return new IndexedEntry(position, deletionTime, columnsIndex);
    }
    else
    {
        return new RowIndexEntry(position);
    }
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public int serializedSize(RowIndexEntry rie)
{
    int size = TypeSizes.NATIVE.sizeof(rie.position) + TypeSizes.NATIVE.sizeof(rie.promotedSize(type));

    if (rie.isIndexed())
    {
        List<IndexHelper.IndexInfo> index = rie.columnsIndex();

        size += DeletionTime.serializer.serializedSize(rie.deletionTime(), TypeSizes.NATIVE);
        size += TypeSizes.NATIVE.sizeof(index.size());

        ISerializer<IndexHelper.IndexInfo> idxSerializer = type.indexSerializer();
        for (IndexHelper.IndexInfo info : index)
            size += idxSerializer.serializedSize(info, TypeSizes.NATIVE);
    }

    return size;
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
private SerializingCache(long capacity, Weigher<RefCountedMemory> weigher, ISerializer<V> serializer)
{
    this.serializer = serializer;

    EvictionListener<K,RefCountedMemory> listener = new EvictionListener<K, RefCountedMemory>()
    {
        public void onEviction(K k, RefCountedMemory mem)
        {
            mem.unreference();
        }
    };

    this.map = new ConcurrentLinkedHashMap.Builder<K, RefCountedMemory>()
               .weigher(weigher)
               .maximumWeightedCapacity(capacity)
               .concurrencyLevel(DEFAULT_CONCURENCY_LEVEL)
               .listener(listener)
               .build();
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
private IndexedEntry(long dataFilePosition, DeletionTime deletionTime, long headerLength,
                     IndexInfo[] columnsIndex, int[] offsets,
                     int indexedPartSize, ISerializer<IndexInfo> idxInfoSerializer)
{
    super(dataFilePosition);

    this.headerLength = headerLength;
    this.deletionTime = deletionTime;

    this.columnsIndex = columnsIndex;
    this.offsets = offsets;
    this.indexedPartSize = indexedPartSize;
    this.idxInfoSerializer = idxInfoSerializer;
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
/**
 *
 * @param indexInfoFilePosition offset of first serialized {@link IndexInfo} object
 * @param indexReader file data input to access the index file, closed by this instance
 * @param idxInfoSerializer the index serializer to deserialize {@link IndexInfo} objects
 */
FileIndexInfoRetriever(long indexInfoFilePosition, FileDataInput indexReader, ISerializer<IndexInfo> idxInfoSerializer)
{
    this.indexInfoFilePosition = indexInfoFilePosition;
    this.idxInfoSerializer = idxInfoSerializer;
    this.indexReader = indexReader;
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public ColumnIndex(SerializationHeader header,
                    SequentialWriter writer,
                    Version version,
                    Collection<SSTableFlushObserver> observers,
                    ISerializer<IndexInfo> indexInfoSerializer)
{
    this.header = header;
    this.writer = writer;
    this.version = version.correspondingMessagingVersion();
    this.observers = observers;
    this.idxSerializer = indexInfoSerializer;
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
private ISerializer<ClusteringPrefix> indexEntryClusteringPrefixSerializer(Version version, SerializationHeader header)
{
    if (!version.storeRows() || header ==  null) //null header indicates streaming from pre-3.0 sstables
    {
        return oldFormatSerializer(version);
    }

    return new NewFormatSerializer(version, header.clusteringTypes());
}
 

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

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

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public void serialize(NamesQueryFilter f, DataOutputPlus out, int version) throws IOException
{
    out.writeInt(f.columns.size());
    ISerializer<CellName> serializer = type.cellSerializer();
    for (CellName cName : f.columns)
    {
        serializer.serialize(cName, out);
    }
    out.writeBoolean(f.countCQL3Rows);
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public NamesQueryFilter deserialize(DataInput in, int version) throws IOException
{
    int size = in.readInt();
    SortedSet<CellName> columns = new TreeSet<CellName>(type);
    ISerializer<CellName> serializer = type.cellSerializer();
    for (int i = 0; i < size; ++i)
        columns.add(serializer.deserialize(in));
    boolean countCQL3Rows = in.readBoolean();
    return new NamesQueryFilter(columns, countCQL3Rows);
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public long serializedSize(NamesQueryFilter f, int version)
{
    TypeSizes sizes = TypeSizes.NATIVE;
    int size = sizes.sizeof(f.columns.size());
    ISerializer<CellName> serializer = type.cellSerializer();
    for (CellName cName : f.columns)
        size += serializer.serializedSize(cName, sizes);
    size += sizes.sizeof(f.countCQL3Rows);
    return size;
}
 

import org.apache.cassandra.io.ISerializer; //导入依赖的package包/类
public ColumnSlice deserialize(DataInput in, int version) throws IOException
{
    ISerializer<Composite> serializer = type.serializer();
    Composite start = serializer.deserialize(in);
    Composite finish = serializer.deserialize(in);
    return new ColumnSlice(start, finish);
}