// Copyright 2010 Google Inc. All Rights Reserved.
package com.google.silvercomet.client;
import com.google.gwt.xhr.client.XMLHttpRequest;
import elemental.client.Browser;
import elemental.html.Window;
import elemental.util.ArrayOf;
import elemental.util.ArrayOfInt;
import elemental.util.ArrayOfString;
import elemental.util.MapFromStringTo;
import elemental.json.Json;
import elemental.js.util.StringUtil;
import elemental.js.util.Xhr;
import elemental.util.CanCompare;
import elemental.dom.TimeoutHandler;
import elemental.util.Collections;
/**
* A very simple data model for the application.
*
* @author knorton@google.com (Kelly Norton)
*/
public class Model implements Xhr.Callback {
/**
* A listener to receive callbacks on model events.
*/
public interface Listener {
void modelDidFailLoading(Model model);
void modelDidFinishBuildingIndex(Model model);
void modelDidFinishLoading(Model model);
}
private static final String DATA_URL = "results.json";
public static final int SECONDS_PER_HISTOGRAM_BUCKET = 600;
/**
* Compute a histogram with number of finishers per bucket of time where the
* size of the bucket is indicated by <code>seconds</code>.
*/
private static ArrayOfInt computeHistogram(ArrayOf<Runner> runners, int seconds) {
final ArrayOfInt hist = Collections.arrayOfInt();
for (int i = 0, n = runners.length(); i < n; ++i) {
int index = runners.get(i).time() / seconds;
hist.set(index, hist.isSet(index) ? hist.get(index) + 1 : 1);
}
int sum = 0;
for (int i = 0, n = hist.length(); i < n; ++i) {
if (hist.isSet(i)) {
sum += hist.get(i);
}
hist.set(i, sum);
}
return hist;
}
/**
* Sorts the list of runners by {@link Runner#time()} and updates their places
* accordingly.
*/
private static ArrayOf<Runner> normalize(ArrayOf<Runner> runners) {
// Sort by time() which is based on bib time.
runners.sort(new CanCompare<Runner>() {
@Override
public int compare(Runner a, Runner b) {
return a.time() - b.time();
}
});
// Update the runner's new place.
for (int i = 0, n = runners.length(); i < n; ++i) {
runners.get(i).setPlace(i + 1);
}
return runners;
}
/**
* Update the model's index with all possible prefixes of the search key.
*/
private static void updateIndexForAllPrefixes(
MapFromStringTo<ArrayOf<Runner>> index, String key, Runner runner) {
assert key.length() > 0 : "key.length must be > 0.";
for (int i = 1, n = key.length(); i <= n; ++i) {
final String prefix = key.substring(0, i);
if (!index.hasKey(prefix)) {
index.put(prefix, Collections.<Runner>arrayOf());
}
final ArrayOf<Runner> values = index.get(prefix);
// Do not add the same runner twice.
if (values.get(values.length() - 1) != runner) {
index.get(prefix).push(runner);
}
}
}
private final Listener listener;
private ArrayOfInt histogram = null;
private MapFromStringTo<ArrayOf<Runner>> index = Collections.mapFromStringTo();
/**
* Create a new model.
*/
public Model(Listener listener) {
this.listener = listener;
}
/**
* Get a reference to the models histogram.
*/
public ArrayOfInt histogram() {
return histogram;
}
/**
* Load the remote data into the model.
*/
public void load() {
Xhr.get(DATA_URL, this);
}
/**
* Called if the XHR fails to load data from there server.
*/
@Override
public void onFail(XMLHttpRequest xhr) {
listener.modelDidFailLoading(this);
}
/**
* Called when XHR successfully loads data from the server.
*/
@Override
public void onSuccess(XMLHttpRequest xhr) {
update((ArrayOf<Runner>)Json.parse(xhr.getResponseText()));
listener.modelDidFinishLoading(this);
}
/**
* Performs a search and returns the list of runners that match.
*/
public ArrayOf<Runner> search(String query) {
return index.get(query);
}
/**
* Update the model's internal data from an list of runners coming from the
* server.
*/
private void update(ArrayOf<Runner> data) {
// Sort & mutate source data.
final ArrayOf<Runner> runners = normalize(data);
// Update indexes later.
Browser.getWindow().setTimeout(new TimeoutHandler() {
@Override
public void onTimeoutHandler() {
for (int i = 0, n = runners.length(); i < n; ++i) {
final Runner runner = runners.get(i);
final String name = runner.name().toLowerCase();
updateIndexForAllPrefixes(index, name, runner);
final ArrayOfString words = StringUtil.split(name, " ");
for (int j = 0, m = words.length(); j < m; ++j) {
updateIndexForAllPrefixes(index, words.get(j), runner);
}
updateIndexForAllPrefixes(index, "" + runner.place(), runner);
updateIndexForAllPrefixes(index, "" + runner.bibNumber(), runner);
}
listener.modelDidFinishBuildingIndex(Model.this);
}
}, 0);
// Compute histogram.
final ArrayOfInt histogram = computeHistogram(runners, SECONDS_PER_HISTOGRAM_BUCKET);
// Update fields.
this.histogram = histogram;
}
}