/* ********************************************************************** **
** Copyright notice **
** **
** (c) 2005-2009 RSSOwl Development Team **
** http://www.rssowl.org/ **
** **
** All rights reserved **
** **
** This program and the accompanying materials are made available under **
** the terms of the Eclipse Public License v1.0 which accompanies this **
** distribution, and is available at: **
** http://www.rssowl.org/legal/epl-v10.html **
** **
** A copy is found in the file epl-v10.html and important notices to the **
** license from the team is found in the textfile LICENSE.txt distributed **
** in this package. **
** **
** This copyright notice MUST APPEAR in all copies of the file! **
** **
** Contributors: **
** RSSOwl Development Team - initial API and implementation **
** **
** ********************************************************************** */
package org.rssowl.ui.internal.editors.feed;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.rssowl.core.persist.IBookMark;
import org.rssowl.core.persist.ICategory;
import org.rssowl.core.persist.ILabel;
import org.rssowl.core.persist.INews;
import org.rssowl.core.persist.INews.State;
import org.rssowl.core.persist.INewsBin;
import org.rssowl.core.persist.IPerson;
import org.rssowl.core.persist.event.NewsEvent;
import org.rssowl.core.persist.reference.NewsBinReference;
import org.rssowl.core.util.CoreUtils;
import org.rssowl.core.util.DateUtils;
import org.rssowl.ui.internal.EntityGroup;
import org.rssowl.ui.internal.editors.feed.NewsGrouping.Group;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Sorts the elements of the feed view based on the choices provided by the
* user.
*
* @author Ismael Juma (ismael@juma.me.uk)
* @author bpasero
*/
public class NewsComparator extends ViewerComparator implements Comparator<INews> {
private NewsColumn fSortBy;
private boolean fAscending;
/* A cache for the Location Column */
private Map<Long, String> fMapBinIdToLocation = new HashMap<Long, String>();
private Map<String, String> fMapFeedLinkToLocation = new HashMap<String, String>();
/**
* @return Returns the ascending.
*/
public boolean isAscending() {
return fAscending;
}
/**
* @param ascending The ascending to set.
*/
public void setAscending(boolean ascending) {
fAscending = ascending;
}
/**
* @return Returns the sortBy.
*/
public NewsColumn getSortBy() {
return fSortBy;
}
/**
* @param sortBy The sortBy to set.
*/
public void setSortBy(NewsColumn sortBy) {
fSortBy = sortBy;
}
/**
* @param events the {@link Set} of NewsEvents that occured.
* @return <code>true</code> if the sorter requires a refresh and
* <code>false</code> otherwise
*/
public boolean needsRefresh(Collection<NewsEvent> events) {
if (fSortBy != null) {
switch (fSortBy) {
case AUTHOR:
return CoreUtils.isAuthorChange(events);
case CATEGORY:
return CoreUtils.isCategoryChange(events);
case DATE:
return CoreUtils.isDateChange(events);
case MODIFIED:
return CoreUtils.isModifiedDateChange(events);
case PUBLISHED:
return CoreUtils.isPublishedDateChange(events);
case TITLE:
return CoreUtils.isTitleChange(events);
}
}
return false; //We ignore some fields intentionally (e.g. state, sticky) to avoid refresh from user interaction
}
/*
* @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer,
* java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
/* Compare Entity Groups */
if (e1 instanceof EntityGroup && e2 instanceof EntityGroup)
return compare((EntityGroup) e1, (EntityGroup) e2);
/* Compare News */
if (e1 instanceof INews && e2 instanceof INews)
return compare((INews) e1, (INews) e2);
return 0;
}
private int compare(EntityGroup e1, @SuppressWarnings("unused") EntityGroup e2) {
/* Support sorting Entity Groups of type DATE */
if (fSortBy != null && (fSortBy == NewsColumn.DATE || fSortBy == NewsColumn.PUBLISHED || fSortBy == NewsColumn.MODIFIED || fSortBy == NewsColumn.RECEIVED) && fAscending) {
long id = e1.getId();
if (id == Group.TODAY.ordinal() || id == Group.YESTERDAY.ordinal() || id == Group.EARLIER_THIS_WEEK.ordinal() || id == Group.LAST_WEEK.ordinal() || id == Group.OLDER.ordinal())
return fAscending ? 1 : -1;
}
return 0;
}
/*
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
public int compare(INews news1, INews news2) {
int result = 0;
if (fSortBy != null) {
switch (fSortBy) {
/* Sort by Date */
case DATE:
return compareByDate(news1, news2, false);
/* Sort by Publish Date */
case PUBLISHED:
return compareByDate(news1.getPublishDate(), news2.getPublishDate(), false);
/* Sort by Modified Date */
case MODIFIED:
return compareByDate(news1.getModifiedDate(), news2.getModifiedDate(), false);
/* Sort by Received Date */
case RECEIVED:
return compareByDate(news1.getReceiveDate(), news2.getReceiveDate(), false);
/* Sort by Title */
case TITLE:
result = compareByTitle(CoreUtils.getHeadline(news1, true), CoreUtils.getHeadline(news2, true));
break;
/* Sort by Author */
case AUTHOR:
result = compareByAuthor(news1.getAuthor(), news2.getAuthor());
break;
/* Sort by Category */
case CATEGORY:
result = compareByCategory(news1.getCategories(), news2.getCategories());
break;
/* Sort by Stickyness */
case STICKY:
result = compareByStickyness(news1.isFlagged(), news2.isFlagged());
break;
/* Sort by Feed */
case FEED:
result = compareByFeed(news1.getFeedLinkAsText(), news2.getFeedLinkAsText());
break;
/* Sort by "Has Attachments" */
case ATTACHMENTS:
result = compareByHasAttachments(!news1.getAttachments().isEmpty(), !news2.getAttachments().isEmpty());
break;
/* Sort by Labels */
case LABELS:
result = compareByLabels(CoreUtils.getSortedLabels(news1), CoreUtils.getSortedLabels(news2));
break;
/* Sort by Status */
case STATUS:
result = compareByStatus(news1.getState(), news2.getState());
break;
/* Sort by Location */
case LOCATION:
result = compareByLocation(news1, news2);
break;
/* Sort by Link */
case LINK:
result = compareByLink(news1, news2);
break;
}
}
/* Fall Back to default sort if result is 0 */
if (result == 0)
result = compareByDate(news1, news2, true);
return result;
}
private int compareByFeed(String feedLink1, String feedLink2) {
int result = feedLink1.compareTo(feedLink2);
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByDate(INews news1, INews news2, boolean forceDescending) {
Date date1 = DateUtils.getRecentDate(news1);
Date date2 = DateUtils.getRecentDate(news2);
return compareByDate(date1, date2, forceDescending);
}
private int compareByDate(Date date1, Date date2, boolean forceDescending) {
if (date1 == null)
return fAscending && !forceDescending ? -1 : 1;
if (date2 == null)
return fAscending && !forceDescending ? 1 : -1;
int result = date1.compareTo(date2);
/* Respect ascending / descending Order */
return fAscending && !forceDescending ? result : result * -1;
}
private int compareByTitle(String title1, String title2) {
int result = compareByString(title1, title2);
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByStatus(INews.State s1, INews.State s2) {
int result = 0;
if (s1 != s2) {
if (s1 == State.NEW)
result = -1;
else if (s2 == State.NEW)
result = 1;
else if (s1 == State.UPDATED)
result = -1;
else if (s2 == State.UPDATED)
result = 1;
else if (s1 == State.UNREAD)
result = -1;
else if (s2 == State.UNREAD)
result = 1;
else
result = s1.compareTo(s2);
}
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByLocation(INews n1, INews n2) {
int result = compareByString(getLocation(n1), getLocation(n2));
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByLink(INews n1, INews n2) {
int result = compareByString(CoreUtils.getLink(n1), CoreUtils.getLink(n2));
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private String getLocation(INews news) {
/* Location: Bin */
if (news.getParentId() > 0) {
String location = fMapBinIdToLocation.get(news.getParentId());
if (location == null) {
NewsBinReference ref = new NewsBinReference(news.getParentId());
INewsBin bin = ref.resolve();
location = bin.getName();
fMapBinIdToLocation.put(news.getParentId(), location);
}
return location;
}
/* Location: Bookmark */
String location = fMapFeedLinkToLocation.get(news.getFeedLinkAsText());
if (location == null) {
IBookMark bookmark = CoreUtils.getBookMark(news.getFeedLinkAsText());
if (bookmark != null) {
location = bookmark.getName();
fMapFeedLinkToLocation.put(news.getFeedLinkAsText(), location);
}
}
return location;
}
private int compareByHasAttachments(boolean hasAttachments1, boolean hasAttachments2) {
int result = 0;
if (hasAttachments1 && !hasAttachments2)
result = 1;
else if (!hasAttachments1 && hasAttachments2)
result = -1;
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByLabels(Set<ILabel> labels1, Set<ILabel> labels2) {
/* Detect cases of empty Labels first */
if (labels1.isEmpty() && labels2.isEmpty())
return 0;
else if (labels1.isEmpty())
return fAscending ? 1 : -1;
else if (labels2.isEmpty())
return fAscending ? -1 : 1;
/* Now compare all labels as there can be more than one assigned */
int result = 0;
Iterator<ILabel> labels1Iterator = labels1.iterator();
Iterator<ILabel> labels2Iterator = labels2.iterator();
while (labels1Iterator.hasNext() && labels2Iterator.hasNext()) {
ILabel label1 = labels1Iterator.next();
ILabel label2 = labels2Iterator.next();
/* Labels identical at this point */
if (label1.getOrder() == label2.getOrder()) {
/* Look for the next label to compare if still labels present */
if (labels1Iterator.hasNext() && labels2Iterator.hasNext())
continue;
/* Sort news with more labels below */
if (labels1Iterator.hasNext())
result = -1;
/* Otherwise keep label above */
else
result = 1;
break;
}
/* Labels not identical - compare order and break */
result = label1.getOrder() < label2.getOrder() ? -1 : 1;
break;
}
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByAuthor(IPerson author1, IPerson author2) {
int result = 0;
if (author1 != null && author2 != null) {
String value1 = author1.getName();
if (value1 == null && author1.getEmail() != null)
value1 = author1.getEmail().toString();
else if (value1 == null && author1.getUri() != null)
value1 = author1.getUri().toString();
String value2 = author2.getName();
if (value2 == null && author2.getEmail() != null)
value2 = author2.getEmail().toString();
else if (value2 == null && author2.getUri() != null)
value2 = author2.getUri().toString();
result = compareByString(value1, value2);
}
else if (author1 != null)
result = -1;
else if (author2 != null)
result = 1;
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByCategory(List<ICategory> categories1, List<ICategory> categories2) {
int result = 0;
if (categories1 != null && categories1.size() > 0 && categories2 != null && categories2.size() > 0) {
ICategory category1 = categories1.get(0);
ICategory category2 = categories2.get(0);
String value1 = category1.getName();
if (value1 == null)
value1 = category1.getDomain();
String value2 = category2.getName();
if (value2 == null)
value2 = category2.getName();
result = compareByString(value1, value2);
}
else if (categories1 != null && categories1.size() > 0)
result = -1;
else if (categories2 != null && categories2.size() > 0)
result = 1;
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByStickyness(boolean sticky1, boolean sticky2) {
int result = 0;
if (sticky1 && !sticky2)
result = 1;
else if (!sticky1 && sticky2)
result = -1;
/* Respect ascending / descending Order */
return fAscending ? result : result * -1;
}
private int compareByString(String str1, String str2) {
if (str1 != null && str2 != null)
return str1.compareToIgnoreCase(str2);
else if (str1 != null)
return -1;
return 1;
}
}