613 lines
18 KiB
Java
613 lines
18 KiB
Java
package net.osmand.search;
|
|
|
|
import net.osmand.Collator;
|
|
import net.osmand.OsmAndCollator;
|
|
import net.osmand.PlatformUtil;
|
|
import net.osmand.ResultMatcher;
|
|
import net.osmand.binary.BinaryMapIndexReader;
|
|
import net.osmand.data.Amenity;
|
|
import net.osmand.data.LatLon;
|
|
import net.osmand.osm.MapPoiTypes;
|
|
import net.osmand.search.core.CustomSearchPoiFilter;
|
|
import net.osmand.search.core.ObjectType;
|
|
import net.osmand.search.core.SearchCoreAPI;
|
|
import net.osmand.search.core.SearchCoreFactory;
|
|
import net.osmand.search.core.SearchCoreFactory.SearchAmenityTypesAPI;
|
|
import net.osmand.search.core.SearchCoreFactory.SearchBuildingAndIntersectionsByStreetAPI;
|
|
import net.osmand.search.core.SearchCoreFactory.SearchStreetByCityAPI;
|
|
import net.osmand.search.core.SearchPhrase;
|
|
import net.osmand.search.core.SearchPhrase.NameStringMatcher;
|
|
import net.osmand.search.core.SearchResult;
|
|
import net.osmand.search.core.SearchSettings;
|
|
import net.osmand.search.core.SearchWord;
|
|
import net.osmand.util.Algorithms;
|
|
import net.osmand.util.MapUtils;
|
|
|
|
import org.apache.commons.logging.Log;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.ListIterator;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.ThreadPoolExecutor;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
|
|
public class SearchUICore {
|
|
|
|
private static final int TIMEOUT_BETWEEN_CHARS = 700;
|
|
private static final int TIMEOUT_BEFORE_SEARCH = 50;
|
|
private static final Log LOG = PlatformUtil.getLog(SearchUICore.class);
|
|
private SearchPhrase phrase;
|
|
private SearchResultCollection currentSearchResult;
|
|
|
|
private ThreadPoolExecutor singleThreadedExecutor;
|
|
private LinkedBlockingQueue<Runnable> taskQueue;
|
|
private Runnable onSearchStart = null;
|
|
private Runnable onResultsComplete = null;
|
|
private AtomicInteger requestNumber = new AtomicInteger();
|
|
private int totalLimit = -1; // -1 unlimited - not used
|
|
|
|
List<SearchCoreAPI> apis = new ArrayList<>();
|
|
private SearchSettings searchSettings;
|
|
private MapPoiTypes poiTypes;
|
|
|
|
|
|
public SearchUICore(MapPoiTypes poiTypes, String locale, boolean transliterate) {
|
|
this.poiTypes = poiTypes;
|
|
taskQueue = new LinkedBlockingQueue<Runnable>();
|
|
searchSettings = new SearchSettings(new ArrayList<BinaryMapIndexReader>());
|
|
searchSettings = searchSettings.setLang(locale, transliterate);
|
|
phrase = new SearchPhrase(searchSettings, OsmAndCollator.primaryCollator());
|
|
currentSearchResult = new SearchResultCollection(phrase);
|
|
singleThreadedExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, taskQueue);
|
|
}
|
|
|
|
public static class SearchResultCollection {
|
|
private List<SearchResult> searchResults;
|
|
private SearchPhrase phrase;
|
|
private static final int DEPTH_TO_CHECK_SAME_SEARCH_RESULTS = 20;
|
|
|
|
public SearchResultCollection(SearchPhrase phrase) {
|
|
searchResults = new ArrayList<>();
|
|
this.phrase = phrase;
|
|
}
|
|
|
|
public SearchResultCollection combineWithCollection(SearchResultCollection collection, boolean resort, boolean removeDuplicates) {
|
|
SearchResultCollection src = new SearchResultCollection(phrase);
|
|
src.addSearchResults(searchResults, false, false);
|
|
src.addSearchResults(collection.searchResults, resort, removeDuplicates);
|
|
return src;
|
|
}
|
|
|
|
public SearchResultCollection addSearchResults(List<SearchResult> sr, boolean resortAll, boolean removeDuplicates) {
|
|
if (resortAll) {
|
|
this.searchResults.addAll(sr);
|
|
sortSearchResults();
|
|
if (removeDuplicates) {
|
|
filterSearchDuplicateResults();
|
|
}
|
|
} else {
|
|
if (!removeDuplicates) {
|
|
this.searchResults.addAll(sr);
|
|
} else {
|
|
ArrayList<SearchResult> addedResults = new ArrayList<>(sr);
|
|
SearchResultComparator cmp = new SearchResultComparator(phrase);
|
|
Collections.sort(addedResults, cmp);
|
|
filterSearchDuplicateResults(addedResults);
|
|
int i = 0;
|
|
int j = 0;
|
|
while (j < addedResults.size()) {
|
|
SearchResult addedResult = addedResults.get(j);
|
|
if (i >= searchResults.size()) {
|
|
int k = 0;
|
|
boolean same = false;
|
|
while (searchResults.size() > k && k < DEPTH_TO_CHECK_SAME_SEARCH_RESULTS) {
|
|
if (sameSearchResult(addedResult, searchResults.get(searchResults.size() - k - 1))) {
|
|
same = true;
|
|
break;
|
|
}
|
|
k++;
|
|
}
|
|
if (!same) {
|
|
searchResults.add(addedResult);
|
|
}
|
|
j++;
|
|
continue;
|
|
}
|
|
SearchResult existingResult = searchResults.get(i);
|
|
if (sameSearchResult(addedResult, existingResult)) {
|
|
j++;
|
|
continue;
|
|
}
|
|
int compare = cmp.compare(existingResult, addedResult);
|
|
if (compare == 0) {
|
|
// existingResult == addedResult
|
|
j++;
|
|
} else if (compare > 0) {
|
|
// existingResult > addedResult
|
|
this.searchResults.add(addedResults.get(j));
|
|
j++;
|
|
} else {
|
|
// existingResult < addedResult
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public List<SearchResult> getCurrentSearchResults() {
|
|
return Collections.unmodifiableList(searchResults);
|
|
}
|
|
|
|
public SearchPhrase getPhrase() {
|
|
return phrase;
|
|
}
|
|
|
|
public void sortSearchResults() {
|
|
Collections.sort(searchResults, new SearchResultComparator(phrase));
|
|
}
|
|
|
|
public void filterSearchDuplicateResults() {
|
|
filterSearchDuplicateResults(searchResults);
|
|
}
|
|
|
|
private void filterSearchDuplicateResults(List<SearchResult> lst) {
|
|
ListIterator<SearchResult> it = lst.listIterator();
|
|
LinkedList<SearchResult> lstUnique = new LinkedList<SearchResult>();
|
|
while (it.hasNext()) {
|
|
SearchResult r = it.next();
|
|
boolean same = false;
|
|
for (SearchResult rs : lstUnique) {
|
|
same = sameSearchResult(rs, r);
|
|
if (same) {
|
|
break;
|
|
}
|
|
}
|
|
if (same) {
|
|
it.remove();
|
|
} else {
|
|
lstUnique.add(r);
|
|
if (lstUnique.size() > DEPTH_TO_CHECK_SAME_SEARCH_RESULTS) {
|
|
lstUnique.remove(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean sameSearchResult(SearchResult r1, SearchResult r2) {
|
|
if (r1.location != null && r2.location != null) {
|
|
Amenity a1 = null;
|
|
if (r1.object instanceof Amenity) {
|
|
a1 = (Amenity) r1.object;
|
|
}
|
|
Amenity a2 = null;
|
|
if (r2.object instanceof Amenity) {
|
|
a2 = (Amenity) r2.object;
|
|
}
|
|
if (r1.localeName.equals(r2.localeName)) {
|
|
double similarityRadius = 30;
|
|
if (a1 != null && a2 != null) {
|
|
// here 2 points are amenity
|
|
String type1 = a1.getType().getKeyName();
|
|
String type2 = a2.getType().getKeyName();
|
|
String subType1 = a1.getSubType();
|
|
String subType2 = a2.getSubType();
|
|
if(a1.getId().longValue() == a2.getId().longValue() && (subType1.equals("building") || subType2.equals("building"))) {
|
|
return true;
|
|
}
|
|
if (!type1.equals(type2)) {
|
|
return false;
|
|
}
|
|
if (type1.equals("natural")) {
|
|
similarityRadius = 50000;
|
|
} else if (subType1.equals(subType2)) {
|
|
if (subType1.contains("cn_ref") || subType1.contains("wn_ref")
|
|
|| (subType1.startsWith("route_hiking_") && subType1.endsWith("n_poi"))) {
|
|
similarityRadius = 50000;
|
|
}
|
|
}
|
|
} else if (ObjectType.isAddress(r1.objectType) && ObjectType.isAddress(r2.objectType)) {
|
|
similarityRadius = 100;
|
|
}
|
|
return MapUtils.getDistance(r1.location, r2.location) < similarityRadius;
|
|
}
|
|
} else if (r1.object != null && r2.object != null) {
|
|
return r1.object == r2.object;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void setPoiTypes(MapPoiTypes poiTypes) {
|
|
this.poiTypes = poiTypes;
|
|
}
|
|
|
|
public int getTotalLimit() {
|
|
return totalLimit;
|
|
}
|
|
|
|
public void setTotalLimit(int totalLimit) {
|
|
this.totalLimit = totalLimit;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public <T> T getApiByClass(Class<T> cl) {
|
|
for (SearchCoreAPI a : apis) {
|
|
if (cl.isInstance(a)) {
|
|
return (T) a;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public <T extends SearchCoreAPI> SearchResultCollection shallowSearch(Class<T> cl,
|
|
String text, final ResultMatcher<SearchResult> matcher) throws IOException {
|
|
T api = getApiByClass(cl);
|
|
if (api != null) {
|
|
SearchPhrase sphrase = this.phrase.generateNewPhrase(text, searchSettings);
|
|
preparePhrase(sphrase);
|
|
AtomicInteger ai = new AtomicInteger();
|
|
SearchResultMatcher rm = new SearchResultMatcher(matcher, sphrase, ai.get(), ai, totalLimit);
|
|
api.search(sphrase, rm);
|
|
|
|
SearchResultCollection collection = new SearchResultCollection(
|
|
sphrase);
|
|
collection.addSearchResults(rm.getRequestResults(), true, true);
|
|
LOG.info(">> Shallow Search phrase " + phrase + " " + rm.getRequestResults().size());
|
|
return collection;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void init() {
|
|
apis.add(new SearchCoreFactory.SearchLocationAndUrlAPI());
|
|
apis.add(new SearchCoreFactory.SearchAmenityTypesAPI(poiTypes));
|
|
apis.add(new SearchCoreFactory.SearchAmenityByTypeAPI(poiTypes));
|
|
apis.add(new SearchCoreFactory.SearchAmenityByNameAPI());
|
|
SearchBuildingAndIntersectionsByStreetAPI streetsApi =
|
|
new SearchCoreFactory.SearchBuildingAndIntersectionsByStreetAPI();
|
|
apis.add(streetsApi);
|
|
SearchStreetByCityAPI cityApi = new SearchCoreFactory.SearchStreetByCityAPI(streetsApi);
|
|
apis.add(cityApi);
|
|
apis.add(new SearchCoreFactory.SearchAddressByNameAPI(streetsApi, cityApi));
|
|
}
|
|
|
|
public void clearCustomSearchPoiFilters() {
|
|
for (SearchCoreAPI capi : apis) {
|
|
if (capi instanceof SearchAmenityTypesAPI) {
|
|
((SearchAmenityTypesAPI) capi).clearCustomFilters();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addCustomSearchPoiFilter(CustomSearchPoiFilter poiFilter, int priority) {
|
|
for (SearchCoreAPI capi : apis) {
|
|
if (capi instanceof SearchAmenityTypesAPI) {
|
|
((SearchAmenityTypesAPI) capi).addCustomFilter(poiFilter, priority);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void registerAPI(SearchCoreAPI api) {
|
|
apis.add(api);
|
|
}
|
|
|
|
|
|
public SearchResultCollection getCurrentSearchResult() {
|
|
return currentSearchResult;
|
|
}
|
|
|
|
public SearchPhrase getPhrase() {
|
|
return phrase;
|
|
}
|
|
|
|
public void setOnSearchStart(Runnable onSearchStart) {
|
|
this.onSearchStart = onSearchStart;
|
|
}
|
|
|
|
public void setOnResultsComplete(Runnable onResultsComplete) {
|
|
this.onResultsComplete = onResultsComplete;
|
|
}
|
|
|
|
public SearchSettings getSearchSettings() {
|
|
return searchSettings;
|
|
}
|
|
|
|
public void updateSettings(SearchSettings settings) {
|
|
searchSettings = settings;
|
|
}
|
|
|
|
private List<SearchResult> filterCurrentResults(List<SearchResult> rr, SearchPhrase phrase) {
|
|
List<SearchResult> l = currentSearchResult.searchResults;
|
|
for (SearchResult r : l) {
|
|
if (filterOneResult(r, phrase)) {
|
|
rr.add(r);
|
|
}
|
|
}
|
|
return rr;
|
|
}
|
|
|
|
private boolean filterOneResult(SearchResult object, SearchPhrase phrase) {
|
|
NameStringMatcher nameStringMatcher = phrase.getNameStringMatcher();
|
|
return nameStringMatcher.matches(object.localeName) || nameStringMatcher.matches(object.otherNames);
|
|
}
|
|
|
|
public boolean selectSearchResult(SearchResult r) {
|
|
this.phrase = this.phrase.selectWord(r);
|
|
return true;
|
|
}
|
|
|
|
public SearchPhrase resetPhrase() {
|
|
this.phrase = this.phrase.generateNewPhrase("", searchSettings);
|
|
return this.phrase;
|
|
}
|
|
|
|
public SearchPhrase resetPhrase(String text) {
|
|
this.phrase = this.phrase.generateNewPhrase(text, searchSettings);
|
|
return this.phrase;
|
|
}
|
|
|
|
public SearchResultCollection search(final String text, final boolean delayedExecution, final ResultMatcher<SearchResult> matcher) {
|
|
final int request = requestNumber.incrementAndGet();
|
|
final SearchPhrase phrase = this.phrase.generateNewPhrase(text, searchSettings);
|
|
this.phrase = phrase;
|
|
SearchResultCollection quickRes = new SearchResultCollection(phrase);
|
|
filterCurrentResults(quickRes.searchResults, phrase);
|
|
LOG.info("> Search phrase " + phrase + " " + quickRes.searchResults.size());
|
|
singleThreadedExecutor.submit(new Runnable() {
|
|
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
if (onSearchStart != null) {
|
|
onSearchStart.run();
|
|
}
|
|
SearchResultMatcher rm = new SearchResultMatcher(matcher, phrase, request, requestNumber, totalLimit);
|
|
rm.searchStarted(phrase);
|
|
if (TIMEOUT_BETWEEN_CHARS > 0 && delayedExecution) {
|
|
Thread.sleep(TIMEOUT_BETWEEN_CHARS);
|
|
} else if (TIMEOUT_BEFORE_SEARCH > 0) {
|
|
Thread.sleep(TIMEOUT_BEFORE_SEARCH);
|
|
}
|
|
if (rm.isCancelled()) {
|
|
return;
|
|
}
|
|
searchInBackground(phrase, rm);
|
|
if (!rm.isCancelled()) {
|
|
SearchResultCollection collection = new SearchResultCollection(
|
|
phrase);
|
|
collection.addSearchResults(rm.getRequestResults(), true, true);
|
|
LOG.info(">> Search phrase " + phrase + " " + rm.getRequestResults().size());
|
|
currentSearchResult = collection;
|
|
rm.searchFinished(phrase);
|
|
if (onResultsComplete != null) {
|
|
onResultsComplete.run();
|
|
}
|
|
}
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
});
|
|
return quickRes;
|
|
}
|
|
|
|
|
|
public boolean isSearchMoreAvailable(SearchPhrase phrase) {
|
|
for (SearchCoreAPI api : apis) {
|
|
if (api.getSearchPriority(phrase) >= 0 && api.isSearchMoreAvailable(phrase)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void searchInBackground(final SearchPhrase phrase, SearchResultMatcher matcher) {
|
|
preparePhrase(phrase);
|
|
ArrayList<SearchCoreAPI> lst = new ArrayList<>(apis);
|
|
Collections.sort(lst, new Comparator<SearchCoreAPI>() {
|
|
|
|
@Override
|
|
public int compare(SearchCoreAPI o1, SearchCoreAPI o2) {
|
|
return Algorithms.compare(o1.getSearchPriority(phrase),
|
|
o2.getSearchPriority(phrase));
|
|
}
|
|
});
|
|
for (SearchCoreAPI api : lst) {
|
|
if (matcher.isCancelled()) {
|
|
break;
|
|
}
|
|
if (!api.isSearchAvailable(phrase) || api.getSearchPriority(phrase) == -1) {
|
|
continue;
|
|
}
|
|
try {
|
|
api.search(phrase, matcher);
|
|
|
|
matcher.apiSearchFinished(api, phrase);
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
LOG.error(e.getMessage(), e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void preparePhrase(final SearchPhrase phrase) {
|
|
for (SearchWord sw : phrase.getWords()) {
|
|
if (sw.getResult() != null && sw.getResult().file != null) {
|
|
phrase.selectFile(sw.getResult().file);
|
|
}
|
|
}
|
|
phrase.sortFiles();
|
|
}
|
|
|
|
|
|
|
|
|
|
public static class SearchResultMatcher implements ResultMatcher<SearchResult>{
|
|
private final List<SearchResult> requestResults = new ArrayList<>();
|
|
private final ResultMatcher<SearchResult> matcher;
|
|
private final int request;
|
|
private final int totalLimit;
|
|
private SearchResult parentSearchResult;
|
|
private final AtomicInteger requestNumber;
|
|
int count = 0;
|
|
private SearchPhrase phrase;
|
|
|
|
|
|
public SearchResultMatcher(ResultMatcher<SearchResult> matcher, SearchPhrase phrase, int request,
|
|
AtomicInteger requestNumber, int totalLimit) {
|
|
this.matcher = matcher;
|
|
this.phrase = phrase;
|
|
this.request = request;
|
|
this.requestNumber = requestNumber;
|
|
this.totalLimit = totalLimit;
|
|
}
|
|
|
|
public SearchResult setParentSearchResult(SearchResult parentSearchResult) {
|
|
SearchResult prev = this.parentSearchResult;
|
|
this.parentSearchResult = parentSearchResult;
|
|
return prev;
|
|
}
|
|
|
|
public List<SearchResult> getRequestResults() {
|
|
return requestResults;
|
|
}
|
|
|
|
public int getCount() {
|
|
return requestResults.size();
|
|
}
|
|
|
|
public void searchStarted(SearchPhrase phrase) {
|
|
if (matcher != null) {
|
|
SearchResult sr = new SearchResult(phrase);
|
|
sr.objectType = ObjectType.SEARCH_STARTED;
|
|
matcher.publish(sr);
|
|
}
|
|
}
|
|
|
|
public void searchFinished(SearchPhrase phrase) {
|
|
if (matcher != null) {
|
|
SearchResult sr = new SearchResult(phrase);
|
|
sr.objectType = ObjectType.SEARCH_FINISHED;
|
|
matcher.publish(sr);
|
|
}
|
|
}
|
|
|
|
public void apiSearchFinished(SearchCoreAPI api, SearchPhrase phrase) {
|
|
if (matcher != null) {
|
|
SearchResult sr = new SearchResult(phrase);
|
|
sr.objectType = ObjectType.SEARCH_API_FINISHED;
|
|
sr.object = api;
|
|
sr.parentSearchResult = parentSearchResult;
|
|
matcher.publish(sr);
|
|
}
|
|
}
|
|
|
|
public void apiSearchRegionFinished(SearchCoreAPI api, BinaryMapIndexReader region, SearchPhrase phrase) {
|
|
if(matcher != null) {
|
|
SearchResult sr = new SearchResult(phrase);
|
|
sr.objectType = ObjectType.SEARCH_API_REGION_FINISHED;
|
|
sr.object = api;
|
|
sr.parentSearchResult = parentSearchResult;
|
|
sr.file = region;
|
|
matcher.publish(sr);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean publish(SearchResult object) {
|
|
if (phrase != null && object.otherNames != null && !phrase.getNameStringMatcher().matches(object.localeName)) {
|
|
for (String s : object.otherNames) {
|
|
if (phrase.getNameStringMatcher().matches(s)) {
|
|
object.alternateName = s;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (matcher == null || matcher.publish(object)) {
|
|
count++;
|
|
object.parentSearchResult = parentSearchResult;
|
|
if (totalLimit == -1 || count < totalLimit) {
|
|
requestResults.add(object);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
@Override
|
|
public boolean isCancelled() {
|
|
boolean cancelled = request != requestNumber.get();
|
|
return cancelled || (matcher != null && matcher.isCancelled());
|
|
}
|
|
}
|
|
|
|
public static class SearchResultComparator implements Comparator<SearchResult> {
|
|
private SearchPhrase sp;
|
|
private Collator collator;
|
|
private LatLon loc;
|
|
private boolean sortByName;
|
|
|
|
public SearchResultComparator(SearchPhrase sp) {
|
|
this.sp = sp;
|
|
this.collator = sp.getCollator();
|
|
loc = sp.getLastTokenLocation();
|
|
sortByName = sp.isSortByName();
|
|
}
|
|
|
|
@Override
|
|
public int compare(SearchResult o1, SearchResult o2) {
|
|
if (o1.getFoundWordCount() != o2.getFoundWordCount()) {
|
|
return -Algorithms.compare(o1.getFoundWordCount(), o2.getFoundWordCount());
|
|
}
|
|
if (!sortByName) {
|
|
double s1 = o1.getSearchDistance(loc);
|
|
double s2 = o2.getSearchDistance(loc);
|
|
int cmp = Double.compare(s1, s2);
|
|
if (cmp != 0) {
|
|
return cmp;
|
|
}
|
|
}
|
|
int st1 = Algorithms.extractFirstIntegerNumber(o1.localeName);
|
|
int st2 = Algorithms.extractFirstIntegerNumber(o2.localeName);
|
|
if (st1 != st2) {
|
|
return Algorithms.compare(st1, st2);
|
|
}
|
|
int cmp = collator.compare(o1.localeName, o2.localeName);
|
|
if (cmp != 0) {
|
|
return cmp;
|
|
}
|
|
if (o1.object instanceof Amenity && o2.object instanceof Amenity) {
|
|
// here 2 points are amenity
|
|
Amenity a1 = (Amenity) o1.object;
|
|
Amenity a2 = (Amenity) o2.object;
|
|
String type1 = a1.getType().getKeyName();
|
|
String type2 = a2.getType().getKeyName();
|
|
String subType1 = a1.getSubType();
|
|
String subType2 = a2.getSubType();
|
|
cmp = collator.compare(type1, type2);
|
|
if (cmp != 0) {
|
|
return cmp;
|
|
}
|
|
cmp = collator.compare(subType1, subType2);
|
|
if (cmp != 0) {
|
|
return cmp;
|
|
}
|
|
}
|
|
|
|
double s1 = o1.getSearchDistance(loc, 1);
|
|
double s2 = o2.getSearchDistance(loc, 1);
|
|
return Double.compare(s1, s2);
|
|
}
|
|
|
|
}
|
|
}
|