string format_timestamp(uint64_t pos);
+EventsModel::EventsModel(sqlite3 *db) : db(db)
+{
+ load_data();
+}
+
QVariant EventsModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (role != Qt::DisplayRole) {
if (role != Qt::DisplayRole) {
return QVariant();
}
- refresh_if_needed();
if (index.column() == 0) {
return QString::fromUtf8(format_timestamp(events[index.row()].t));
} else if (index.column() == 1) {
optional<int> player_id = events[index.row()].player_id;
if (player_id) {
- const Player &p = players[*player_id];
+ auto p_it = players.find(*player_id);
+ const Player &p = p_it->second;
return QString::fromUtf8(p.name + " (" + p.number + ")");
} else {
return QVariant();
return QVariant();
}
-void EventsModel::refresh_if_needed() const
+void EventsModel::load_data()
{
- if (!stale) {
- return;
- }
-
players.clear();
events.clear();
- stale = false;
// Read the players.
sqlite3_stmt *stmt;
}
// Read the events.
- ret = sqlite3_prepare_v2(db, "SELECT t, player, type FROM event", -1, &stmt, 0);
+ ret = sqlite3_prepare_v2(db, "SELECT event, t, player, type FROM event ORDER BY t", -1, &stmt, 0);
if (ret != SQLITE_OK) {
fprintf(stderr, "SELECT prepare: %s\n", sqlite3_errmsg(db));
abort();
ret = sqlite3_step(stmt);
if (ret == SQLITE_ROW) {
Event e;
- e.t = sqlite3_column_int(stmt, 0);
- e.player_id = sqlite3_column_int(stmt, 1);
- e.type = (const char *)sqlite3_column_text(stmt, 2);
+ e.event_id = sqlite3_column_int(stmt, 0);
+ e.t = sqlite3_column_int(stmt, 1);
+ if (sqlite3_column_type(stmt, 2) == SQLITE_INTEGER) { // Non-NULL.
+ e.player_id = sqlite3_column_int(stmt, 2);
+ }
+ e.type = (const char *)sqlite3_column_text(stmt, 3);
events.push_back(std::move(e));
} else if (ret == SQLITE_DONE) {
break;
fprintf(stderr, "SELECT finalize: %s\n", sqlite3_errmsg(db));
abort();
}
-
- // TODO what if data changes externally?
- //emit dataChanged(QModelIndex(
}
-int EventsModel::insert_event(uint64_t t, int player_id)
+unsigned EventsModel::insert_event(uint64_t t, optional<int> player_id, const string &type)
{
auto it = lower_bound(events.begin(), events.end(), t,
[](const Event &e, uint64_t t) { return e.t < t; });
- int pos = distance(events.begin(), it);
- beginInsertRows(QModelIndex(), pos, pos + 1);
+ unsigned pos = distance(events.begin(), it);
+ beginInsertRows(QModelIndex(), pos, pos);
Event e;
e.t = t;
e.player_id = player_id;
- e.type = "unknown";
+ e.type = type;
events.insert(events.begin() + pos, e);
endInsertRows();
- // FIXME sqlite
+ // Insert the new row into the database.
+ sqlite3_stmt *stmt;
+ int ret = sqlite3_prepare_v2(db, "INSERT INTO event (t, player, type) VALUES (?, ?, ?)", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ sqlite3_bind_int64(stmt, 1, t);
+ if (player_id) {
+ sqlite3_bind_int64(stmt, 2, *player_id);
+ } else {
+ sqlite3_bind_null(stmt, 2);
+ }
+ sqlite3_bind_text(stmt, 3, type.data(), type.size(), SQLITE_STATIC);
+
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ fprintf(stderr, "INSERT step: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ ret = sqlite3_finalize(stmt);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "INSERT finalize: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+ events[pos].event_id = sqlite3_last_insert_rowid(db);
return pos;
}
+
+void EventsModel::delete_event(unsigned pos)
+{
+ int event_id = events[pos].event_id;
+
+ beginRemoveRows(QModelIndex(), pos, pos);
+ events.erase(events.begin() + pos);
+ endRemoveRows();
+
+ // Delete the row from the database.
+ sqlite3_stmt *stmt;
+ int ret = sqlite3_prepare_v2(db, "DELETE FROM event WHERE event=?", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "DELETE prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ sqlite3_bind_int64(stmt, 1, event_id);
+
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ fprintf(stderr, "DELETE step: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ ret = sqlite3_finalize(stmt);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "DELETE finalize: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+}
+
+void EventsModel::set_event_type(unsigned pos, const string &type)
+{
+ events[pos].type = type;
+ emit dataChanged(createIndex(pos, 0), createIndex(pos, 2));
+
+ sqlite3_stmt *stmt;
+ int ret = sqlite3_prepare_v2(db, "UPDATE event SET type=? WHERE event=?", -1, &stmt, 0);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "INSERT prepare: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ sqlite3_bind_text(stmt, 1, type.data(), type.size(), SQLITE_STATIC);
+ sqlite3_bind_int64(stmt, 2, events[pos].event_id);
+
+ ret = sqlite3_step(stmt);
+ if (ret == SQLITE_ROW) {
+ fprintf(stderr, "UPDATE step: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+
+ ret = sqlite3_finalize(stmt);
+ if (ret != SQLITE_OK) {
+ fprintf(stderr, "UPDATE finalize: %s\n", sqlite3_errmsg(db));
+ abort();
+ }
+}
+
+EventsModel::Status EventsModel::get_status_at(uint64_t t)
+{
+ Status s;
+ s.our_score = 0;
+ s.their_score = 0;
+ s.offense = true;
+ uint64_t last_gained_possession = 0;
+ unsigned num_touches = 0;
+ for (const Event &e : events) {
+ if (e.t > t) {
+ break;
+ }
+ if (e.type == "goal") {
+ ++s.our_score;
+ s.offense = false;
+ num_touches = 0;
+ }
+ if (e.type == "their_goal") {
+ ++s.their_score;
+ s.offense = true;
+ num_touches = 0;
+ }
+ if (e.type == "catch") {
+ if (num_touches == 0) { // Pick up.
+ last_gained_possession = e.t;
+ }
+ ++num_touches;
+ }
+ if (e.type == "interception") {
+ num_touches = 1;
+ s.offense = true;
+ last_gained_possession = e.t;
+ }
+ if (e.type == "drop" || e.type == "throwaway") {
+ s.offense = false;
+ num_touches = 0;
+ }
+ }
+ s.num_passes = (num_touches == 0) ? 0 : num_touches - 1;
+ s.possession_sec = (s.offense && last_gained_possession != 0 && num_touches != 0) ? (t - last_gained_possession) / 1000 : 0;
+ return s;
+}
+
+set<int> EventsModel::get_team_at(uint64_t t)
+{
+ set<int> team;
+ for (const Event &e : events) {
+ if (e.t > t) {
+ break;
+ }
+ if (e.type == "in") {
+ team.insert(*e.player_id);
+ }
+ if (e.type == "out") {
+ team.erase(*e.player_id);
+ }
+ }
+ return team;
+}
projects / pkanalytics / blobdiff