Java 类it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap 实例源码

private static void decodePropertyColumn(MultipartBinary.PropertyColumn column, ObjectArrayList<? extends StoreRef> entries) {
    final String key = column.getKey();
    Int2ObjectArrayMap<DataRef> outputs = new Int2ObjectArrayMap<>();
    Input input = new Input(column.getData().toByteArray());
    CoreRefType type = BinaryCoreReader.fromByteValue((byte)column.getType().getNumber());
    BinaryCoreReader propreader = new BinaryCoreReader(input);
    int i = 0;
    while(!input.eof()) {
        byte b = input.readByte();
        if(b == 0x0) {
            i++;
        }
        else if(b == (byte)0xFF) {
            entries.get(i).get().putProperty(key, propreader.read(type));
            i++;
        }
        else if(b == (byte)0xFE) {
            i += input.readVarInt(true);
        } else {
            input.setPosition(input.position()-1);
            entries.get(i).get().putProperty(key, propreader.read(type));
            i++;
        }
    }
}

public void putModel(StorageNetworkCable.CableType type, CableColor color, EnumFacing side, int state, int channel, IBakedModel bake) {
    if (!model.containsKey(type)) {
        model.put(type, new EnumMap<CableColor, Map<EnumFacing, Map<Integer, Map<Integer, IBakedModel>>>>(CableColor.class));
    }
    Map<CableColor, Map<EnumFacing, Map<Integer, Map<Integer, IBakedModel>>>> map = model.get(type);
    if (!map.containsKey(color)) {
        map.put(color, new EnumMap<EnumFacing, Map<Integer, Map<Integer, IBakedModel>>>(EnumFacing.class));
    }
    Map<EnumFacing, Map<Integer, Map<Integer, IBakedModel>>> m = map.get(color);
    if (!m.containsKey(side)) {
        m.put(side, new Int2ObjectArrayMap<Map<Integer, IBakedModel>>());
    }
    Map<Integer, Map<Integer, IBakedModel>> stateMap = m.get(side);
    if (!stateMap.containsKey(state)) {
        stateMap.put(state, new Int2ObjectArrayMap<IBakedModel>());
    }
    stateMap.get(state).put(channel, bake);
    last.add(bake);
    if (first == null)
        first = bake;
    if (type == StorageNetworkCable.CableType.NORMAL && color == CableColor.FLUIX && state == 0 && channel == 0) {
        baseModel.addAll(bake.getQuads(StorageInit.cable.getDefaultState(), null, 0));
    }
}

/** */
public Int2ObjectArrayMap<IntSet> indexesMap() {
    Int2ObjectArrayMap<IntSet> res = new Int2ObjectArrayMap<>();

    for (Integer row : sto.keySet())
        res.put(row.intValue(), (IntSet)sto.get(row).keySet());

    return res;
}

public void putModelOverride(StorageNetworkCable.CableType type, CableColor color, int channel, Axis axis, IBakedModel bake) {
    if (!modelO.containsKey(type)) {
        modelO.put(type, new EnumMap<CableColor, Map<Integer, Map<Axis, IBakedModel>>>(CableColor.class));
    }
    Map<CableColor, Map<Integer, Map<Axis, IBakedModel>>> map = modelO.get(type);
    if (!map.containsKey(color)) {
        map.put(color, new Int2ObjectArrayMap<Map<Axis, IBakedModel>>());
    }
    Map<Integer, Map<Axis, IBakedModel>> m = map.get(color);
    if (!m.containsKey(channel)) {
        m.put(channel, new EnumMap<Axis, IBakedModel>(Axis.class));
    }
    m.get(channel).put(axis, bake);
}

/** */
public Int2ObjectArrayMap<IntSet> indexesMap() {
    Int2ObjectArrayMap<IntSet> res = new Int2ObjectArrayMap<>();

    for (Integer row : sto.keySet())
        res.put(row.intValue(), (IntSet)sto.get(row).keySet());

    return res;
}

/** */
public Int2ObjectArrayMap<IntSet> indexesMap() {
    return ((SparseLocalOnHeapMatrixStorage)getStorage()).indexesMap();
}

/** */
public Int2ObjectArrayMap<IntSet> indexesMap() {
    return ((SparseLocalOnHeapMatrixStorage)getStorage()).indexesMap();
}

public Numberer(int capacity) {
    cnt = 0;
    index2object = new Int2ObjectArrayMap<T>(capacity);
    object2index = new Object2IntArrayMap<>(capacity);
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, DataType type, int tagNum, int value) {
    assert (tagNum > 0) : "Tag must be positive.";
    map.put(tagNum, FieldFactory.fromIntValue(type, tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, int tagNum, int value) {
    assert (tagNum > 0) : "Tag must be positive.";
    map.put(tagNum, FieldFactory.fromIntValue(tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, FieldType fieldType, int value) {
    assert (fieldType != null) : "Tag must be specified.";
    map.put(fieldType.tag(), FieldFactory.fromIntValue(fieldType.type(), fieldType.tag(), value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, DataType type, int tagNum, long value) {
    assert (tagNum > 0) : "Tag must be positive.";
    map.put(tagNum, FieldFactory.fromLongValue(type, tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, int tagNum, long value) {
    assert (tagNum > 0) : "Tag must be positive.";
    map.put(tagNum, FieldFactory.fromLongValue(tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, FieldType fieldType, long value) {
    assert (fieldType != null) : "Tag must be specified.";
    map.put(fieldType.tag(), FieldFactory.fromLongValue(fieldType.type(), fieldType.tag(), value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, FieldType fieldType, String value) {
    assert (fieldType != null) : "Tag must be specified.";
    assert (value != null) : "Value must be specified.";
    map.put(fieldType.tag(), FieldFactory.fromStringValue(fieldType.type(), fieldType.tag(), value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, FieldType fieldType, char value) {
    if (fieldType.type() != DataType.CHAR) {
        throw new IllegalArgumentException("FieldType " + fieldType + " must be CHAR");
    }
    map.put(fieldType.tag(), new CharField(fieldType.tag(), value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, int tagNum, String value) {
    assert (tagNum > 0) : "TagNum must be positive. Got " + tagNum;
    assert (value != null) : "Value must be specified.";
    map.put(tagNum, FieldFactory.fromStringValue(tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, DataType type, int tagNum, String value) {
    assert (tagNum > 0) : "TagNum must be positive. Got " + tagNum;
    assert (value != null) : "Value must be specified.";
    map.put(tagNum, FieldFactory.fromStringValue(type, tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, FieldType fieldType, FixedPointNumber value) {
    assert (fieldType != null) : "Tag must be specified.";
    assert (value != null) : "Value must be specified.";
    map.put(fieldType.tag(), FieldFactory.fromFixedPointValue(fieldType.type(), fieldType.tag(), value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, int tagNum, FixedPointNumber value) {
    assert (tagNum > 0) : "TagNum must be positive. Got " + tagNum;
    assert (value != null) : "Value must be specified.";
    map.put(tagNum, FieldFactory.fromFixedPointValue(tagNum, value));
}

public static void add(Int2ObjectArrayMap<FixMessageFragment> map, DataType type, int tagNum, FixedPointNumber value) {
    assert (tagNum > 0) : "TagNum must be positive. Got " + tagNum;
    assert (value != null) : "Value must be specified.";
    map.put(tagNum, FieldFactory.fromFixedPointValue(type, tagNum, value));
}

public Group(int expectedSize) {
    this.contents = new Int2ObjectArrayMap<>(expectedSize);
}

public Group() {
    this.contents = new Int2ObjectArrayMap<>(DEFAULT_GROUP_SIZE);
}

/**
 * Creates FixMessageBuilderImpl with expected body field count.
 * <p>
 * Providing expected capacity eliminates unnecessary growing of internal ArrayList storing body fields.
 * </p>
 *
 * @param expectedBodyFieldCount estimated maximum number of field in message body
 */
private FixMessageBuilderImpl(int expectedBodyFieldCount) {
    this.header = new FixMessageHeader();
    this.trailer = new FixMessageTrailer();
    this.body = new Int2ObjectArrayMap<>(expectedBodyFieldCount);
}