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);
}
void producer(qi::Promise<int> pro) {
qi::os::msleep(100);
pro.setValue(42);
}
void operator()(const T& value)
{
result.setValue(value);
}
void onStop()
{
_stopped = true;
_sync.setValue(0);
}
void unlock(qi::Promise<int> prom, bool* tag)
{
*tag = true;
prom.setValue(1);
}