Building subscribe

Author: Josema

src/core/constructors/node.js

@@ -2,12 +2,12 @@
 dop.core.node = function() {
     // Inherit emitter
     dop.util.merge(this, new dop.util.emitter); //https://jsperf.com/inheritance-call-vs-object-assign
-    this.object_owned = {};
-    this.object_subscribed = {};
+    this.connected = false;
     this.request_inc = 1;
     this.requests = {};
     this.requests_queue = [];
-    this.connected = false;
+    this.object_subscribed = {};
+    this.object_owner = {};
     // Generating token
     do { this.token = dop.util.uuid() }
     while (typeof dop.data.node[this.token]=='object');

src/core/protocol/registerObjectToNode.js

@@ -1,14 +1,24 @@
 
 dop.core.registerObjectToNode = function(node, object) {
-    var object_id = dop.getObjectId(object),
-        object_data = dop.data.object_data[object_id];
+
+    var object_id = dop.getObjectId(object), object_data;
+
+    if (dop.data.object[object_id] === undefined)
+        dop.data.object[object_id] = {
+            object: object,
+            nodes_total: 0,
+            node: {}
+        };
+    
+    object_data = dop.data.object[object_id];
 
     if (object_data.node[node.token] === undefined) {
-        object_data.node[node.token] = true;
-        object_data.nodes += 1;
-        node.object_subscribed[object_id] = true;
-        return true;
+        object_data.nodes_total += 1;
+        object_data.node[node.token] = {
+            subscribed: false, 
+            owner: false
+        };
     }
-    else
-        return false;
+
+    return object_data;
 };

src/core/protocol/registerOwner.js

@@ -0,0 +1,7 @@
+
+dop.core.registerOwner = function(node, object, object_owner_id) {
+    var object_data = dop.core.registerObjectToNode(node, object),
+        object_id = dop.getObjectId(object_data.object);
+    object_data.node[node.token].owner = true;
+    node.object_owner[object_owner_id] = object_id;
+};

src/core/protocol/registerSubscriber.js

@@ -0,0 +1,12 @@
+
+dop.core.registerSubscriber = function(node, object) {
+    var object_data = dop.core.registerObjectToNode(node, object),
+        object_id = dop.getObjectId(object_data.object);
+    node.object_subscribed[object_id] = true;
+    if (object_data.node[node.token].subscribed)
+        return false;
+    else {
+        object_data.node[node.token].subscribed = true;
+        return true;
+    }
+};

src/core/protocol/unregisterNode.js

@@ -1,11 +1,25 @@
 
 dop.core.unregisterNode = function(node) {
-    var object_id, object_data;
+    var object_id, object_owner_id, object_data;
+    // Removing subscribed objects
     for (object_id in node.object_subscribed) {
-        object_data = dop.data.object_data[object_id];
-        // Deleting instance inside of dop.data.object_data
-        object_data.nodes -= 1;
-        delete object_data.node[node.token];
+        object_data = dop.data.object[object_id];
+        if (object_data.node[node.token] !== undefined) {
+            object_data.nodes_total -= 1;
+            delete object_data.node[node.token];
+        }
     }
-    delete dop.data.node[ node.token ];
+    // Removing owner objects
+    for (object_owner_id in node.object_owner) {
+        object_id = node.object_owner[object_owner_id];
+        object_data = dop.data.object[object_id];
+        if (object_data.node[node.token] !== undefined) {
+            object_data.nodes_total -= 1;
+            delete object_data.node[node.token];
+        }
+    }
+    // Deleting object data if not more nodes are depending
+    if (object_data.nodes_total === 0)
+        delete dop.data.object[object_id];
+    delete dop.data.node[node.token];
 };

src/dop.js

@@ -10,7 +10,6 @@ var dop = {
         node:{},
         object_inc:1,
         object:{},
-        object_data:{},
         collectors:[[],[]],
         // lastGet:{}
     },

src/protocol/_onsubscribe.js

@@ -8,19 +8,20 @@ dop.protocol._onsubscribe = function(node, request_id, request, response) {
 
         else {
             var object_path = response[1],
-                object_owned_id = object_path[0],
-                object_owned = response[2],
-                object, object_id;
-
-            if (node.object_owned[object_owned_id] === undefined) {
-                object = dop.register(object_owned);
-                object_id = dop.getObjectId(object);
-                node.object_owned[object_owned_id] = object_id;
-            }
-            else {
-                object_id = node.object_owned[object_owned_id];
-                object = dop.getObjectRootById(object_id);
+                object_owner_id = object_path[0],
+                object_owner = response[2],
+                object;
+
+            if (node.object_owner[object_owner_id] === undefined) {
+                object = dop.register((dop.isObjectRegistrable(request.into)) ? 
+                    dop.util.merge(request.into, object_owner)
+                :
+                    object_owner);
+                dop.core.registerOwner(node, object, object_owner_id);
             }
+            else
+                object = dop.data.object[node.object_owner[object_owner_id]].object;
+
 
             request.promise.resolve(dop.util.get(object, object_path.slice(1)));
         }

src/protocol/onsubscribe.js

@@ -3,15 +3,17 @@ dop.protocol.onsubscribe = function(node, request_id, request) {
 
     if (isFunction(dop.data.onsubscribe)) {
 
-        var args = Array.prototype.slice.call(request, 1), object, response;
+        var args = Array.prototype.slice.call(request, 1);
 
         dop.core.localProcedureCall(dop.data.onsubscribe, args, function resolve(value) {
             if (isObject(value)) {
-                object = dop.register(value);
-                var object_id = dop.getObjectId(object);
-                response = dop.core.createResponse(request_id, 0, dop.getObjectDop(object));
-                if (dop.core.registerObjectToNode(node, object))
-                    response.push(dop.getObjectRootById(object_id));
+                var object = dop.register(value),
+                    object_id = dop.getObjectId(object),
+                    object_root = dop.getObjectRoot(object),
+                    response = dop.core.createResponse(request_id, 0, dop.getObjectDop(object));
+
+                if (dop.core.registerSubscriber(node, object_root))
+                    response.push(object_root);
                 dop.core.sendResponse(node, response);
                 return object;
             }

src/protocol/subscribe.js

@@ -3,6 +3,11 @@ dop.protocol.subscribe = function(node, args) {
     args = Array.prototype.slice.call(args, 0);
     args.unshift(node, dop.protocol.instructions.subscribe);
     var request = dop.core.createRequest.apply(node, args);
+    request.promise.into = function(object) {
+        if (dop.isObjectRegistrable(object))
+            request.into = object;
+        return request.promise;
+    };
     dop.core.storeRequest(node, request);
     if (node.connected)
         dop.core.sendRequests(node);

test/transports/subscribe.js

@@ -22,8 +22,9 @@ var client = dopClient.connect({transport:transportConnect, listener:server});
         return {paco:'pil'};
     })
 
-    client.subscribe('PUBLIC').then(function(obj){
-        console.log( obj );
+    myobj = dopClient.register({mola:'mazo'})
+    client.subscribe('PUBLIC').into(myobj).then(function(obj){
+        console.log( obj===myobj );
     })