private void process(OsmRelation relation) {
boolean hasChildRelations = false;
TLongList childRelationMembers = new TLongArrayList();
for (OsmRelationMember member : OsmModelUtil.membersAsList(relation)) {
if (member.getType() == EntityType.Relation) {
hasChildRelations = true;
idsIsChildRelation.add(member.getId());
childRelationMembers.add(member.getId());
if (storeSimpleRelations) {
idsSimpleRelations.remove(member.getId());
}
}
}
long id = relation.getId();
if (hasChildRelations) {
idsHasChildRelations.add(id);
if (!graph.getNodes().contains(id)) {
graph.addNode(id);
}
TLongIterator iterator = childRelationMembers.iterator();
while (iterator.hasNext()) {
long member = iterator.next();
if (!graph.getNodes().contains(member)) {
graph.addNode(member);
}
graph.addEdge(id, member);
}
} else {
if (storeSimpleRelations && !idsIsChildRelation.contains(id)) {
idsSimpleRelations.add(id);
}
numNoChildren++;
}
}
/**
* Compares this set with another set for equality of their stored entries.
*
* @param other an <code>Object</code> value
* @return true if the sets are identical
*/
@Override
public boolean equals(Object other) {
if (_set.equals(other)) {
return true; // comparing two trove sets
} else if (other instanceof Set) {
Set<?> that = (Set<?>) other;
if (that.size() != _set.size()) {
return false; // different sizes, no need to compare
} else { // now we have to do it the hard way
Iterator<?> it = that.iterator();
for (int i = that.size(); i-- > 0; ) {
Object val = it.next();
if (val instanceof Long) {
long v = ((Long) val).longValue();
if (_set.contains(v)) {
// match, ok to continue
} else {
return false; // no match: we're done
}
} else {
return false; // different type in other set
}
}
return true; // all entries match
}
} else {
return false;
}
}
private void extract(Path path) throws IOException {
Path pathWays = path.resolve(fileNamesWays);
Path pathNodeIds = path.resolve(fileNamesNodeIds);
InputStream input = StreamUtil.bufferedInputStream(pathWays.toFile());
OsmIterator osmIterator = OsmIoUtils.setupOsmIterator(input, inputFormat, false);
OutputStream outputNodeIds = StreamUtil.bufferedOutputStream(pathNodeIds.toFile());
IdListOutputStream idOutputNodeIds = new IdListOutputStream(outputNodeIds);
TLongSet nodeIdsSet = new TLongHashSet();
for (EntityContainer container : osmIterator) {
if (container.getType() != EntityType.Way) {
continue;
}
OsmWay way = (OsmWay) container.getEntity();
for (long id : OsmModelUtil.nodesAsList(way).toArray()) {
nodeIdsSet.add(id);
}
}
input.close();
long[] nodesIds = nodeIdsSet.toArray();
Arrays.sort(nodesIds);
for (long id : nodesIds) {
idOutputNodeIds.write(id);
}
idOutputNodeIds.close();
}
public List<Group> buildGroupsUndirected() {
List<Group> groups = new LinkedList<>();
TLongSet nodes = new TLongHashSet(graph.getNodes());
while (!nodes.isEmpty()) {
long id = any(nodes);
TLongSet reachable = reachable(graph, id);
nodes.removeAll(reachable);
groups.add(new Group(id, reachable));
}
return groups;
}
private void test(Data data) throws Exception {
Random r = getRandom();
final int numDocs = 1000 + r.nextInt(19000);
final List<TLongSet> values = new ArrayList<TLongSet>(numDocs);
for (int i = 0; i < numDocs; ++i) {
final int numValues = data.numValues(r);
final TLongSet vals = new TLongHashSet(numValues);
for (int j = 0; j < numValues; ++j) {
vals.add(data.nextValue(r));
}
values.add(vals);
}
test(values);
}
private void test(List<TLongSet> values) throws Exception {
StringField id = new StringField("_id", "", Field.Store.NO);
for (int i = 0; i < values.size(); ++i) {
Document doc = new Document();
id.setStringValue("" + i);
doc.add(id);
final TLongSet v = values.get(i);
for (TLongIterator it = v.iterator(); it.hasNext(); ) {
LongField value = new LongField("value", it.next(), Field.Store.NO);
doc.add(value);
}
writer.addDocument(doc);
}
writer.forceMerge(1);
final IndexNumericFieldData indexFieldData = getForField("value");
final AtomicNumericFieldData atomicFieldData = indexFieldData.load(refreshReader());
final LongValues data = atomicFieldData.getLongValues();
final DoubleValues doubleData = atomicFieldData.getDoubleValues();
final TLongSet set = new TLongHashSet();
final TDoubleSet doubleSet = new TDoubleHashSet();
for (int i = 0; i < values.size(); ++i) {
final TLongSet v = values.get(i);
assertThat(data.hasValue(i), equalTo(!v.isEmpty()));
assertThat(doubleData.hasValue(i), equalTo(!v.isEmpty()));
if (v.isEmpty()) {
assertThat(data.getValue(i), equalTo(0L));
assertThat(doubleData.getValue(i), equalTo(0d));
}
set.clear();
for (LongValues.Iter iter = data.getIter(i); iter.hasNext(); ) {
set.add(iter.next());
}
assertThat(set, equalTo(v));
final TDoubleSet doubleV = new TDoubleHashSet();
for (TLongIterator it = v.iterator(); it.hasNext(); ) {
doubleV.add((double) it.next());
}
doubleSet.clear();
for (DoubleValues.Iter iter = doubleData.getIter(i); iter.hasNext(); ) {
doubleSet.add(iter.next());
}
assertThat(doubleSet, equalTo(doubleV));
}
}
@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;
}
private Group build(long start) {
TLongSet group = new TLongHashSet();
group.add(start);
TLongSet left = new TLongHashSet();
left.addAll(graph.getEdgesOut(start));
while (!left.isEmpty()) {
long next = any(left);
if (group.contains(next)) {
continue;
}
group.add(next);
Set<Long> out = graph.getEdgesOut(next);
left.addAll(out);
}
return new Group(start, group);
}
private TLongSet reachable(Graph<Long> graph, long id) {
TLongSet reached = new TLongHashSet();
TLongSet queue = new TLongHashSet();
queue.add(id);
while (!queue.isEmpty()) {
long current = any(queue);
reached.add(current);
Set<Long> out = graph.getEdgesOut(current);
for (long next : out) {
if (!reached.contains(next)) {
queue.add(next);
}
}
}
return reached;
}
/**
* Inserts a value into the set.
*
* @param value true if the set was modified by the insertion
*/
@Override
public boolean add(Long value) {
return value != null && _set.add(value.longValue());
}
@Override
public void onBindViewHolder(CommentView view, int position) {
CommentEntry entry = comments.get(position);
Comment comment = entry.comment;
view.setCommentDepth(entry.depth);
view.senderInfo.setSenderName(comment.getName(), comment.getMark());
view.senderInfo.setOnSenderClickedListener(v -> doOnAuthorClicked(comment));
AndroidUtility.linkify(view.comment, comment.getContent());
// show the points
if (equalsIgnoreCase(comment.getName(), selfName)
|| comment.getCreated().isBefore(scoreVisibleThreshold)) {
view.senderInfo.setPoints(getCommentScore(entry));
} else {
view.senderInfo.setPointsUnknown();
}
// and the date of the post
view.senderInfo.setDate(comment.getCreated());
// enable or disable the badge
boolean badge = op.transform(op -> op.equalsIgnoreCase(comment.getName())).or(false);
view.senderInfo.setBadgeOpVisible(badge);
// and register a vote handler
view.vote.setVote(entry.vote, true);
view.vote.setOnVoteListener(
v -> {
boolean changed = doVote(entry, v);
notifyItemChanged(position);
return changed;
});
// set alpha for the sub views. sadly, setting alpha on view.itemView is not working
view.comment.setAlpha(entry.vote == Vote.DOWN ? 0.5f : 1f);
view.senderInfo.setAlpha(entry.vote == Vote.DOWN ? 0.5f : 1f);
view.senderInfo.setOnAnswerClickedListener(v -> doAnswer(comment));
Context context = view.itemView.getContext();
view.itemView.setBackgroundColor(
ContextCompat.getColor(
context,
comment.getId() == selectedCommentId
? R.color.selected_comment_background
: R.color.feed_background));
if (view.kFav != null) {
if (showFavCommentButton) {
boolean isFavorite = favedComments.contains(comment.getId());
view.kFav.setTextColor(
isFavorite
? ContextCompat.getColor(context, R.color.primary)
: ContextCompat.getColor(context, R.color.grey_700));
view.kFav.setVisibility(View.VISIBLE);
view.kFav.setOnClickListener(
v -> {
commentActionListener.onCommentMarkAsFavoriteClicked(comment, !isFavorite);
});
} else {
view.kFav.setVisibility(View.GONE);
}
}
}
public boolean isEmpty() {
return set.isEmpty();
}
public long pop() {
long value = stack.pop();
set.remove(value);
return value;
}
public boolean contains(long value) {
return set.contains(value);
}
/** It is not allowed to push values that are already contained in the set. */
public void push(long value) {
set.add(value);
stack.push(value);
}
private long any(TLongSet nodes) {
TLongIterator iterator = nodes.iterator();
long id = iterator.next();
iterator.remove();
return id;
}
public List<Group> buildGroupsDirected() {
List<Group> groups = new LinkedList<>();
// First determine 'start' relations, i.e. relations without incoming
// edges in the relation graph
TLongSet starts = new TLongHashSet();
Collection<Long> ids = graph.getNodes();
for (long id : ids) {
if (graph.getEdgesIn(id).isEmpty()) {
starts.add(id);
}
}
// Build sub-graphs reachable from 'start' relations
logger.debug("Number of start relations: " + starts.size());
for (long start : starts.toArray()) {
groups.add(build(start));
}
// In case of circles within the relation graph that are not reachable
// from any start relation, there may be some relations left, that have
// not been put into groups yet.
TLongSet remaining = new TLongHashSet();
remaining.addAll(ids);
for (Group group : groups) {
remaining.removeAll(group.getRelationIds());
}
if (remaining.size() > 0) {
logger.debug("remaining: " + remaining.size());
while (!remaining.isEmpty()) {
long id = any(remaining);
TLongSet reachable = reachable(graph, id);
remaining.removeAll(reachable);
long lowest = IdUtil.lowestId(reachable);
groups.add(new Group(lowest, reachable));
}
}
return groups;
}
/**
* Deletes a value from the set.
*
* @param value an <code>Object</code> value
* @return true if the set was modified
*/
@Override
public boolean remove(Object value) {
return value instanceof Long && _set.remove(((Long) value).longValue());
}
/** {@inheritDoc} */
@Override
public boolean contains(Object o) {
if (!(o instanceof Long)) return false;
return _set.contains(((Long) o).longValue());
}
@Override
public long[] getPriorStepExecutionIds() {
return priorStepExecutionIds.toArray();
}