1 files changed, 1418 insertions, 0 deletions

diff --git a/node_modules/montage/core/change-notification.js b/node_modules/montage/core/change-notification.js
new file mode 100644
index 00000000..bfe5ff2d
--- /dev/null
+++ b/node_modules/montage/core/change-notification.js
@@ -0,0 +1,1418 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+/**
+    @module montage/core/event/change-notification
+*/
+
+var Montage = require("montage").Montage,
+    logger = require("core/logger").logger("change-notification"),
+    UNDERSCORE = "_";
+
+// key: <path>, <target uuid>, <listener uuid>
+var _descriptorsDirectory = Object.create(null);
+
+// key: <target uuid>, <path>
+var _willChangeDescriptorsDirectory = Object.create(null);
+var _willChangeDescriptorsIndexesDirectory = Object.create(null);
+var _changeDescriptorsDirectory = Object.create(null);
+var _changeDescriptorsIndexesDirectory = Object.create(null);
+
+exports.__reset__ = function() {
+    _descriptorsDirectory = Object.create(null);
+    _willChangeDescriptorsDirectory = Object.create(null);
+    _willChangeDescriptorsIndexesDirectory = Object.create(null);
+    _changeDescriptorsDirectory = Object.create(null);
+    _changeDescriptorsIndexesDirectory = Object.create(null);
+    // also need to remove all installed setters
+};
+
+exports.__debug__ = function() {
+    console.log("_descriptorsDirectory", _descriptorsDirectory);
+    console.log("_willChangeDescriptorsDirectory", _willChangeDescriptorsDirectory, _willChangeDescriptorsIndexesDirectory);
+    console.log("_changeDescriptorsDirectory", _changeDescriptorsDirectory, _changeDescriptorsIndexesDirectory);
+};
+
+var ChangeNotification = exports.ChangeNotification = Object.create(Montage, {
+    // (object) => <object>.uuid
+    //
+    // (target_n): {
+    //     <propertyPath_n>: {
+    //         target,
+    //         propertyPath,
+    //         willChangeListeners: {
+    //             (listener_n): {
+    //                 listenerTarget,
+    //                 listenerFunction,
+    //                 listensToMutation
+    //             }
+    //         },
+    //         changeListeners: same as willChangeListeners,
+    //         willChangeListenersCount: Object.keys(willChangeListeners).length,
+    //         changeListenersCount: Object.keys(changeListeners).length,
+    //         handleWillChange: function()
+    //         handleChange: function()
+    //     }
+    // }
+    _descriptorsRegistry: {
+        writable: true,
+        value: Object.create(null)
+    },
+
+    _createFunctionDescriptor: {
+        value: function(target, listener, beforeChange, mutation) {
+            var identifier,
+                functionName,
+                functionDescriptor = Object.create(ChangeNotificationFunctionDescriptor);
+
+            if (typeof listener === "function") {
+                functionDescriptor.listenerFunction = listener;
+                functionDescriptor.listenerTarget = target;
+            } else {
+                identifier = target.identifier;
+
+                if (identifier) {
+                    identifier = identifier.toCapitalized();
+
+                    functionName = "handle" + identifier + (beforeChange ? "WillChange" : "Change");
+                    if (typeof listener[functionName] === "function") {
+                        functionDescriptor.listenerFunctionName = functionName;
+                        functionDescriptor.listenerFunction = listener[functionName];
+                        functionDescriptor.listenerTarget = listener;
+                    }
+                }
+
+                if (!functionDescriptor.listenerFunction) {
+                    functionName = "handle" + (beforeChange ? "WillChange" : "Change");
+                    if (typeof listener[functionName] === "function") {
+                        functionDescriptor.listenerFunctionName = functionName;
+                        functionDescriptor.listenerFunction = listener[functionName];
+                        functionDescriptor.listenerTarget = listener;
+                    }
+                }
+            }
+
+            if (!functionDescriptor.listenerFunction) {
+                console.log("Could not find valid listener when installing", target, listener);
+                throw "Could not find valid listener when installing";
+            }
+
+            functionDescriptor.listensToMutation = mutation;
+            return functionDescriptor;
+        }
+    },
+
+    registerPropertyChangeListener: {
+        value: function(target, path, listener, beforeChange, mutation) {
+            var targetKey = target.uuid,
+                registry = this._descriptorsRegistry,
+                targetEntry = registry[targetKey],
+                descriptor;
+
+            if (path == null) {
+                path = "*";
+                mutation = true;
+            }
+
+            if (!targetEntry) {
+                targetEntry = registry[targetKey] = Object.create(null);
+                targetEntry.propertyPathCount = 0;
+            }
+
+            descriptor = targetEntry[path];
+            if (!descriptor) {
+                descriptor = targetEntry[path] = Object.create(ChangeNotificationDescriptor).initWithTargetPath(target, path);
+                targetEntry.propertyPathCount++;
+            }
+            descriptor.registerListener(listener, beforeChange, mutation);
+
+            return descriptor;
+        }
+    },
+
+    unregisterPropertyChangeListener: {
+        value: function(target, path, listener, beforeChange) {
+            var targetKey = target.uuid,
+                registry = this._descriptorsRegistry,
+                targetEntry = registry[targetKey],
+                descriptor;
+
+            if (path == null) {
+                path = "*";
+            }
+
+            if (targetEntry) {
+                descriptor = targetEntry[path];
+                if (descriptor) {
+                    // TODO: should this function return the number of listeners?
+                    descriptor.unregisterListener(listener, beforeChange);
+                    if (descriptor.willChangeListenersCount === 0 &&
+                        descriptor.changeListenersCount === 0) {
+                        delete targetEntry[path];
+                        if (--targetEntry.propertyPathCount === 0) {
+                            delete registry[targetKey];
+                        }
+                    }
+                }
+            }
+        }
+    },
+
+    getPropertyChangeDescriptor: {
+        value: function(target, path) {
+            var targetEntry = this._descriptorsRegistry[target.uuid];
+
+            if (targetEntry) {
+                if (path == null) {
+                    path = "*";
+                }
+                return targetEntry[path];
+            }
+        }
+    },
+
+    __debug__: {
+        value: function() {
+            console.log("_descriptorsRegistry: ", this._descriptorsRegistry);
+        }
+    },
+
+    __reset__: {
+        value: function() {
+            this._descriptorsRegistry = Object.create(null);
+        }
+    }
+});
+
+var ChangeNotificationDescriptor = Montage.create(Montage, {
+    target: {value: null},
+    propertyPath: {value: null},
+    willChangeListeners: {value: null},
+    changeListeners: {value: null},
+    willChangeListenersCount: {value: 0},
+    changeListenersCount: {value: 0},
+    isActive: {value: false},
+    // list of all objects that this listener needed to start listening to.
+    // these are the objects in the target.getProperty(path).
+    // format [(target, propertyName, remainingPath)*]
+    dependencies: {value: null},
+    hasWillChangeDependencies: {value: false},
+    hasChangeDependencies: {value: false},
+    // index of where this listener is expected to be in its dependent listeners
+    dependentDescriptorsIndex: {value: null},
+    mutationDependencyIndex: {value: null},
+    mutationListenersCount: {value: 0},
+
+    initWithTargetPath: {
+        value: function(target, path) {
+            this.target = target;
+            this.propertyPath = path;
+
+            return this;
+        }
+    },
+    registerListener: {
+        value: function(listener, beforeChange, mutation) {
+            var listenerKey = listener.uuid;
+
+            if (beforeChange) {
+                listeners = this.willChangeListeners;