@Override
public void addPrimitive(long value) {
if (!buf.hasRemaining()) {
buf = list.addBlock().asLongBuffer();
}
buf.put(value);
list.incSize();
}
/**
* Returns a new list of the part of the receiver between <code>from</code>, inclusive, and <code>
* to</code>, inclusive.
*
* @param from the index of the first element (inclusive).
* @param to the index of the last element (inclusive).
* @return a new list
* @exception IndexOutOfBoundsException index is out of range (<tt>size()>0 && (from<0 ||
* from>to || to>=size())</tt>).
*/
public AbstractLongList partFromTo(int from, int to) {
checkRangeFromTo(from, to, size);
int length = to - from + 1;
LongArrayList part = new LongArrayList(length);
part.addAllOfFromTo(this, from, to);
return part;
}
public List<NewsReference> getNews(Set<INews.State> states) {
List<NewsReference> newsRefs = new ArrayList<NewsReference>(getNewsCount(states));
for (INews.State state : states) {
int index = state.ordinal();
LongArrayList newsIds = fNewsIds[index];
for (int i = 0, c = newsIds.size(); i < c; ++i) {
long newsId = newsIds.get(i);
Assert.isLegal(newsId != 0);
newsRefs.add(new NewsReference(newsId));
}
}
return newsRefs;
}
/**
* Get the keys of this vector sorted by the value of the items stored for each key.
*
* @param decreasing If {@code true}, sort in decreasing order.
* @return The sorted list of keys of this vector.
*/
public LongArrayList keysByValue(boolean decreasing) {
long[] skeys = keySet().toLongArray();
LongComparator cmp;
// Set up the comparator. We use the key as a secondary comparison to get
// a reproducible sort irrespective of sorting algorithm.
if (decreasing) {
cmp =
new AbstractLongComparator() {
@Override
public int compare(long k1, long k2) {
int c = Double.compare(get(k2), get(k1));
if (c != 0) {
return c;
} else {
return Longs.compare(k1, k2);
}
}
};
} else {
cmp =
new AbstractLongComparator() {
@Override
public int compare(long k1, long k2) {
int c = Double.compare(get(k1), get(k2));
if (c != 0) {
return c;
} else {
return Longs.compare(k1, k2);
}
}
};
}
LongArrays.quickSort(skeys, cmp);
return LongArrayList.wrap(skeys);
}
LongArrayListWriter(LongArrayList list) {
this.list = list;
buf = list.addBlock().asLongBuffer();
}
public Pair<Boolean, Boolean> setNews(Map<INews.State, List<NewsReference>> newsMap) {
Assert.isNotNull(newsMap, "newsMap"); // $NON-NLS-1$
boolean changed = false;
boolean isNewNewsAdded = false;
Set<INews.State> statesToReset = EnumSet.allOf(INews.State.class);
statesToReset.removeAll(newsMap.keySet());
/* Reset all ArrayLists whose state is not present in newsMap */
for (INews.State state : statesToReset) {
int index = state.ordinal();
LongArrayList currentArrayList = fNewsIds[index];
if (currentArrayList.size() > 0) {
currentArrayList.clear();
changed = true;
}
}
/* For each Result */
for (Map.Entry<INews.State, List<NewsReference>> mapEntry : newsMap.entrySet()) {
List<NewsReference> news = mapEntry.getValue();
INews.State state = mapEntry.getKey();
Assert.isNotNull(news, "news"); // $NON-NLS-1$
Assert.isNotNull(state, "state"); // $NON-NLS-1$
long[] newArray = new long[news.size()];
/* Fill Bucket */
for (int i = 0; i < news.size(); i++) {
newArray[i] = news.get(i).getId();
}
int index = state.ordinal();
LongArrayList currentArrayList = fNewsIds[index];
if (state.equals(INews.State.NEW)) {
/* Check for added *new* News */
if (newArray.length > currentArrayList.size()) isNewNewsAdded = true;
else {
for (long value : newArray) {
if (currentArrayList.indexOf(value) < 0) {
isNewNewsAdded = true;
break;
}
}
}
if (isNewNewsAdded || (newArray.length != currentArrayList.size())) {
changed = true;
currentArrayList.setAll(newArray);
}
} else {
if (!currentArrayList.elementsEqual(newArray)) {
currentArrayList.setAll(newArray);
changed = true;
}
}
}
return Pair.create(changed, isNewNewsAdded);
}
public void removeNewsRefs(List<NewsReference> newsRefs) {
for (LongArrayList list : fNewsIds) {
for (NewsReference newsRef : newsRefs) list.removeByElement(newsRef.getId());
}
}
