0
var promise = $.when(sba_dfd.promise(), sbb_dfd.promise(), sbc_dfd.promise(), sbd_dfd.promise(), sbe_dfd.promise());
if (sbf_dfd.state() || sbg_dfd.state() == "resolved") {promise.state()=="rejected"};

What is worng in this statement? I guess it's syntax, but I just can't put my finger on it.

rudolf
  • 61
  • 1
  • 7
  • `promise.state()=="rejected"` you probably meant `promise.state()="rejected"`, however even that won't work. `$.when` returns a promise object, promise objects can't be manually resolved or rejected unless you have access to the originating deferred object. – Kevin B Nov 14 '12 at 18:18
  • Explain the logic behind your code and we may be able to suggest a way to accomplish it. – Kevin B Nov 14 '12 at 18:20
  • It goes like this: `var promise` is a batch of `divs`, which must be `resolved` to continue. But if `sbf` and `sbg` are `resolved`, the `var promise` should go invalid, therefore `rejected`. Something like that. – rudolf Nov 14 '12 at 19:44
  • You will need to create your own deferred object, you need more control than a promise object can give you. – Kevin B Nov 14 '12 at 19:45
  • Deferred stating all the `var promise` promises? – rudolf Nov 14 '12 at 19:46
  • no, such as `var deferredObj = $.Deferred()`; then you can resolve or reject that whenever you see fit with `deferredObj.resolve()` or `deferredObj.reject()` – Kevin B Nov 14 '12 at 19:51

1 Answers1

0

I think this can be solved with some inverse resolution logic, ie. a Deferred object that is resolved in response to a rejection and vice versa.

First a function to do the inversion :

function inverse_resolve(promise) {
    var dfrd = $.Deferred();
    promise.done(dfrd.reject).fail(dfrd.resolve);
    return dfrd.promise();
}

Now, we can compose a fairly conventional when() expression that responds normally to sba, sbb, sbc, sbd, sbe but to the inverse state of sbf and sbg.

$.when(sba_dfd, sbb_dfd, sbc_dfd, sbd_dfd, sbe_dfd, inverse_resolve(sbf_dfd), inverse_resolve(sbg_dfd)).done(function() {
    //do something
});

For clarity, I have left out .promise() in each case. In practice, .promise() isn't necessary as .when() will respond to Deferreds in the same way it responds to promises.

As I say, I think this will work. It's completely untested.

Beetroot-Beetroot
  • 18,022
  • 3
  • 37
  • 44