[Telemetry] Implement subscription pools

Implement data structures which support lossless/lossy
behaviors for telemetry subscriptions (that is, allow
users of the telemetrySubscriber to decide whether or not
they are willing to drop updates in favor of only being
notified with the latest available values.) WTD-784.

platform/telemetry/src/TelemetryQueue.js

@@ -0,0 +1,71 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Supports TelemetrySubscription. Provides a simple data structure
+         * (with a pool-like interface) that aggregates key-value pairs into
+         * a queued series of large objects, ensuring that no value is
+         * overwritten (but consolidated non-overlapping keys into single
+         * objects.)
+         * @constructor
+         */
+        function TelemetryQueue() {
+            var queue = [];
+
+            // Look up an object in the queue that does not have a value
+            // assigned to this key (or, add a new one)
+            function getFreeObject(key) {
+                var index = 0, object;
+
+                // Look for an existing queue position where we can store
+                // a value to this key without overwriting an existing value.
+                for (index = 0; index < queue.length; index += 1) {
+                    if (queue[index][key] === undefined) {
+                        return queue[index];
+                    }
+                }
+
+                // If we made it through the loop, values have been assigned
+                // to that key in all queued containers, so we need to queue
+                // up a new  container for key-value pairs.
+                object = {};
+                queue.push(object);
+                return object;
+            }
+
+            return {
+                /**
+                 * Check if any value groups remain in this pool.
+                 * @return {boolean} true if value groups remain
+                 */
+                isEmpty: function () {
+                    return queue.length < 1;
+                },
+                /**
+                 * Retrieve the next value group from this pool.
+                 * This gives an object containing key-value pairs,
+                 * where keys and values correspond to the arguments
+                 * given to previous put functions.
+                 * @return {object} key-value pairs
+                 */
+                poll: function () {
+                    return queue.shift();
+                },
+                /**
+                 * Put a key-value pair into the pool.
+                 * @param {string} key the key to store the value under
+                 * @param {*} value the value to store
+                 */
+                put: function (key, value) {
+                    getFreeObject(key)[key] = value;
+                }
+            };
+        }
+
+        return TelemetryQueue;
+    }
+);

platform/telemetry/src/TelemetrySubscriber.js

@@ -32,18 +32,23 @@ define(
                  *        associated telemetry data is of interest
                  * @param {Function} callback a function to invoke
                  *        when new data has become available.
+                 * @param {boolean} lossless flag to indicate whether the
+                 *        callback should be notified for all values
+                 *        (otherwise, multiple values in quick succession
+                 *        will call back with only the latest value.)
                  * @returns {TelemetrySubscription} the subscription,
                  *        which will provide access to latest values.
                  *
                  * @method
                  * @memberof TelemetrySubscriber
                  */
-                subscribe: function (domainObject, callback) {
+                subscribe: function (domainObject, callback, lossless) {
                     return new TelemetrySubscription(
                         $q,
                         $timeout,
                         domainObject,
-                        callback
+                        callback,
+                        lossless
                     );
                 }
             };

platform/telemetry/src/TelemetryTable.js

@@ -0,0 +1,53 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Supports TelemetrySubscription. Provides a simple data structure
+         * (with a pool-like interface) that aggregates key-value pairs into
+         * one large object, overwriting new values as necessary. Stands
+         * in contrast to the TelemetryQueue, which will avoid overwriting
+         * values.
+         * @constructor
+         */
+        function TelemetryTable() {
+            var table;
+
+            return {
+                /**
+                 * Check if any value groups remain in this pool.
+                 * @return {boolean} true if value groups remain
+                 */
+                isEmpty: function () {
+                    return !table;
+                },
+                /**
+                 * Retrieve the next value group from this pool.
+                 * This gives an object containing key-value pairs,
+                 * where keys and values correspond to the arguments
+                 * given to previous put functions.
+                 * @return {object} key-value pairs
+                 */
+                poll: function () {
+                    var t = table;
+                    table = undefined;
+                    return t;
+                },
+                /**
+                 * Put a key-value pair into the pool.
+                 * @param {string} key the key to store the value under
+                 * @param {*} value the value to store
+                 */
+                put: function (key, value) {
+                    table = table || {};
+                    table[key] = value;
+                }
+            };
+        }
+
+        return TelemetryTable;
+    }
+);