import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
void updateRowVisibility(LongSet nodeSuids) {
    if (session == null || nodeSuids == null || nodeSuids.isEmpty()) {
        setAllVisible();
        return;
    }
    if (filterDomainsCheckBox == null || !filterDomainsCheckBox.isSelected()) {
        setAllVisible();
        return;
    }

    Long[] nodeMappings = session.getNodeMappings();
    if (nodeMappings == null) {
        setAllVisible();
        return;
    }

    domainRows.stream()
              .forEach(row -> row.setVisible(row.hasSignificant(nodeSuids)));
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private void checkBlock(IDBlock block, LongSet ids) {
    assertEquals(blockSize,block.numIds());
    for (int i=0;i<blockSize;i++) {
        long id = block.getId(i);
        assertEquals(id,block.getId(i));
        assertFalse(ids.contains(id));
        assertTrue(id<idUpperBound);
        assertTrue(id>0);
        ids.add(id);
    }
    if (hasEmptyUid) {
        assertEquals(blockSize-1,block.getId(block.numIds()-1)-block.getId(0));
    }
    try {
        block.getId(blockSize);
        fail();
    } catch (ArrayIndexOutOfBoundsException e) {}
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Test
public void testSimpleIDAcquisition() throws BackendException {
    final IDBlockSizer blockSizer = new InnerIDBlockSizer();
    idAuthorities[0].setIDBlockSizer(blockSizer);
    int numTrials = 100;
    LongSet ids = new LongHashSet((int)blockSize*numTrials);
    long previous = 0;
    for (int i=0;i<numTrials;i++) {
        IDBlock block = idAuthorities[0].getIDBlock(0, 0, GET_ID_BLOCK_TIMEOUT);
        checkBlock(block,ids);
        if (hasEmptyUid) {
            if (previous!=0)
                assertEquals(previous+1, block.getId(0));
            previous=block.getId(block.numIds()-1);
        }
    }
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
public CombinedTerm(AbstractType<?> comparator, DataTerm term)
{
    this.comparator = comparator;
    this.term = term;
    this.tokens = new TreeMap<>();

    RangeIterator<Long, Token> tokens = term.getTokens();
    while (tokens.hasNext())
    {
        Token current = tokens.next();
        LongSet offsets = this.tokens.get(current.get());
        if (offsets == null)
            this.tokens.put(current.get(), (offsets = new LongOpenHashSet()));

        for (Long offset : ((TokenTree.OnDiskToken) current).getOffsets())
            offsets.add(offset);
    }
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private LeafEntry createEntry(final long tok, final LongSet offsets)
{
    int offsetCount = offsets.size();
    switch (offsetCount)
    {
        case 0:
            throw new AssertionError("no offsets for token " + tok);
        case 1:
            long offset = offsets.toArray()[0];
            if (offset > MAX_OFFSET)
                throw new AssertionError("offset " + offset + " cannot be greater than " + MAX_OFFSET);
            else if (offset <= Integer.MAX_VALUE)
                return new SimpleLeafEntry(tok, offset);
            else
                return new FactoredOffsetLeafEntry(tok, offset);
        case 2:
            long[] rawOffsets = offsets.toArray();
            if (rawOffsets[0] <= Integer.MAX_VALUE && rawOffsets[1] <= Integer.MAX_VALUE &&
                    (rawOffsets[0] <= Short.MAX_VALUE || rawOffsets[1] <= Short.MAX_VALUE))
                return new PackedCollisionLeafEntry(tok, rawOffsets);
            else
                return createOverflowEntry(tok, offsetCount, offsets);
        default:
            return createOverflowEntry(tok, offsetCount, offsets);
    }
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Override
public Pair<Long, LongSet> computeNext()
{
    if (currentIterator != null && currentIterator.hasNext())
    {
        Map.Entry<Long, LongSet> next = currentIterator.next();
        return Pair.create(next.getKey(), next.getValue());
    }
    else
    {
        if (!levelIterator.hasNext())
            return endOfData();
        else
        {
            currentIterator = ((Leaf) levelIterator.next()).tokenIterator();
            return computeNext();
        }
    }

}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Test
public void buildAndIterate() throws Exception
{
    final TokenTreeBuilder builder = new TokenTreeBuilder(tokens).finish();
    final Iterator<Pair<Long, LongSet>> tokenIterator = builder.iterator();
    final Iterator<Map.Entry<Long, LongSet>> listIterator = tokens.entrySet().iterator();
    while (tokenIterator.hasNext() && listIterator.hasNext())
    {
        Pair<Long, LongSet> tokenNext = tokenIterator.next();
        Map.Entry<Long, LongSet> listNext = listIterator.next();

        Assert.assertEquals(listNext.getKey(), tokenNext.left);
        Assert.assertEquals(listNext.getValue(), tokenNext.right);
    }

    Assert.assertFalse("token iterator not finished", tokenIterator.hasNext());
    Assert.assertFalse("list iterator not finished", listIterator.hasNext());
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Test
public void testSimpleIDAcquisition() throws BackendException {
    final IDBlockSizer blockSizer = new InnerIDBlockSizer();
    idAuthorities[0].setIDBlockSizer(blockSizer);
    int numTrials = 100;
    LongSet ids = new LongOpenHashSet((int)blockSize*numTrials);
    long previous = 0;
    for (int i=0;i<numTrials;i++) {
        IDBlock block = idAuthorities[0].getIDBlock(0, 0, GET_ID_BLOCK_TIMEOUT);
        checkBlock(block,ids);
        if (hasEmptyUid) {
            if (previous!=0)
                assertEquals(previous+1, block.getId(0));
            previous=block.getId(block.numIds()-1);
        }
    }
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Override
public void setupSuiteScopeCluster() throws Exception {
    assertAcked(client().admin().indices().prepareCreate("idx")
            .addMapping("type", "s", "type=keyword").get());

    cardinality = randomIntBetween(8, 30);
    final List<IndexRequestBuilder> indexRequests = new ArrayList<>();
    final Set<String> stringTerms = new HashSet<>();
    final LongSet longTerms = new LongHashSet();
    for (int i = 0; i < cardinality; ++i) {
        String stringTerm;
        do {
            stringTerm = RandomStrings.randomAsciiOfLength(random(), 8);
        } while (!stringTerms.add(stringTerm));
        long longTerm;
        do {
            longTerm = randomInt(cardinality * 2);
        } while (!longTerms.add(longTerm));
        double doubleTerm = longTerm * Math.PI;
        String dateTerm = DateTimeFormat.forPattern("yyyy-MM-dd")
                .print(new DateTime(2014, 1, ((int) longTerm % 20) + 1, 0, 0, DateTimeZone.UTC));
        final int frequency = randomBoolean() ? 1 : randomIntBetween(2, 20);
        for (int j = 0; j < frequency; ++j) {
            indexRequests.add(client().prepareIndex("idx", "type").setSource(jsonBuilder()
                    .startObject()
                    .field("s", stringTerm)
                    .field("l", longTerm)
                    .field("d", doubleTerm)
                    .field("date", dateTerm)
                    .field("match", randomBoolean())
                    .endObject()));
        }
    }
    cardinality = stringTerms.size();

    indexRandom(true, indexRequests);
    ensureSearchable();
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
void updateRowVisibility(LongSet nodeSuids) {
    if (session == null || nodeSuids == null || nodeSuids.isEmpty()) {
        setAllVisible();
        return;
    }
    if (filterAttributesCheckBox == null || !filterAttributesCheckBox.isSelected()) {
        setAllVisible();
        return;
    }

    Long[] nodeMappings = session.getNodeMappings();
    if (nodeMappings == null) {
        setAllVisible();
        return;
    }

    AnalysisMethod analysisMethod = session.getAnalysisMethod();

    Consumer<? super AttributeRow> action;
    if (analysisMethod == AnalysisMethod.HighestAndLowest) {
        action = row -> row.setVisible(row.hasHighest(nodeSuids) || row.hasLowest(nodeSuids));
    } else if (analysisMethod == AnalysisMethod.Highest) {
        action = row -> row.setVisible(row.hasHighest(nodeSuids));
    } else {
        action = row -> row.setVisible(row.hasLowest(nodeSuids));
    }

    attributes.stream()
              .forEach(action);
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void notifyNodeSelectionChangedListeners(LongSet nodeSuids) {
    List<NodeSelectionChangedListener> listeners = (List<NodeSelectionChangedListener>) listenersByClass.get(NodeSelectionChangedListener.class);
    listeners.stream()
             .forEach(l -> l.set(nodeSuids));
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
public static boolean hasIntersection(LongSet set1,
                                      LongSet set2) {
    Iterator<LongCursor> iterator = set1.iterator();
    while (iterator.hasNext()) {
        LongCursor cursor = iterator.next();
        if (set2.contains(cursor.value)) {
            return true;
        }
    }
    return false;
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
public void add(Long token, long keyPosition)
{
    LongSet found = tokens.get(token);
    if (found == null)
        tokens.put(token, (found = new LongOpenHashSet(2)));

    found.add(keyPosition);
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private void writeTerm(InMemoryTerm term, TokenTreeBuilder keys) throws IOException
{
    term.serialize(buffer);
    buffer.writeByte((byte) keys.getTokenCount());

    Iterator<Pair<Long, LongSet>> tokens = keys.iterator();
    while (tokens.hasNext())
        buffer.writeLong(tokens.next().left);
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private static Set<DecoratedKey> convert(TokenTreeBuilder offsets)
{
    Set<DecoratedKey> result = new HashSet<>();

    Iterator<Pair<Long, LongSet>> offsetIter = offsets.iterator();
    while (offsetIter.hasNext())
    {
        LongSet v = offsetIter.next().right;

        for (LongCursor offset : v)
            result.add(keyAt(offset.value));
    }
    return result;
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private static void addAll(OnDiskIndexBuilder builder, ByteBuffer term, TokenTreeBuilder tokens)
{
    for (Map.Entry<Long, LongSet> token : tokens.getTokens().entrySet())
    {
        for (long position : token.getValue().toArray())
            builder.add(term, keyAt(position), position);
    }
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Test
public void buildSerializeAndIterate() throws Exception
{
    final TokenTreeBuilder builder = new TokenTreeBuilder(simpleTokenMap).finish();

    final File treeFile = File.createTempFile("token-tree-iterate-test1", "tt");
    treeFile.deleteOnExit();

    final SequentialWriter writer = new SequentialWriter(treeFile, 4096, false);
    builder.write(writer);
    writer.close();

    final RandomAccessReader reader = RandomAccessReader.open(treeFile);
    final TokenTree tokenTree = new TokenTree(new MappedBuffer(reader));

    final Iterator<Token> tokenIterator = tokenTree.iterator(KEY_CONVERTER);
    final Iterator<Map.Entry<Long, LongSet>> listIterator = simpleTokenMap.entrySet().iterator();
    while (tokenIterator.hasNext() && listIterator.hasNext())
    {
        Token treeNext = tokenIterator.next();
        Map.Entry<Long, LongSet> listNext = listIterator.next();

        Assert.assertEquals(listNext.getKey(), treeNext.get());
        Assert.assertEquals(convert(listNext.getValue()), convert(treeNext));
    }

    Assert.assertFalse("token iterator not finished", tokenIterator.hasNext());
    Assert.assertFalse("list iterator not finished", listIterator.hasNext());

    reader.close();
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
@Override
public TokenWithOffsets computeNext()
{
    if (!elements.hasNext())
        return endOfData();

    Map.Entry<Long, LongSet> next = elements.next();
    return new TokenWithOffsets(next.getKey(), next.getValue());
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private static Set<DecoratedKey> convert(LongSet offsets)
{
    Set<DecoratedKey> keys = new HashSet<>();
    for (LongCursor offset : offsets)
        keys.add(KEY_CONVERTER.apply(offset.value));

    return keys;
}
 

import com.carrotsearch.hppc.LongSet; //导入依赖的package包/类
private static TokenTree generateTree(final long minToken, final long maxToken) throws IOException
{
    final SortedMap<Long, LongSet> toks = new TreeMap<Long, LongSet>()
    {{
            for (long i = minToken; i <= maxToken; i++)
            {
                LongSet offsetSet = new LongOpenHashSet();
                offsetSet.add(i);
                put(i, offsetSet);
            }
    }};

    final TokenTreeBuilder builder = new TokenTreeBuilder(toks).finish();
    final File treeFile = File.createTempFile("token-tree-get-test", "tt");
    treeFile.deleteOnExit();

    final SequentialWriter writer = new SequentialWriter(treeFile, 4096, false);
    builder.write(writer);
    writer.close();

    RandomAccessReader reader = null;

    try
    {
        reader = RandomAccessReader.open(treeFile);
        return new TokenTree(new MappedBuffer(reader));
    }
    finally
    {
        FileUtils.closeQuietly(reader);
    }
}