objectRegistry.js

Go to the documentation of this file.

 
 
//class for registering items that will receive messages from the server
 
define( [
                'remoto!stdlib:js/include/utils.js',
                'include/modal/modal',
        ],
        function(utils,modal)
        {
                'use strict';
 
                var _objectRegistry;
 
                function objectRegistry()
                {
                        this._objects = {};
                        this._reads = {};
                        this._metadatas = {};
                        //this._noresubscribe = {};
                }
 
                objectRegistry.prototype = {
 
                        reset:                  function()
                                                {
                                                        for (var i in this._objects)
                                                                for (var j=0;j<this._objects[i].length;j++)
                                                                        if (this._objects[i][j].detach)
                                                                                this._objects[i][j].detach();
 
                                                        this._objects = {};
                                                        this._reads = {};
                                                        this._metadatas = {};
                                                        //this._noresubscribe = {};
 
                                                        _definitions = {};
                                                        _loaders = {};
                                                },
 
                        printRegistry:          function()
                                                {
                                                        console.log( "objects", this._objects );
                                                        console.log( "definitions", _definitions );
                                                        console.log( "loaders", _loaders );
                                                        console.log( "reads", this._reads );
                                                        console.log( "metadata", this._metadatas );
                                                },
 
                        registerObject:         function(id,o,nosubscribe)//,noresubscribe)
                                                {
                                                        //console.log(arguments);
 
                                                        var forceSubscribe = false;
 
                                                        id = utils.cleanPath(id);
 
                                                        if (!this._objects[id])
                                                        {       this._objects[id] = [];
                                                //              forceSubscribe = true;
                                                        }
 
                                                        if (!this._objects[id].includes(o))
                                                                this._objects[id].push(o);
 
                                                //      console.log(this._objects[id]);
 
                                                //      if (noresubscribe)                              //should be manually added by a class when needed
                                                //              this._noresubscribe[id] = true;
 
                                                        if (!nosubscribe || forceSubscribe)
                                                                if (this.pathAddedCallback)
                                                                        this.pathAddedCallback([id]);
                                                },
 
                        unregisterObject:       function(id,o,silent,nounsubscribe,now)
                                                {
                                                        var forceUnsubscribe = false;
 
                                                        id = utils.cleanPath(id);
 
                                                        if (!this._objects[id])
                                                        {       //console.dir(this._objects);
                                                                if (!silent)
                                                                        console.warn("Registered object with id \""+id+"\" does not exist.",o);
                                                                return;
                                                        }
 
                                                        var i = this._objects[id].indexOf(o);
 
                                                        if (i>-1)
                                                        {
                                                                var b = this._objects[id].splice(i,1);
                                                                //b.destroy();
                                                        }
                                                //      else
                                                //              throw "Registered matching object with id="+id+" was not found.";
 
                                                        if (this._objects[id].length === 0)
                                                        {       delete this._objects[id];
                                                                //delete this._noresubscribe[id];       //would have been manually added by a class when registered
                                                //              forceUnsubscribe = true;
 
                                                //              console.log(this._objects[id]);
 
                                                        }//?
 
                                                        if (!nounsubscribe || forceUnsubscribe)
                                                        if (this.pathRemovedCallback)
                                                        {
                                                                this.pathRemovedCallback([id],now);
                                                                //console.trace("path removed: "+id);
                                                        }
                                                },
 
                        readPath:               function(id,o)
                                                {
                                                        var requested = true;
 
                                                        id = utils.cleanPath(id);
 
                                                        if (!this._reads[id])
                                                        {       this._reads[id] = [];
                                                                requested = false;
                                                        }
 
                                                        this._reads[id].push(o);
 
                                                        if (!requested)
                                                        if (this.pathReadCallback)
                                                                this.pathReadCallback([id]);
                                                },
 
                        readSinglePath:         function(id,o,metadata)
                                                {
                                                        var requested = true;
 
                                                        id = utils.cleanPath(id);
 
                                                        if (!this._reads[id])
                                                        {       this._reads[id] = [];
                                                                requested = false;
                                                        }
 
                                                        this._reads[id].push(o);
 
                                                        if (!requested)
                                                        if (this.pathReadSingleCallback)
                                                                this.pathReadSingleCallback(id,metadata);
                                                },
 
 
                        metadataPath:           function(id,o)
                                                {
                                                        var requested = true;
 
                                                        id = utils.cleanPath(id);
 
                                                        if (!this._metadatas[id])
                                                        {       this._metadatas[id] = [];
                                                                requested = false;
                                                        }
 
                                                        this._metadatas[id].push(o);
 
                                                        if (!requested)
                                                        if (this.pathMetadataCallback)
                                                                this.pathMetadataCallback([id]);
                                                },
 
                        isRegistered:           function(id,object)
                                                {
                                                        if (this._objects[id])
                                                                if (this._objects[id].indexOf(object) > -1)
                                                                        return true;
 
                                                        return false;
 
                                                        //return (this._objects[id] ? true : false);
                                                },
 
                        /*
                        fetchObject:            function(id,firstOnly)
                                                {
                                                        if (this._objects[id] && this._objects[id].length)
                                                                return firstOnly ? this._objects[id][0] : this._objects[id];
                                                        else
                                                                return firstOnly ? null : [];
                                                },
                        */
 
                        pathAddedCallback:      null,
                        pathRemovedCallback:    null,
                        pathReadCallback:       null,
                        pathMetadataCallback:   null,
 
                        pathList:               function()
                                                {
                                                        //return Object.keys(this._objects).concat( Object.keys(this._reads ) );
 
                                                        //https://medium.com/@alvaro.saburido/set-theory-for-arrays-in-es6-eb2f20a61848
                                                        var l = Object.keys(this._objects);
                                                //      var nr = Object.keys(this._noresubscribe);
                                                //      let d = l.filter(x => !nr.includes(x));
                                                //      return d;
                                                        return l;
                                                },
 
                //      isSubscribedTo:         function(path)
                //                              {
                //                                      return this._objects.hasOwnProperty(path);
                //                              },
 
                        applyDiff:              function(id,diff,user,except)
                                                {
                                                        id = utils.cleanPath(id);
 
                                                        //console.log(data);
                                                        //console.log(this._objects);
 
                                                        var o = this._objects[id];
                                                        o = o ? o.slice(0) : null;              //copy the array, because the diff may change it
 
                                                //      try
                                                        {
                                                                if (o)
                                                                {       //for (var i=0;i<o.length;i++)
                                                                        //      if("startDiff" in o[i])
                                                                        //              if (o[i] !== except)
                                                                        //                      o[i].startDiff();
 
                                                                        for (var i=0;i<o.length;i++)
                                                                                if ("applyDiff" in o[i])
                                                                                {
                                                                                        //console.log(o[i]);
                                                                                        if (o[i] !== except)
                                                                                        {
                                                                                                if (diff !== null && Object.keys(diff).length == 1 && ("mounted" in diff))
                                                                                                {
                                                                                                        if ("mounted" in o[i])
                                                                                                                o[i].mounted(diff.mounted)
                                                                                                }
                                                                                                else
                                                                                                //      try
                                                                                                        {
                                                                                                                o[i].applyDiff(diff,user);
                                                                                                        }
                                                                                                //      catch(err)
                                                                                                //      {
                                                                                                //              console.error("objectRegistry applyDiff exception (1):"+err);
                                                                                                //              console.log(o[i]);
                                                                                                //      }
                                                                                        }
                                                                                //      else
                                                                                //              console.log("skipped except in objectRegistry : "+o.length);
                                                                                }
                                                                                else
                                                                                {       console.error("Object in registry doesn't have an applyDiff function!",id,o[i]);
                                                                                        console.trace();
                                                                                }
 
                                                                        //for (var i=0;i<o.length;i++)
                                                                        //      if ("stopDiff" in o[i])
                                                                        //              if (o[i] !== except)
                                                                        //                      o[i].stopDiff();
 
                                                                        return true;
                                                                }
                                                                else
                                                                {
                                                                        //console.trace("Non-registered path: "+id,arguments);
                                                                        //console.log(arguments);
                                                                        //console.log(this._objects);
                                                                }
                                                        }
                                                //      catch(err)
                                                //      {
                                                //              console.error("objectRegistry applyDiff exception (2):"+err);
                                                //      }
 
                                                        return false;
                                                },
 
                        applySubscription:      function(id,data,metadata)
                                                {
                                                        //console.log(id);
                                                        id = utils.cleanPath(id);
                                                        var o1 = this._objects[id];
                                                        var o = o1 ? o1.slice(0) : null;                //copy the array, because the subscription may change it
 
                                                        var context = metadata.context = metadata.context || {};
                                                        context.sourcefile = utils.fileNameFromPath( id, true );
                                                        context.sourcepath = id;
                                                        context.sourcedir = utils.dirNameFromPath( id );
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applySubscription" in o[i])
                                                                        {
                                                                                //if (!o[i]._subscribed)
                                                                                        o[i].applySubscription(data,metadata);
                                                                                //else
                                                                                //      console.error("Object at "+id+"/"+i+" was already subscribed.");
                                                                        }
                                                                        else if ("applyDiff" in o[i])
                                                                                o[i].applyDiff(data,null);
                                                                        else
                                                                        {       console.error("Object in registry doesn't have an applySubscription or applyDiff function!");
                                                                                console.trace();
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                console.error("Non-registered path: "+id,arguments);
                                                                //console.log(arguments);
                                                                //console.log(this._objects);
                                                        }
 
                                                        return false;
                                                },
 
                        applyRead:              function(id,data,metadata)
                                                {
                                                        //console.log("applyRead",arguments);
 
                                                        id = utils.cleanPath(id);
                                                        var o = this._reads[id];
                                                        delete this._reads[id];
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyRead" in o[i])
                                                                        {
                                                                                o[i].applyRead(id,data,metadata);
                                                                        }
                                                                        else
                                                                        {       console.error("Object in registry doesn't have an applyRead function!");
                                                                                console.trace();
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                console.error("Non-registered path: "+id,arguments);
                                                                //console.log(arguments);
                                                                //console.log(this._objects);
                                                        }
 
                                                        return false;
                                                },
 
                        applyMetadata:          function(id,metadata)
                                                {
                                                        //console.trace("apply metadata",arguments);
 
                                                        id = utils.cleanPath(id);
                                                        var o = this._metadatas[id];
                                                        delete this._metadatas[id];
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyMetadata" in o[i])
                                                                        {
                                                                                o[i].applyMetadata(id,metadata);
                                                                        }
                                                                        else
                                                                        {       console.error("Object in registry doesn't have an applyMetadata function!");
                                                                                console.trace();
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                console.error("Non-registered metadata path: "+id,arguments,o);
                                                                //console.log(arguments);
                                                                //console.log(this._objects);
                                                        }
 
                                                        console.trace("returning false");
                                                        return false;
                                                },
 
                        applyRequestLock:       function(id,data)
                                                {
                                                        id = utils.cleanPath(id);
                                                        var o = this._objects[id];
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyRequestLock" in o[i])
                                                                        {
                                                                                o[i].applyRequestLock(data);
                                                                        }
                                                                        else
                                                                        {       console.error("Object in registry doesn't have an applyRequestLock function!");
                                                                                console.trace();
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                console.error("Non-registered path: "+id,arguments);
                                                                //console.log(arguments);
                                                                //console.log(this._objects);
                                                        }
 
                                                        return false;
                                                },
 
                        applyReleaseLock:       function(id,data)
                                                {
                                                        id = utils.cleanPath(id);
                                                        var o = this._objects[id];
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyReleaseLock" in o[i])
                                                                        {
                                                                                o[i].applyReleaseLock(data);
                                                                        }
                                                                        else
                                                                        {       console.error("Object in registry doesn't have an applyReleaseLock function!");
                                                                                console.trace();
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                console.error("Non-registered path: "+id,arguments);
                                                                //console.log(arguments);
                                                                //console.log(this._objects);
                                                        }
 
                                                        return false;
                                                },
 
                        applyRequestError:      function(command,id,reason)
                                                {
                                                        //console.warn("objectregistry applyRequestError",arguments,this._objects);
 
                                                        id = utils.cleanPath(id);
                                                        var o;
                                                        var ok = false;
 
                                                        switch (command)
                                                        {
                                                                case "subscribe":
                                                                case "unsubscribe":     o = this._objects[id];          break;
 
                                                                case "read":            o = this._reads[id];            break;
 
                                                                case "metadata":        o = this._metadatas[id];        break;
 
                                                                default:                console.error("unsupported applyRequestError command: "+command);
                                                                                        break;
                                                        };
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyRequestError" in o[i])
                                                                        {
                                                                                o[i].applyRequestError(command,id,reason);
                                                                        }
                                                                        else
                                                                        {       console.error("Object '"+id+"' in registry doesn't have an applyRequestError function!",o[i]);
                                                                                //console.log(o[i]);
                                                                                //console.trace();
                                                                                var commandUP = command.charAt(0).toUpperCase() + command.slice(1);
                                                                                modal.alert( reason, null, commandUP+" Error" );
                                                                        }
                                                                }
 
                                                                ok = true;
                                                        }
 
                                                        //clean up the bad things
                                                        switch (command)
                                                        {
                                                                case "subscribe":
                                                                case "unsubscribe":     delete this._objects[id];       break;
 
                                                                case "read":            delete this._reads[id];         break;
 
                                                                case "metadata":        delete this._metadatas[id];     break;
                                                        };
 
                                                        return ok;
                                                },
 
                        applyRequestSuccess:    function(command,id,data,metadata)
                                                {
                                                        id = utils.cleanPath(id);
                                                        var o = this._objects[id];
 
                                                        if (o)
                                                        {
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if ("applyRequestSuccess" in o[i])
                                                                        {
                                                                                o[i].applyRequestSuccess(command,id,data,metadata);
                                                                        }
                                                                        else
                                                                        {       console.error("Object '"+id+"' in registry doesn't have an applyRequestSuccess function!");
                                                                                console.log(o[i]);
                                                                                modal.alert( "no applyRequestSuccess function!", null, command+" success error" );
                                                                        }
                                                                }
 
                                                                return true;
                                                        }
                                                        else
                                                        {
                                                                if (command != "rm")
                                                                {
                                                                        console.error("applyRequestSuccess Non-registered path: "+id,arguments);
                                                                        console.log(this._objects);
                                                                }
                                                                else
                                                                        return true;
                                                        }
 
                                                        return false;
                                                },
 
                        find:                   function(id,type)
                                                {
                                                        var o = this._objects[id];
                                                        //console.log(o);
 
                                                        if (o)
                                                        {
                                                                if (!type)                                      //don't care about type
                                                                        return o[0];
 
                                                                for (var i=0;i<o.length;i++)
                                                                {
                                                                        if (o[i] instanceof type)               //generally return a pane
                                                                                return o[i];
 
                                                                        if (o[i]._object instanceof type)       //return a more complex object
                                                                                return o[i]._object;
                                                                }
                                                        }
 
                                                        return null;
                                                },
                }
 
                function extendDefinition( extender, base, strict )
                {
                        base = base || {};
 
                        if (typeof base == "string")
                                return extender;
 
                        //if (typeof extender == 'object' && extender !== null)
                        if (!utils.isArray(extender) && typeof extender == 'object' && extender !== null)
                        {
                                if (strict)                                     //FIXME: this is a sloppy workaround
                                {
                                        //if (base !== null && extender !== null)
                                        if (('value' in base) && !('value' in extender))
                                        {
                                                //console.log(extender,base);
                                                //base['value'] = extender;
                                                base['value'] = extendDefinition( extender, base['value'] );
                                                return base;
                                        }
                                }
 
                                for (var a in extender)
                                {
                                        if (strict)                             //strict mode will not allow the extender to add fields to the base
                                        {       if (!(a in base))
                                                {       //console.log("skipping "+a+" because it's not in the schema.");
                                                        continue;
                                                }
 
                                                //console.log(extender,base);
                                        }
 
                                        if (typeof base[a] == 'object')
                                                base[a] = extendDefinition( extender[a], base[a], strict );
                                                //base[a] = extendDefinition( extender[a], base[a] );   //FIXME: only use strict on the base extension?
                                        else
                                                base[a] = extender[a];
                                }
                        }
                        else
                        {       if ('value' in base)
                                        base["value"] = extender;               //case of a value being promoted to the value field of an aggregate object
                                else
                                        return extender;                        //or the case of a new value being introduced
                        }
 
                        return base;
                }
 
                var _definitions = {};          //these are global to the objectRegistry
                var _loaders = {};
 
                function objectLoader(basePath,strict)
                {
                        basePath = basePath || "";
 
                        this._basePath = utils.cleanPath( basePath );
                        this._strict = !!strict;
 
                        //this._definitions = {};
                        //this._loaders = {};
                }
 
                objectLoader.prototype = {
 
                        destroy:                function()
                                                {
                                                        //for (var p in this._loaders)
                                                        //      this._loaders[p].destroy();
 
                                                        //this._definitions = null;
                                                        //this._loaders = null;
                                                },
 
                        fetchDefinition:        function(path, data, callback)
                                                {
                                                        if (!path)
                                                        {       if (callback)
                                                                        return callback( this.applyDefinition(path,data) );
                                                                else
                                                                        return;
                                                        }
 
                                                        path = this._basePath + "/" + path;
                                                        path = utils.cleanPath(path);
                                                        data = data || {};
 
                                                        if (!(path in _definitions))
                                                                this.loadDefinition( path, data, callback );
                                                        else
                                                        {       //console.error("already loaded "+path);
                                                                if (callback)
                                                                        return callback( this.applyDefinition(path,data) );
                                                        }
                                                },
 
                        loadDefinition:         function(path, data, callback)
                                                {
                                                        path = utils.cleanPath(path);
 
                                                        //if (this._loaders[path])
                                                        if (!(path in _loaders))
                                                                _loaders[path] = new objectLoaderLoader( this, path, data, callback );
                                                        else
                                                                _loaders[path].enqueue( data, callback );
                                                },
 
                        loadedDefinition:       function(path, data)
                                                {
                                                        path = utils.cleanPath(path);
 
                                                        //console.log("Loaded definition: "+path,data);
                                                        _definitions[ path ] = data;
                                                },
 
                        applyDefinition:        function( path, data )
                                                {
                                                        path = utils.cleanPath(path);
 
                                                        var base = utils.copyObject( _definitions[path] );
                                                        return extendDefinition( data, base, this._strict );
                                                },
 
                        applyValues:            function( values, definition )
                                                {
                                                        var t,b;
 
                                                        if (definition === null)
                                                                return values;
 
                                                        //if (typeof values === 'object')
                                                        if (!utils.isArray(values) && typeof values == 'object')
                                                        {       for (var a in values)
                                                                {
                                                                        var v = values[a];
                                                                        var aa = a.split('.');
 
                                                                        if (aa.length > 1)
                                                                        {
                                                                                t = v;
                                                                                a = aa.shift();
                                                                                b = aa.join('.');
                                                                                v = {};
                                                                                v[b] = t;
                                                                        }
 
                                                                        if (!(a in definition) && ('value' in definition) && (typeof definition['value'] == 'object'))
                                                                        {
                                                                                if (a.split('.',2)[0] in definition['value'])
                                                                                        v = values;
 
                                                                                definition['value'] = this.applyValues( v, definition['value'] );
                                                                        }
                                                                        else if (typeof definition[a] == 'object')
                                                                                definition[a] = this.applyValues( v, definition[a] );
                                                                        else
                                                                                definition[a] = v;
                                                                }
                                                        }
                                                        else
                                                        {       if ('value' in definition)
                                                                        definition['value'] = values;
                                                                else
                                                                        return values;
                                                        }
 
                                                        return definition;
                                                },
                }
 
                function objectLoaderLoader(factory, path, data, callback)
                {
                        path = utils.cleanPath(path);
 
                        this._factory = factory;
                        this._path = path;
                        this._callbacks = [ { data:data, callback:callback } ];
                        this._subscribed = false;
 
                        //console.error(path);
                        //_objectRegistry.registerObject( path, this );
                        //console.log(this._path);
 
                        _objectRegistry.readPath( path, this );
 
                        this._timeout = setTimeout( this.timeout.bind(this), 60000 );   //timeout in one minute
                }
 
                objectLoaderLoader.prototype = {
 
                        destroy:                function()
                                                {
                                                        //console.log("destroying objectLoaderLoader: "+this._path);
 
                                                        //_objectRegistry.unregisterObject( this._path, this );
 
                                                        if (this._timeout)
                                                        {       clearTimeout( this._timeout );
                                                                this._timeout = null;
                                                        }
 
 
                                                        delete _loaders[this._path];
 
                                                        this._factory = null;
                                                        this._callbacks = [];
                                                },
 
                        timeout:                function()
                                                {
                                                        console.warn( "Timeout on "+this._path );
                                                        console.log(this);
                                                },
 
                        applyRead:              function(path,data,metadata)
                                                {
                                                        return this.applySubscription(data,metadata);
                                                },
 
                        applySubscription:      function(data,metadata)
                                                {
                                                        if (this._subscribed)
                                                        {       console.warn("already subscribed: "+this._path)
                                                                return;
                                                        }
 
                                                        this._subscribed = true;
 
                                                        if (!this._callbacks.length)
                                                        {       console.error("objectLoaderLoader has no callbacks... don't know what to do with the subscription!");
                                                                return;
                                                        }
 
                                                        var base = data.base;
 
                                                        if (base)
                                                                this._factory.fetchDefinition( base, data, this.loaded.bind(this) );
                                                        else
                                                                this.loaded(data);
                                                },
 
                        enqueue:                function(data,callback)
                                                {
                                                        this._callbacks.push( { data:data, callback:callback } );
                                                },
 
                        loaded:                 function(data)
                                                {
                                                        this._factory.loadedDefinition( this._path, data );
 
                                                //      this.unqueueCallback();                                         //use this to let the interface breathe during a long load.
                                                //      return;
 
                                                        for (var i=0;i<this._callbacks.length;i++)
                                                        {       var c = this._callbacks[i];
                                                                if (c.callback)
                                                                        c.callback( this._factory.applyDefinition( this._path, c.data) );
                                                        }
 
                                                        this.destroy();
 
                                                        /*
                                                        var THIS = this;
                                                        setTimeout( function() {
                                                                console.log(_definitions);
                                                                console.log(_loaders);
                                                        }, 100 );
                                                        */
                                                },
 
                        unqueueCallback:        function()
                                                {
                                                        if (this._callbacks.length)
                                                        {
                                                                var c = this._callbacks.shift();
                                                                if (c.callback)
                                                                        c.callback( this._factory.applyDefinition( this._path, c.data ) );
                                                        }
 
                                                        if (this._callbacks.length)
                                                                //setTimeout( this.unqueueCallback.bind(this),0 );
                                                                requestAnimationFrame( this.unqueueCallback.bind(this) );
                                                        else
                                                                this.destroy();
                                                }
                }
 
                _objectRegistry = new objectRegistry();
                _objectRegistry.objectLoader = objectLoader;
                _objectRegistry.extendDefinition = extendDefinition;
 
                return _objectRegistry;
        }
);