Java TLongSet类代码示例

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/**
 * Return the number of unsupported blocks connected to any blocks neighboring the given location,
 * which is assumed to contain an air block. The search may bail out early when the count is greater
 * or equal to the given limit, though this cannot be guaranteed.
 */
private int countUnsupportedNeighbors(long pos, int limit) {
    TLongSet supported = new TLongHashSet();
    TLongSet unsupported = new TLongHashSet();

    try {
        for(BlockFace face : NEIGHBORS) {
            if(!this.isSupported(neighborPos(pos, face), supported, unsupported)) {
                if(unsupported.size() >= limit) break;
            }
        }
    }
    catch(MaxSearchVisitsExceeded ex) {
        this.logError(ex);
    }

    return unsupported.size();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/** {@inheritDoc) */
public boolean equals( Object other ) {
    if (! ( other instanceof TLongSet ) ) {
        return false;
    }
    final TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = _states.length; i-- > 0; ) {
        if ( _states[i] == FULL ) {
            if ( ! that.contains( _set[i] ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/** {@inheritDoc} */
public boolean equals( Object other ) {
    if ( ! ( other instanceof TLongSet ) ) {
        return false;
    }
    TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = _states.length; i-- > 0; ) {
        if ( _states[i] == FULL ) {
            if ( ! that.contains( _set[i] ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Override
public void calculateAllReduceFactors(final TLongObjectMap<TLongArrayList> nodeSegmentTable,
                                      final TLongObjectMap<ISegment> segmentsTable,
                                      final TLongSet relevantLinks,
                                      TLongObjectMap<IPixelCut> pixelCuts) {
	TLongObjectMap<IRenderingSegment> renderingResults = new TLongObjectHashMap<>();
	nodeSegmentTable.forEachEntry((nodeId, segmentIds) -> {
        if (segmentIds.size() > 1) {
            ISegment[] segments = new ISegment[segmentIds.size()];
            for (int i = 0; i < segmentIds.size(); i++) {
                segments[i] = segmentsTable.get(segmentIds.get(i));
            }
            investigateNode(nodeId, renderingResults, segments);
        }
        return true;
    });
    adaptPixelCuts(pixelCuts, renderingResults);
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Override
public void update(JSONObject json) {
    position = json.optInt("position");
    if(overwrites == null) overwrites = new TLongObjectHashMap<>();
    TLongSet toRemove = new TLongHashSet(overwrites.keys());
    JSONArray array = json.getJSONArray("permission_overwrites");
    for(int i = 0, j = array.length(); i < j; i++) {
        JSONObject overwrite = array.getJSONObject(i);
        long id = overwrite.getLong("id");
        toRemove.remove(id);
        overwrites.put(id, new CachedOverwrite(overwrite));
    }
    for(TLongIterator it = toRemove.iterator(); it.hasNext();) {
        overwrites.remove(it.next());
    }
    name = json.optString("name");
    topic = json.optString("topic");
    nsfw = json.optBoolean("nsfw");
    lastMessageId = json.optLong("last_message_id");
    bitrate = json.optInt("bitrate");
    userLimit = json.optInt("user_limit");
    parentId = json.optLong("parent_id");
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
public boolean equals( Object other ) {
    if (! ( other instanceof TLongSet ) ) {
        return false;
    }
    final TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = _states.length; i-- > 0; ) {
        if ( _states[i] == FULL ) {
            if ( ! that.contains( _set[i] ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Override
public Array<T> distinct(int limit) {
    final int capacity = limit < Integer.MAX_VALUE ? limit : 100;
    final TLongSet set = new TLongHashSet(capacity);
    final ArrayBuilder<T> builder = ArrayBuilder.of(capacity, type());
    for (int i=0; i<length(); ++i) {
        final long code = getLong(i);
        if (set.add(code)) {
            final T value = getValue(i);
            builder.add(value);
            if (set.size() >= limit) {
                break;
            }
        }
    }
    return builder.toArray();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Override
public final Array<Long> distinct(int limit) {
    final int capacity = limit < Integer.MAX_VALUE ? limit : 100;
    final TLongSet set = new TLongHashSet(capacity);
    final ArrayBuilder<Long> builder = ArrayBuilder.of(capacity, Long.class);
    for (int i=0; i<length(); ++i) {
        final long value = getLong(i);
        if (set.add(value)) {
            builder.addLong(value);
            if (set.size() >= limit) {
                break;
            }
        }
    }
    return builder.toArray();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
public Trivia(TextChannel channel, TLongSet players, OpenTriviaDatabase.Question question) {
    super(channel, players, question.correctAnswer, (question.incorrectAnswers.size() + 1) / 2);

    List<String> options = new ArrayList<>(question.incorrectAnswers);
    options.add(question.correctAnswer);

    int triesLeft = options.size()/2;

    totalOptions = options.size();
    correctOptionIndex = options.indexOf(question.correctAnswer);

    Collections.shuffle(options);

    int[] idx = {1};
    channel.sendMessage(new EmbedBuilder()
            .setDescription("**" + question.question + "**")
            .addField("Options", options.stream().map(o->idx[0]++ + " - " + o).collect(Collectors.joining("**\n**", "**", "**")), false)
            .addField("Difficulty", question.difficulty, true)
            .addField("Category", question.category, true)
            .setFooter(triesLeft + " tries left | Answer with the option number", null)
            .build()
    ).queue();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Command(
        name = "trivia",
        description = "Play trivia",
        usage = "`>>trivia`: Play trivia",
        permission = CommandPermission.USER,
        category = CommandCategory.GAME
)
public static void trivia(@Argument("channel") TextChannel channel, @Argument("author") User author) {
    if(check(channel)) return;
    OpenTriviaDatabase.Question q = OpenTriviaDatabase.random();
    if(q == null) {
        channel.sendMessage("Error getting a question from open trivia database").queue();
        return;
    }
    TLongSet players = new TLongHashSet();
    players.add(author.getIdLong());
    EventManagerThread.current().newThread(()->{
        try {
            Thread.sleep(100);
        } catch(InterruptedException e) {
            return;
        }
        InteractiveOperations.create(channel.getIdLong(), 120, new Trivia(channel, players, q));
    }, "Game Starter").start();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
@Command(
        name = "pokemonguess",
        description = "Guess which pokemon it is",
        usage = "`>>pokemonguess`: Play pokemon guess solo\n" +
                "`>>pokemonguess @Someone @SomeoneElse ...`: Play pokemon guess with your friends (if you have any)",
        permission = CommandPermission.USER,
        category = CommandCategory.GAME
)
public static void pokemonguess(@Argument("channel") TextChannel channel, @Argument("author") User author, @Argument("message") Message message) {
    if(check(channel)) return;
    TLongSet players = new TLongHashSet();
    players.add(author.getIdLong());
    for(User u : message.getMentionedUsers()) players.add(u.getIdLong());
    EventManagerThread.current().newThread(()->{
        try {
            Thread.sleep(100);
        } catch(InterruptedException e) {
            return;
        }
        InteractiveOperations.create(channel.getIdLong(), 120, new Pokemon(channel, players));
    }, "Game Starter").start();
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/** {@inheritDoc) */
@Override
public boolean equals( Object other ) {
    if (! ( other instanceof TLongSet ) ) {
        return false;
    }
    final TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = _states.length; i-- > 0; ) {
        if ( _states[i] == FULL ) {
            if ( ! that.contains( _set[i] ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean equals( Object other ) {
    if ( ! ( other instanceof TLongSet ) ) {
        return false;
    }
    TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = _states.length; i-- > 0; ) {
        if ( _states[i] == FULL ) {
            if ( ! that.contains( _set[i] ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public boolean equals( Object other ) {
    if ( ! ( other instanceof TLongSet ) ) {
        return false;
    }
    TLongSet that = ( TLongSet ) other;
    if ( that.size() != this.size() ) {
        return false;
    }
    for ( int i = capacity(); i-- > 0; ) {
        if ( _states.get(i) == FULL ) {
            if ( ! that.contains( _set.get( i ) ) ) {
                return false;
            }
        }
    }
    return true;
}
 

import gnu.trove.set.TLongSet; //导入依赖的package包/类
/**
 * Return whether this ring has intersections in terms of node ids appearing
 * multiple times.
 */
public boolean hasNodeIntersections() {
    int size = this.nodeIds.size();
    // Keep a set of already encountered ids
    TLongSet before = new TLongHashSet();
    // The first id can't be there already because the set is empty
    before.add(this.nodeIds.get(0));
    // Check all nodes except the last one which gets special care
    for (int i = 1; i < size - 1; i++) {
        long id = this.nodeIds.get(i);
        // Is it already on the set -> there is an intersection
        if (before.contains(id)) {
            return true;
        }
        // Add to the set of encountered ids
        before.add(id);
    }
    // If this ring is closed, the last node intersects the first one, but
    // that is okay
    if (this.isClosed()) {
        return false;
    }
    // If the ring is not closed, the last node might be an intersection
    // with one of the others
    return before.contains(this.nodeIds.get(size - 1));
}