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

private void readNodeLayer(int id, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    String layer = MemoryCoreNodeLayer.fromId(id).layer;
    if(layer == null) {
        layer = reader.readString();
    }

    int numVariants = reader.readVarInt(true);

    for(int i = 0; i < numVariants; i++) {
        String variant = reader.readString();
        if(variant.equals(""))
            variant = null;

        readNodes(store.getNodeCollection(layer, variant), nodeRefs);
    }
}

private void readEdges(MemoryEdgeCollection store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    int edgeSize = reader.readVarInt(true);

    ArrayList<MemoryEdge> memoryEdges = new ArrayList<>(edgeSize);
    for(int i = 0; i < edgeSize; i++) {
        int head = reader.readVarInt(true);
        int tail = reader.readVarInt(true);

        MemoryEdge edge = store.create();

        edge.connect(nodeRefs.get(tail), nodeRefs.get(head));
        memoryEdges.add(edge);
    }

    readAllProperties(memoryEdges);
}

@Override
public MemoryDocument decode(Input input) {
    MemoryDocumentStore store = new MemoryDocumentStore();
    Reader reader = new Reader(input);

    store.properties = reader.readProperties();
    store.text = input.readString();

    Int2ReferenceOpenHashMap<NodeRef> nodeRefs = new Int2ReferenceOpenHashMap<>();

    int layerEnd = input.readInt();
    layerEnd += input.position();

    while(input.position() < layerEnd) {
        int id = Byte.toUnsignedInt(input.readByte());
        if((id & 0x80) == 0) {
            reader.readNodeLayer(id, store, nodeRefs);
        } else {
            reader.readEdgeLayer(id & ~0x80, store, nodeRefs);
        }
    }

    return new MemoryDocument(store);
}

@Override
public void decode(Input reader, String text, String key, int count, int[] propertySetMapping, IntArrayList psets, Int2ReferenceOpenHashMap<? extends StoreRef> refs) {
    int numEntries = reader.readVarInt(true);
    StringRef[] entries = new StringRef[numEntries];

    //Read dictionary
    /*int[] lens = new int[numEntries];
    for (int i = 0; i < numEntries; i++)
        lens[i] = reader.readPosVarInt();*/

    for(int i = 0; i < numEntries; i++)
        entries[i] = new StringRef(reader.readString());//reader.readRawString(lens[i]));

    IntListIterator noderange = psets.iterator();
    while (noderange.hasNext()) {
        int psetid = noderange.nextInt();
        final int start = propertySetMapping[psetid];
        final int end = propertySetMapping[psetid + 1];

        for (int i = start; i < end; i++) {
            refs.get(i).get().putProperty(key, entries[reader.readVarInt(true)]);
        }
    }
}

@Override
public void decode(Input reader, String text, String key, int count, int[] propertySetMapping, IntArrayList psets, Int2ReferenceOpenHashMap<? extends StoreRef> refs) {
    int numEntries = reader.readVarInt(true);
    //Read dictionary
    //int len = reader.readVarInt(true);
    StringRef[] entries = new StringRef[numEntries];

    for(int i = 0; i < numEntries; i++)
        entries[i] = new StringRef(reader.readString());

    IntListIterator noderange = psets.iterator();
    while (noderange.hasNext()) {
        int psetid = noderange.nextInt();
        final int start = propertySetMapping[psetid];
        final int end = propertySetMapping[psetid + 1];

        for (int i = start; i < end; i++) {
            refs.get(i).get().putProperty(key, entries[reader.readVarInt(true)]);
        }
    }
}

private void readNodeLayer(int id, Input reader, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    String layer = MemoryCoreNodeLayer.fromId(id).layer;
    if(layer == null) {
        layer = reader.readString();
    }

    int endPos = reader.readInt();
    endPos += reader.position();

    while(reader.position() < endPos) {
        String variant = reader.readString();
        if(variant.equals(""))
            variant = null;

        readNodes(store.getNodeCollection(layer, variant), reader, nodeRefs);
    }
}

private void readEdgeLayer(int id, Input reader, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    String layer = MemoryCoreEdgeLayer.fromId(id).layer;
    if(layer == null) {
        layer = reader.readString();
    }

    int endPos = reader.readInt();
    endPos += reader.position();

    while(reader.position() < endPos) {
        String variant = reader.readString();
        if(variant.equals(""))
            variant = null;

        readEdges(reader, store.getEdgeCollection(layer, variant), nodeRefs);
    }
}

@Override
public MemoryDocument decode(Input reader) {
    MemoryDocumentStore store = new MemoryDocumentStore();
    store.properties = readProperties(reader);
    store.text = reader.readString();

    Int2ReferenceOpenHashMap<NodeRef> nodeRefs = new Int2ReferenceOpenHashMap<>();

    int layerEnd = reader.readInt();
    layerEnd += reader.position();

    while(reader.position() < layerEnd) {
        int id = Byte.toUnsignedInt(reader.readByte());
        if((id & 0x80) == 0) {
            readNodeLayer(id, reader, store, nodeRefs);
        } else {
            readEdgeLayer(id & ~0x80, reader, store, nodeRefs);
        }
    }

    return new MemoryDocument(store);
}

public void readEdges(JsonNode node, MemoryEdgeCollection collection, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    JsonNode connections = node.path("connections");
    JsonNode properties = node.path("properties");
    int numEdges = connections.size()/2;

    Iterator<JsonNode> propIter = properties.elements();

    for(int i = 0; i < numEdges; i++) {
        int head = connections.get(i*2).intValue();
        int tail = connections.get(i*2+1).intValue();

        MemoryEdge memoryEdge = collection.create();
        memoryEdge.connect(nodeRefs.get(tail), nodeRefs.get(head));

        memoryEdge.properties = readProperties(propIter.next());
    }
}

@Test
public void whenIndexDoesNotHaveAnyPreviousIntersectingListItShouldIndexListAsExpected() {
    final Int2ReferenceMap<IntList> expectedListsInvertedIndex = new Int2ReferenceOpenHashMap<IntList>() {{
        put(1, new IntArrayList(new int[] {0}));
        put(3, new IntArrayList(new int[] {0}));
        put(4, new IntArrayList(new int[] {0}));
        put(5, new IntArrayList(new int[] {0}));
        put(8, new IntArrayList(new int[] {0}));
    }};
    final InvertedListIntReferenceListsIndex listsIndex = new InvertedListIntReferenceListsIndex();
    final int index = 0;
    final IntList list = new IntArrayList(new int[] {1, 3, 4, 5, 8});

    listsIndex.addListIntoListsInvertedIndex(index, list);

    assertEquals(
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(expectedListsInvertedIndex),
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(listsIndex.listsInvertedIndex)
    );
}

@Test
public void whenIndexHavePreviousIntersectingListItShouldIndexListAsExpected() {
    final Int2ReferenceMap<IntList> expectedListsInvertedIndex = new Int2ReferenceOpenHashMap<IntList>() {{
        put(1, new IntArrayList(new int[] {1}));
        put(2, new IntArrayList(new int[] {0}));
        put(3, new IntArrayList(new int[] {0, 1}));
        put(4, new IntArrayList(new int[] {1}));
        put(5, new IntArrayList(new int[] {0, 1}));
        put(8, new IntArrayList(new int[] {1}));
    }};
    final InvertedListIntReferenceListsIndex listsIndex = new InvertedListIntReferenceListsIndex();
    listsIndex.listsInvertedIndex.put(2, new IntArrayList(new int[]{0}));
    listsIndex.listsInvertedIndex.put(3, new IntArrayList(new int[]{0}));
    listsIndex.listsInvertedIndex.put(5, new IntArrayList(new int[]{0}));
    final int index = 1;
    final IntList list = new IntArrayList(new int[] {1, 3, 4, 5, 8});

    listsIndex.addListIntoListsInvertedIndex(index, list);

    assertEquals(
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(expectedListsInvertedIndex),
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(listsIndex.listsInvertedIndex)
    );
}

private void readEdgeLayer(int id, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    String layer = MemoryCoreEdgeLayer.fromId(id).layer;
    if(layer == null) {
        layer = reader.readString();
    }

    int numVariants = reader.readVarInt(true);
    for (int i = 0; i < numVariants; i++) {
        String variant = reader.readString();
        if(variant.equals(""))
            variant = null;

        readEdges(store.getEdgeCollection(layer, variant), nodeRefs);
    }
}

public static void decode(Input reader, String text, String key, int count,
                          int[] propertySetMapping,
                          IntArrayList psets,
                          Int2ReferenceOpenHashMap<? extends StoreRef> refs) {
    int id = Byte.toUnsignedInt(reader.readByte());
    StringCodecs.codecs[id].decode(reader, text, key, count, propertySetMapping, psets, refs);
}

@Override
public void decode(Input reader, String text, String key, int count, int[] propertySetMapping, IntArrayList psets, Int2ReferenceOpenHashMap<? extends StoreRef> refs) {
    IntListIterator noderange = psets.iterator();
    int k = 0;
    while (noderange.hasNext()) {
        int psetid = noderange.nextInt();
        final int start = propertySetMapping[psetid];
        final int end = propertySetMapping[psetid + 1];

        for (int i = start; i < end; i++, k++) {
            refs.get(i).get().putProperty(key, reader.readString());
        }
    }
}

public abstract void decode(Input reader,
String text,
String key,
int count,
int[] propertySetMapping,
IntArrayList psets,
Int2ReferenceOpenHashMap<? extends StoreRef> refs);

@Override
public void decode(Input reader, String text, String key, int count, int[] propertySetMapping, IntArrayList psets, Int2ReferenceOpenHashMap<? extends StoreRef> refs) {
    //int len = reader.readPosVarInt();

    IntListIterator noderange = psets.iterator();
    while (noderange.hasNext()) {
        int psetid = noderange.nextInt();
        final int start = propertySetMapping[psetid];
        final int end = propertySetMapping[psetid + 1];

        for (int i = start; i < end; i++) {
            refs.get(i).get().putProperty(key, reader.readString());
        }
    }
}

private void readEdges(Input reader, MemoryEdgeCollection store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    int edgeSize = reader.readInt();

    for(int i = 0; i < edgeSize; i++) {
        int head = reader.readInt();
        int tail = reader.readInt();

        MemoryEdge edge = store.create();

        edge.connect(nodeRefs.get(tail), nodeRefs.get(head));
        edge.properties = readProperties(reader);
    }
}

public void readNodeLayers(JsonNode node, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    Iterator<JsonNode> layerIter = node.elements();
    while(layerIter.hasNext()) {
        JsonNode layerNode = layerIter.next();
        String layer = layerNode.path("layer").asText();

        Iterator<JsonNode> variantsIter = layerNode.path("variants").elements();
        Iterator<JsonNode> nodesIter = layerNode.path("nodes").elements();
        while (variantsIter.hasNext() && nodesIter.hasNext()) {
            JsonNode nodes = nodesIter.next();
            String variant = variantsIter.next().asText();
            readNodes(nodes, store.getNodeCollection(layer, variant.length() == 0 ? null : variant), nodeRefs);
        }
    }
}

public void readEdgeLayers(JsonNode node, MemoryDocumentStore store, Int2ReferenceOpenHashMap<NodeRef> nodeRefs) {
    Iterator<JsonNode> layerIter = node.elements();
    while(layerIter.hasNext()) {
        JsonNode layerNode = layerIter.next();
        String layer = layerNode.path("layer").asText();

        Iterator<JsonNode> variantsIter = layerNode.path("variants").elements();
        Iterator<JsonNode> nodesIter = layerNode.path("edges").elements();
        while (variantsIter.hasNext() && nodesIter.hasNext()) {
            JsonNode nodes = nodesIter.next();
            String variant = variantsIter.next().asText();
            readEdges(nodes, store.getEdgeCollection(layer, variant.length() == 0 ? null : variant), nodeRefs);
        }
    }
}

@Test
public void whenIndexHavePreviousIndexedListsItShouldRemoveListFromIndexAsExpected() {
    final Int2ReferenceMap<IntList> expectedListsInvertedIndex = new Int2ReferenceOpenHashMap<IntList>() {{
        put(2, new IntArrayList(new int[] {2}));
        put(3, new IntArrayList(new int[] {0}));
        put(5, new IntArrayList(new int[] {0, 2}));
        put(9, new IntArrayList(new int[] {2}));
    }};
    final InvertedListIntReferenceListsIndex listsIndex = new InvertedListIntReferenceListsIndex() {{
        listsInvertedIndex.put(1, new IntArrayList(new int[] {1}));
        listsInvertedIndex.put(2, new IntArrayList(new int[] {2}));
        listsInvertedIndex.put(3, new IntArrayList(new int[] {0, 1}));
        listsInvertedIndex.put(4, new IntArrayList(new int[] {1}));
        listsInvertedIndex.put(5, new IntArrayList(new int[] {0, 1, 2}));
        listsInvertedIndex.put(8, new IntArrayList(new int[] {1}));
        listsInvertedIndex.put(9, new IntArrayList() {{ add(2); }});
    }};
    final int index = 1;
    final IntList list = new IntArrayList(new int[] {1, 3, 4, 5, 8});

    listsIndex.removeListFromListsInvertedIndex(index, list);

    assertEquals(
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(expectedListsInvertedIndex),
        Helper.<Integer, Int2ReferenceMap<IntList>>translateToUtilsCollection(listsIndex.listsInvertedIndex)
    );
}

public CalicoEventHandler()
    {
        eventListeners = new Int2ReferenceOpenHashMap<ArrayList<CalicoEventListener>>();
        globalListeners = new ArrayList<CalicoEventListener>();
        registerEvents();
//      System.out.println("Instanciated the Calico Event Handler Class!");
    }

public InvertedListIntReferenceListsIndex() {
    listsInvertedIndex = new Int2ReferenceOpenHashMap<IntList>();
    candidates = new IntOpenHashSet();
    outputOffset = new IntOutputOffset();
}

public CalicoEventHandler()
    {
        eventListeners = new Int2ReferenceOpenHashMap<ArrayList<CalicoEventListener>>();
        registerEvents();
//      System.out.println("Instanciated the Calico Event Handler Class!");
    }