C++ Promise::setValue方法代码示例

void slowDisconnect(qi::Promise<void> ready, qi::Promise<void> done, qi::Future<void> wait, qi::AnyObject obj, boost::shared_ptr<qi::SignalLink> link)
{
  ready.setValue(0);
  wait.wait();
  try {
    obj.disconnect(*link);
  }
  catch (...) {}
  done.setValue(0);
}

void onFire2(const int& pl)
{
  if (pl)
    oclient1.async<void>("onFire1", pl-1);
  else
    payload.setValue(true);
}

 void operator()(int newValue)
 {
   if (newValue == targetValue)
   {
     running.setValue(true);
   }
 }

 void ServiceDirectoryClient::onSDEventConnected(qi::Future<SignalLink> future,
   qi::Promise<void> promise, bool isAdd)
 {
   if (promise.future().isFinished()) {
     return;
   }
   if (future.hasError())
   {
     qi::Future<void> fdc = onSocketDisconnected(future.error());
     fdc.connect(&qi::Promise<void>::setError, promise, future.error());
     return;
   }
   bool ready = false;
   {
     boost::mutex::scoped_lock lock(_mutex);
     if (isAdd)
       _addSignalLink = future.value();
     else
       _removeSignalLink = future.value();
     ready = _addSignalLink && _removeSignalLink;
   }
   if (ready)
   {
     promise.setValue(0);
     connected();
   }
 }

 static void onEventConnected(RemoteObject* ro, qi::Future<SignalLink> fut, qi::Promise<SignalLink> prom, SignalLink id) {
   if (fut.hasError()) {
     prom.setError(fut.error());
     return;
   }
   prom.setValue(id);
 }

 void serviceReady(qi::Future<void> fut, qi::Promise<unsigned int> result, unsigned int idx) {
   if (fut.hasError()) {
     result.setError(fut.error());
     return;
   }
   result.setValue(idx);
 }

static void call_from_java_cont(qi::Future<qi::AnyReference> ret,
    qi::Promise<qi::AnyValue> promise)
{
  if (ret.hasError())
    promise.setError(ret.error());
  else
    promise.setValue(qi::AnyValue(ret.value(), false, true));
}

 void RemoteObject::onMetaObject(qi::Future<qi::MetaObject> fut, qi::Promise<void> prom) {
   if (fut.hasError()) {
     qiLogVerbose() << "MetaObject error: " << fut.error();
     prom.setError(fut.error());
     return;
   }
   qiLogVerbose() << "Fetched metaobject";
   setMetaObject(fut.value());
   prom.setValue(0);
 }

  void SessionPrivate::listenStandaloneCont(qi::Promise<void> p, qi::Future<void> f)
  {
    if (f.hasError())
      p.setError(f.error());
    else
    {
      _sdClient.setServiceDirectory(boost::static_pointer_cast<ServiceBoundObject>(_sd._serviceBoundObject)->object());
      // _sdClient will trigger its connected, which will trigger our connected

      p.setValue(0);
    }
  }

 void log(const qi::LogLevel,
          const qi::Clock::time_point,
          const qi::SystemClock::time_point,
          const char*,
          const char*,
          const char*,
          const char*,
          int) {
   start.future().wait();
   if (++count == MAX)
     finished.setValue(0);
 }

 int f(int end, qi::Promise<void> finished)
 {
   int startval = prop.get();
   EXPECT_FALSE(calling);
   calling = true;
   qi::os::msleep(5);
   EXPECT_TRUE(calling);
   calling = false;
   EXPECT_EQ(startval, prop.get());
   if (++callcount == end + 1)
     finished.setValue(0);
   return 42;
 }

  void SessionPrivate::addSdSocketToCache(Future<void> f, const qi::Url& url,
                                          qi::Promise<void> p)
  {
    qiLogDebug() << "addSocketToCache processing";
    if (f.hasError())
    {
      qiLogDebug() << "addSdSocketToCache: connect reported failure";
      _serviceHandler.removeService("ServiceDirectory");
      p.setError(f.error());
      return;
    }

    // Allow the SD process to use the existing socket to talk to our services
    _serverObject.registerSocket(_sdClient.socket());

    /* Allow reusing the SD socket for communicating with services.
     * To do this, we must add it to our socket cache, and for this we need
     * to know the sd machineId
     */
     std::string mid;
     try
     {
       mid = _sdClient.machineId();
     }
     catch (const std::exception& e)
     { // Provide a nice message for backward compatibility
       qiLogVerbose() << e.what();
       qiLogWarning() << "Failed to obtain machineId, connection to service directory will not be reused for other services.";
       p.setValue(0);
       return;
     }
     TransportSocketPtr s = _sdClient.socket();
     qiLogVerbose() << "Inserting sd to cache for " << mid <<" " << url.str() << std::endl;
     _socketsCache.insert(mid, s->remoteEndpoint(), s);
     p.setValue(0);
  }

  void SessionPrivate::onTrackedServiceAdded(const std::string& actual,
      const std::string& expected,
      qi::Promise<void> promise,
      boost::shared_ptr<qi::Atomic<int> > link)
  {
    if (actual != expected)
      return;

    // only do it once in case of multiple calls
    SignalLink link2 = link->swap(0);

    if (link2 == 0)
      return;

    _sdClient.serviceAdded.disconnect(link2);

    promise.setValue(0);
  }

void testDelete(bool afirst, bool disconnectFirst, qi::Promise<void> end)
{
  qi::Promise<void> p0;
  qi::Promise<void> p1;
  qi::SignalLink fireId, onFireId, onFireId2;
  qi::AnyObject *a;
  qi::AnyObject *b;
  {
    qi::DynamicObjectBuilder oba, obb;
    fireId = oba.advertiseSignal<int>("fire");
    onFireId = obb.advertiseMethod("onFire", boost::function<void(int)>(boost::bind<void>(&onFire, _1, boost::ref(p0))));
    onFireId2 = obb.advertiseMethod("onFire2", boost::function<void(int)>(boost::bind<void>(&onFire2, _1, boost::ref(p1))));
    a = new qi::AnyObject(oba.object());
    b = new qi::AnyObject(obb.object());
  }
  qi::SignalLink linkId = (*a).connect(fireId, *b, onFireId);
  (*a).connect(fireId, *b, onFireId2);
  //std::vector<qi::SignalSubscriber> subs = (*a)->subscribers(fireId);
  //EXPECT_EQ(static_cast<unsigned int>(2), subs.size());
  // Subs ordering is unspecified
  //EXPECT_EQ(subs[0].method + subs[1].method, onFireId + onFireId2);
  lastPayload = 11;
  lastPayload2 = 11;
  (*a).post("fire", 12);
  EXPECT_TRUE(p0.future().hasValue(1000));
  EXPECT_TRUE(p1.future().hasValue(1000));
  EXPECT_EQ(12, *lastPayload);
  EXPECT_EQ(12, *lastPayload2);
  p0 = qi::Promise<void>();
  p1 = qi::Promise<void>();
  if (disconnectFirst)
  {
    (*a).disconnect(linkId);
    (*a).post("fire", 13);
    EXPECT_TRUE(p1.future().hasValue(1000));
    EXPECT_EQ(12, *lastPayload);
    EXPECT_EQ(13, *lastPayload2);
    p0 = qi::Promise<void>();
    p1 = qi::Promise<void>();
  }
  if (afirst)
  {
    delete a;
    delete b;
  }
  else
  {
    int e1 = *lastPayload, e2 = *lastPayload2;
    delete b;
    // wait for the object to be deleted (signal callbacks may still be
    // running)
    qi::os::msleep(10);
    (*a).post("fire", 12);
    EXPECT_EQ(e1, *lastPayload);
    EXPECT_EQ(e2, *lastPayload2);
    delete a;
  }
  ++completed;
  int next = *completed;
  if (next == 4)
  {
    end.setValue(0);
    return;
  }
  qi::getEventLoop()->post(
    boost::bind(&testDelete, !!((int)next/2), !!((int)next%2), end));
}

void onFire2(const int& pl, qi::Promise<void>& p)
{
  ++lastPayload2;
  p.setValue(0);
}