Question

Update 2:
I think this is a better explanation:

I have two callbacks, and each is filling up an array. I want to merge these arrays somehow. The naive way to do it is to wait until the arrays are filled, then merge with a for loop. I can’t do that because there’s no real way to check if the callbacks are “done”.

The next step might be something like this: Each time an object is downloaded by a callback, it checks the merge array (called mixed), and sees if it contains a “partner” object. If it does: then merge into that partner object. If it doesn’t, then insert that object.

I’m worried about race conditions: callback 1 sees the array is empty, decides to insert into it, but then control switches to callback 2, which inserts first. Callback 1 should now merge instead of insert, but when control switches back, it inserts instead.

What could help is if I could make an atomic “check and insert/merge” block of code. Is there a way to do that?

---

Update 1:
Now with code, and more words!

Thanks for your response, everyone. I went and tried to simplify the code as much as I could.

Words:

I have an array called mixed. Mixed should end up with: all objects of type (A), and if they have analogue objects of type (B) (also known as “private”s), they should be merged.

That means using two functions that use callbacks – getAllA and getAllB. Right now, I call both, wait a bit manually, then run a for loop that does that merging.

What I need to do is edit my code so that the merging happens in callbacks. However, I can’t think of a way to do that merging in a way that doesn’t create a race condition.

Naively, I might want to first fill up mixed with objects of type A, then go iterate through the B objects and merge them as needed. However, I can’t do that because there’s no way to see if you’re “done” with on(“contact_added”) in firebase. What I think I want is a concurrent array structure, but I don’t know how to use a built-in one. I’m worried about making my own because I don’t know how to check to if I did it wrong. Race conditions are tricky like that.

Now, the code:
Here are the scripts you need to reference:

And here’s what I paste into the javascript console:

    //Note: private ~~ B
    //      public ~ A

    var me = 'IWwypRHWpDmydd30o-v';
    var mixed = new Array();
    var mixedNames = new Array();
    var privates = new Object();

    var callbackB = function(snapshot){
        child = snapshot.val();
        privates[snapshot.name()] = child;
    };

    var callbackA = function(snapshot){
        var listRef = snapshot.ref();
        listRef.on('child_added', function (snapshot2) {
        child = snapshot2.val();
            mixedNames.push(snapshot2.name());
            mixed.push(child);
      });
    };

    var getAllB = function (callback, ownerid){
        var priv = new Firebase('http://gamma.firebase.com/innermost/project/private/' + ownerid);
        priv.on('child_added', function (snapshot){
        callback(snapshot);
      });
    };

    function getAllA(callback) {
      var pub = new Firebase('http://gamma.firebase.com/innermost/project/public');
      pub.once('value', function (snapshot) {
        if (snapshot.val() === null) {
          alert('snapshot does not exist.');
        }
        callback(snapshot);
      });
    }

    getAllA(callbackA);
    getAllB(callbackB, me);

    //////wait

    for (b in privates){
        var index = $.inArray(b, mixedNames);
        if (index < 0){ //if there is no record with this name
            mixed.push(privates[b]);
            mixedNames.push(b);
        }
        else{
            var pub = mixed[index];
            var mutt = returnMixed(pub, privates[b]);
            mixed.splice(index,1,mutt);
        }
    };

What I want to do is move the logic from the for loop into the callbacks, because if you run the for loop right away, the arrays won’t be done downloading through the callbacks yet.

---

The old entry:

I have two callbacks accessing lists of data on Firebase.

Callback 1 gets objects of type A.
Callback 2 gets objects of type B.

My goal – have an array that properly merges objects of type A and B.

Most (but necessarily all) objects of type B have a “partner” object of type A.
A few objects of type A have a partner object of type B.

For each object pulled from Firebase, I want to see if their partner is in the array. If not, then insert. If so, then “merge” with the partner instead.

I can’t think of a way to do this without a concurrent data structure – but I don’t know how to do that in Javascript.

How can I either create that concurrent Array, or figure out a way to achieve my goal some other way?

Answer 1

<script src="underscore.js"></script> <!-- or the lib of your choice -->
<script>

   function addWithPartner( value, id, type ) {
      var indexOfPartner = _.find(values, function(partner, i) {
         // logic for determining what a partner is goes here
         // for example: 
         return value.name == partner.name;
      });

      if( indexOfPartner >= 0 ) {
         merge( values, indexOfPartner, value );
      }
      else {
         values.push( value );
      }
   }

   function merge( list, index, value ) {
      // do whatever merge means here
      // for example:
      _.extend( list[index], value );
   }

   var FB = new Firebase(YOUR_URL);
   var values = [];

   FB.child('TYPEA').on('child_added', function(snapshot) {
      addWithPartner( snapshot.val(), snapshot.name(), 'typeA' );
   });

   FB.child('TYPEB').on('child_added', function(snapshot) {
      addWithPartner( snapshot.val(), snapshot.name(), 'typeB' );
   });

</script>