Add storeEvents impl.

lib/store/webstorage.js

@@ -364,6 +364,59 @@ WebStorageStore.prototype.scrollback = function(room, limit) {
     return scrollback;
 };
 
+/**
+ * Store events for a room. The events have already been added to the timeline.
+ * @param {Room} room The room to store events for.
+ * @param {Array<MatrixEvent>} events The events to store.
+ * @param {string} token The token associated with these events.
+ * @param {boolean} toStart True if these are paginated results. The last element
+ * is the 'oldest' (for parity with homeserver scrollback APIs).
+ */
+WebStorageStore.prototype.storeEvents = function(room, events, token, toStart) {
+    if (toStart) {
+        // add paginated events to lowest batch indexes (can go -ve)
+        var lowIndex = getIndexExtremity(
+            getTimelineIndices(this.store, room.roomId), true
+        );
+        var i, key, batch;
+        for (i = 0; i < events.length; i++) { // loop events to be stored
+            key = keyName(room.roomId, "timeline", lowIndex);
+            batch = this.store.getItem(key) || [];
+            while (batch.length < this.batchSize && i < events.length) {
+                batch.unshift(events[i]);
+                i++; // increment to insert next event into this batch
+            }
+            i--; // decrement to avoid skipping one (for loop ++s)
+            this.store.setItem(key, batch);
+            lowIndex--; // decrement index to get a new batch.
+        }
+    }
+    else {
+        // dump as live events
+        var liveEvents = this.store.getItem(
+            keyName(room.roomId, "timeline", "live")
+        ) || [];
+        debuglog(
+            "Adding %s events to %s live list (which has %s already)",
+            events.length, room.roomId, liveEvents.length
+        );
+        var updateState = false;
+        liveEvents.concat(utils.map(events, function(me) {
+            // cheeky check to avoid looping twice
+            if (me.isState()) {
+                updateState = true;
+            }
+            return me.event;
+        }));
+        if (updateState) {
+            debuglog("Storing state for %s as new events updated state", room.roomId);
+            // use 0 batch size; we don't care about batching right now.
+            var serRoom = SerialisedRoom.fromRoom(room, 0);
+            this.store.setItem(keyName(serRoom.roomId, "state"), serRoom.state);
+        }
+    }
+};
+
 /**
  * Sync the 'live' timeline, batching live events according to 'batchSize'.
  * @param {string} roomId The room to sync the timeline.
@@ -375,7 +428,7 @@ WebStorageStore.prototype._syncTimeline = function(roomId, timelineIndices) {
     var liveEvents = this.store.getItem(keyName(roomId, "timeline", "live")) || [];
 
     // get the highest numbered $INDEX batch
-    var highestIndex = getHighestIndex(timelineIndices);
+    var highestIndex = getIndexExtremity(timelineIndices);
     var hiKey = keyName(roomId, "timeline", highestIndex);
     var hiBatch = this.store.getItem(hiKey) || [];
     // fill up the existing batch first.
@@ -481,7 +534,7 @@ function loadRoom(store, roomId, numEvents, tokenArray) {
 
     // add most recent numEvents
     var recentEvents = [];
-    var index = getHighestIndex(getTimelineIndices(store, roomId));
+    var index = getIndexExtremity(getTimelineIndices(store, roomId));
     var eventIndex = index;
     var i, key, batch;
     while (recentEvents.length < numEvents) {
@@ -534,15 +587,18 @@ function getTimelineIndices(store, roomId) {
     return keys;
 }
 
-function getHighestIndex(timelineIndices) {
-    var highestIndex, index;
+function getIndexExtremity(timelineIndices, getLowest) {
+    var extremity, index;
     for (var i = 0; i < timelineIndices.length; i++) {
         index = parseInt(timelineIndices[i]);
-        if (!isNaN(index) && (highestIndex === undefined || index > highestIndex)) {
-            highestIndex = index;
+        if (!isNaN(index) && (
+                extremity === undefined ||
+                !getLowest && index > extremity ||
+                getLowest && index < extremity)) {
+            extremity = index;
         }
     }
-    return highestIndex;
+    return extremity;
 }
 
 function keyName(roomId, key, index) {