Merge branch 'timeline-save-770b'

platform/core/src/capabilities/PersistenceCapability.js

@@ -46,6 +46,7 @@ define(
          * @implements {Capability}
          */
         function PersistenceCapability(
+            cacheService,
             persistenceService,
             identifierService,
             notificationService,
@@ -56,6 +57,7 @@ define(
             this.modified = domainObject.getModel().modified;
 
             this.domainObject = domainObject;
+            this.cacheService = cacheService;
             this.identifierService = identifierService;
             this.persistenceService = persistenceService;
             this.notificationService = notificationService;
@@ -130,6 +132,7 @@ define(
                 domainObject = this.domainObject,
                 model = domainObject.getModel(),
                 modified = model.modified,
+                cacheService = this.cacheService,
                 persistenceService = this.persistenceService,
                 persistenceFn = model.persisted !== undefined ?
                     this.persistenceService.updateObject :
@@ -146,6 +149,9 @@ define(
                 getKey(domainObject.getId()),
                 domainObject.getModel()
             ]).then(function(result){
+                if (result) {
+                    cacheService.remove(domainObject.getId());
+                }
                 return rejectIfFalsey(result, self.$q);
             }).catch(function(error){
                 return notifyOnError(error, domainObject, self.notificationService, self.$q);

platform/core/src/models/CachingModelDecorator.js

@@ -35,9 +35,8 @@ define(
          * @param {ModelService} modelService this service to decorate
          * @implements {ModelService}
          */
-        function CachingModelDecorator(modelService) {
-            this.cache = {};
-            this.cached = {};
+        function CachingModelDecorator(cacheService, modelService) {
+            this.cacheService = cacheService;
             this.modelService = modelService;
         }
 
@@ -51,17 +50,16 @@ define(
         }
 
         CachingModelDecorator.prototype.getModels = function (ids) {
-            var cache = this.cache,
-                cached = this.cached,
+            var cacheService = this.cacheService,
                 neededIds = ids.filter(function notCached(id) {
-                    return !cached[id];
+                    return !cacheService.has(id);
                 });
 
             // Update the cached instance of a model to a new value.
             // We update in-place to ensure there is only ever one instance
             // of any given model exposed by the modelService as a whole.
             function updateModel(id, model) {
-                var oldModel = cache[id];
+                var oldModel = cacheService.get(id);
 
                 // Same object instance is a possibility, so don't copy
                 if (oldModel === model) {
@@ -71,7 +69,7 @@ define(
                 // If we'd previously cached an undefined value, or are now
                 // seeing undefined, replace the item in the cache entirely.
                 if (oldModel === undefined || model === undefined) {
-                    cache[id] = model;
+                    cacheService.put(id, model);
                     return model;
                 }
 
@@ -91,15 +89,15 @@ define(
             // Store the provided models in our cache
             function cacheAll(models) {
                 Object.keys(models).forEach(function (id) {
-                    cache[id] = cached[id] ?
+                    var model = cacheService.has(id) ?
                         updateModel(id, models[id]) : models[id];
-                    cached[id] = true;
+                    cacheService.put(id, model);
                 });
             }
 
             // Expose the cache (for promise chaining)
             function giveCache() {
-                return cache;
+                return cacheService.all();
             }
 
             // Look up if we have unknown IDs
@@ -110,7 +108,7 @@ define(
             }
 
             // Otherwise, just expose the cache directly
-            return fastPromise(cache);
+            return fastPromise(cacheService.all());
         };
 
         return CachingModelDecorator;

platform/core/src/models/ModelCacheService.js

@@ -0,0 +1,83 @@
+/*****************************************************************************
+ * Open MCT Web, Copyright (c) 2014-2015, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT Web is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT Web includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+/*global define*/
+
+define([], function () {
+    'use strict';
+
+    /**
+     * Provides a cache for domain object models which exist in memory,
+     * but may or may not exist in backing persistene stores.
+     * @constructor
+     * @memberof platform/core
+     */
+    function ModelCacheService() {
+        this.cache = {};
+    }
+
+    /**
+     * Put a domain object model in the cache.
+     * @param {string} id the domain object's identifier
+     * @param {object} model the domain object's model
+     */
+    ModelCacheService.prototype.put = function (id, model) {
+        this.cache[id] = model;
+    };
+
+    /**
+     * Retrieve a domain object model from the cache.
+     * @param {string} id the domain object's identifier
+     * @returns {object} the domain object's model
+     */
+    ModelCacheService.prototype.get = function (id) {
+        return this.cache[id];
+    };
+
+    /**
+     * Check if a domain object model is in the cache.
+     * @param {string} id the domain object's identifier
+     * @returns {boolean} true if present; false if not
+     */
+    ModelCacheService.prototype.has = function (id) {
+        return this.cache.hasOwnProperty(id);
+    };
+
+    /**
+     * Remove a domain object model from the cache.
+     * @param {string} id the domain object's identifier
+     */
+    ModelCacheService.prototype.remove = function (id) {
+        delete this.cache[id];
+    };
+
+    /**
+     * Retrieve all cached domain object models. These are given
+     * as an object containing key-value pairs, where keys are
+     * domain object identifiers and values are domain object models.
+     * @returns {object} all domain object models
+     */
+    ModelCacheService.prototype.all = function () {
+        return this.cache;
+    };
+
+    return ModelCacheService;
+});

platform/core/src/services/Instantiate.js

@@ -44,10 +44,15 @@ define(
          * @param {IdentifierService} identifierService service to generate
          *        new identifiers
          */
-        function Instantiate(capabilityService, identifierService) {
+        function Instantiate(
+            capabilityService,
+            identifierService,
+            cacheService
+        ) {
             return function (model, id) {
                 var capabilities = capabilityService.getCapabilities(model);
                 id = id || identifierService.generate();
+                cacheService.put(id, model);
                 return new DomainObjectImpl(id, model, capabilities);
             };
         }