summaryrefslogtreecommitdiff
path: root/matlab/src
diff options
context:
space:
mode:
Diffstat (limited to 'matlab/src')
-rw-r--r--matlab/src/Future.cpp106
-rw-r--r--matlab/src/Future.h37
-rw-r--r--matlab/src/ObjectPrx.cpp113
-rw-r--r--matlab/src/ice.h9
4 files changed, 149 insertions, 116 deletions
diff --git a/matlab/src/Future.cpp b/matlab/src/Future.cpp
index e6568e19789..72ca51aad88 100644
--- a/matlab/src/Future.cpp
+++ b/matlab/src/Future.cpp
@@ -18,18 +18,51 @@ void
IceMatlab::Future::token(function<void()> t)
{
lock_guard<mutex> lock(_mutex);
- if(!isFinished())
+ if(stateImpl() != State::Finished)
{
_token = std::move(t);
}
}
bool
-IceMatlab::Future::waitUntilFinished()
+IceMatlab::Future::waitForState(State state, double timeout)
{
unique_lock<mutex> lock(_mutex);
- _cond.wait(lock, [this]{ return this->isFinished(); });
- return !_exception;
+ if(timeout < 0)
+ {
+ _cond.wait(lock, [this, state]{ return state == this->stateImpl(); });
+ return !_exception;
+ }
+ else
+ {
+ auto now = chrono::system_clock::now();
+ auto stop = now + chrono::milliseconds(static_cast<long long>(timeout * 1000));
+ bool b = _cond.wait_until(lock, stop, [this, state]{ return state == this->stateImpl(); });
+ return b && !_exception;
+ }
+}
+
+bool
+IceMatlab::Future::waitForState(const string& s, double timeout)
+{
+ State state;
+ if(s == "running")
+ {
+ state = State::Running;
+ }
+ else if(s == "sent")
+ {
+ state = State::Sent;
+ }
+ else if(s == "finished")
+ {
+ state = State::Finished;
+ }
+ else
+ {
+ throw std::invalid_argument("state must be one of 'running', 'sent' or 'finished'");
+ }
+ return waitForState(state, timeout);
}
void
@@ -53,6 +86,26 @@ IceMatlab::Future::sent()
{
}
+string
+IceMatlab::Future::state() const
+{
+ lock_guard<mutex> lock(const_cast<mutex&>(_mutex));
+ string st;
+ switch(stateImpl())
+ {
+ case State::Running:
+ st = "running";
+ break;
+ case State::Sent:
+ st = "sent";
+ break;
+ case State::Finished:
+ st = "finished";
+ break;
+ }
+ return st;
+}
+
void
IceMatlab::Future::cancel()
{
@@ -68,7 +121,7 @@ IceMatlab::Future::cancel()
// SimpleFuture
//
IceMatlab::SimpleFuture::SimpleFuture() :
- _done(false)
+ _state(State::Running)
{
}
@@ -76,30 +129,23 @@ void
IceMatlab::SimpleFuture::done()
{
lock_guard<mutex> lock(_mutex);
- _done = true;
+ _state = State::Finished;
_cond.notify_all();
}
-string
-IceMatlab::SimpleFuture::state() const
+IceMatlab::Future::State
+IceMatlab::SimpleFuture::stateImpl() const
{
- lock_guard<mutex> lock(const_cast<mutex&>(_mutex));
- if(_exception || _done)
+ if(_exception)
{
- return "finished";
+ return State::Finished;
}
else
{
- return "running";
+ return _state;
}
}
-bool
-IceMatlab::SimpleFuture::isFinished() const
-{
- return _done || _exception;
-}
-
extern "C"
{
@@ -111,13 +157,25 @@ Ice_SimpleFuture_unref(void* self)
}
mxArray*
-Ice_SimpleFuture_wait(void* self, unsigned char* ok)
+Ice_SimpleFuture_wait(void* self)
{
- // TBD: Timeout?
+ bool b = deref<SimpleFuture>(self)->waitForState("finished", -1);
+ return createResultValue(createBool(b));
+}
- bool b = deref<SimpleFuture>(self)->waitUntilFinished();
- *ok = b ? 1 : 0;
- return 0;
+mxArray*
+Ice_SimpleFuture_waitState(void* self, mxArray* st, double timeout)
+{
+ try
+ {
+ string s = getStringFromUTF16(st);
+ bool b = deref<SimpleFuture>(self)->waitForState(s, timeout);
+ return createResultValue(createBool(b));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
}
mxArray*
@@ -137,7 +195,7 @@ mxArray*
Ice_SimpleFuture_check(void* self)
{
auto f = deref<SimpleFuture>(self);
- if(!f->waitUntilFinished())
+ if(!f->waitForState(Future::State::Finished, -1))
{
assert(f->getException());
try
diff --git a/matlab/src/Future.h b/matlab/src/Future.h
index 0b6858bffb9..d631fd9904b 100644
--- a/matlab/src/Future.h
+++ b/matlab/src/Future.h
@@ -17,18 +17,22 @@ class Future
public:
void token(std::function<void()>);
- bool waitUntilFinished();
+
+ enum State { Running, Sent, Finished };
+
+ bool waitForState(State, double);
+ bool waitForState(const std::string&, double);
virtual void exception(std::exception_ptr);
std::exception_ptr getException() const;
virtual void sent();
- virtual std::string state() const = 0;
+ virtual std::string state() const;
void cancel();
protected:
- virtual bool isFinished() const = 0;
+ virtual State stateImpl() const = 0;
std::mutex _mutex;
std::condition_variable _cond;
@@ -37,27 +41,6 @@ protected:
std::exception_ptr _exception; // If a local exception occurs.
};
-//
-// For invocations that are considered completed when sent.
-//
-class SentFuture : public Future
-{
-public:
-
- SentFuture();
-
- virtual void sent();
- virtual std::string state() const;
-
-protected:
-
- virtual bool isFinished() const;
-
-private:
-
- bool _sent;
-};
-
class SimpleFuture : public Future
{
public:
@@ -66,15 +49,13 @@ public:
void done();
- virtual std::string state() const;
-
protected:
- virtual bool isFinished() const;
+ virtual State stateImpl() const;
private:
- bool _done;
+ State _state;
};
}
diff --git a/matlab/src/ObjectPrx.cpp b/matlab/src/ObjectPrx.cpp
index db6ebb65c0e..9ecc9abab56 100644
--- a/matlab/src/ObjectPrx.cpp
+++ b/matlab/src/ObjectPrx.cpp
@@ -28,7 +28,6 @@ public:
virtual void exception(exception_ptr);
virtual void sent();
- virtual string state() const;
void finished(const std::shared_ptr<Ice::Communicator>&, const Ice::EncodingVersion&, bool,
std::pair<const Ice::Byte*, const Ice::Byte*>);
@@ -36,12 +35,11 @@ public:
protected:
- virtual bool isFinished() const;
+ virtual State stateImpl() const;
private:
const bool _twoway;
- enum State { Running, Sent, Finished };
State _state;
bool _ok; // True for success, false for user exception.
vector<Ice::Byte> _data;
@@ -90,26 +88,6 @@ InvocationFuture::finished(const std::shared_ptr<Ice::Communicator>& communicato
_cond.notify_all();
}
-string
-InvocationFuture::state() const
-{
- lock_guard<mutex> lock(const_cast<mutex&>(_mutex));
- string st;
- switch(_state)
- {
- case State::Running:
- st = "running";
- break;
- case State::Sent:
- st = "sent";
- break;
- case State::Finished:
- st = "finished";
- break;
- }
- return st;
-}
-
void
InvocationFuture::getResults(bool& ok, pair<const Ice::Byte*, const Ice::Byte*>& p)
{
@@ -127,44 +105,28 @@ InvocationFuture::getResults(bool& ok, pair<const Ice::Byte*, const Ice::Byte*>&
}
}
-bool
-InvocationFuture::isFinished() const
+Future::State
+InvocationFuture::stateImpl() const
{
- return _state == State::Finished;
+ return _state;
}
class GetConnectionFuture : public Future
{
public:
- virtual string state() const;
-
void finished(shared_ptr<Ice::Connection>);
shared_ptr<Ice::Connection> getConnection() const;
protected:
- virtual bool isFinished() const;
+ virtual State stateImpl() const;
private:
shared_ptr<Ice::Connection> _connection;
};
-string
-GetConnectionFuture::state() const
-{
- lock_guard<mutex> lock(const_cast<mutex&>(_mutex));
- if(_exception || _connection)
- {
- return "finished";
- }
- else
- {
- return "running";
- }
-}
-
void
GetConnectionFuture::finished(shared_ptr<Ice::Connection> con)
{
@@ -181,10 +143,17 @@ GetConnectionFuture::getConnection() const
return _connection;
}
-bool
-GetConnectionFuture::isFinished() const
+Future::State
+GetConnectionFuture::stateImpl() const
{
- return _connection || _exception;
+ if(_exception || _connection)
+ {
+ return State::Finished;
+ }
+ else
+ {
+ return State::Running;
+ }
}
static const char* invokeResultFields[] = {"ok", "params"};
@@ -1155,21 +1124,32 @@ Ice_InvocationFuture_id(void* self, unsigned long long* id)
}
mxArray*
-Ice_InvocationFuture_wait(void* self, unsigned char* ok)
+Ice_InvocationFuture_wait(void* self)
{
- // TBD: Timeout?
+ bool b = deref<InvocationFuture>(self)->waitForState(Future::State::Finished, -1);
+ return createResultValue(createBool(b));
+}
- bool b = deref<InvocationFuture>(self)->waitUntilFinished();
- *ok = b ? 1 : 0;
- return 0;
+mxArray*
+Ice_InvocationFuture_waitState(void* self, mxArray* st, double timeout)
+{
+ try
+ {
+ string state = getStringFromUTF16(st);
+ bool b = deref<InvocationFuture>(self)->waitForState(state, timeout);
+ return createResultValue(createBool(b));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
}
mxArray*
Ice_InvocationFuture_results(void* self)
{
- // TBD: Timeout?
auto f = deref<InvocationFuture>(self);
- if(!f->waitUntilFinished())
+ if(!f->waitForState(Future::State::Finished, -1))
{
assert(f->getException());
try
@@ -1220,7 +1200,7 @@ mxArray*
Ice_InvocationFuture_check(void* self)
{
auto f = deref<InvocationFuture>(self);
- if(!f->waitUntilFinished())
+ if(!f->waitForState(Future::State::Finished, -1))
{
assert(f->getException());
try
@@ -1260,21 +1240,32 @@ Ice_GetConnectionFuture_id(void* self, unsigned long long* id)
}
mxArray*
-Ice_GetConnectionFuture_wait(void* self, unsigned char* ok)
+Ice_GetConnectionFuture_wait(void* self)
{
- // TBD: Timeout?
+ bool b = deref<GetConnectionFuture>(self)->waitForState(Future::State::Finished, -1);
+ return createResultValue(createBool(b));
+}
- bool b = deref<GetConnectionFuture>(self)->waitUntilFinished();
- *ok = b ? 1 : 0;
- return 0;
+mxArray*
+Ice_GetConnectionFuture_waitState(void* self, mxArray* st, double timeout)
+{
+ try
+ {
+ string state = getStringFromUTF16(st);
+ bool b = deref<GetConnectionFuture>(self)->waitForState(state, timeout);
+ return createResultValue(createBool(b));
+ }
+ catch(const std::exception& ex)
+ {
+ return createResultException(convertException(ex));
+ }
}
mxArray*
Ice_GetConnectionFuture_fetch(void* self, void** con)
{
- // TBD: Timeout?
auto f = deref<GetConnectionFuture>(self);
- if(!f->waitUntilFinished())
+ if(!f->waitForState(Future::State::Finished, -1))
{
assert(f->getException());
try
diff --git a/matlab/src/ice.h b/matlab/src/ice.h
index d36b7da3e82..d958c8a5c4b 100644
--- a/matlab/src/ice.h
+++ b/matlab/src/ice.h
@@ -111,20 +111,23 @@ ICE_MATLAB_API mxArray* Ice_ObjectPrx_ice_flushBatchRequestsAsync(void*, void**)
ICE_MATLAB_API mxArray* Ice_ObjectPrx_clone(void*, void**);
ICE_MATLAB_API mxArray* Ice_InvocationFuture_unref(void*);
-ICE_MATLAB_API mxArray* Ice_InvocationFuture_wait(void*, unsigned char*);
+ICE_MATLAB_API mxArray* Ice_InvocationFuture_wait(void*);
+ICE_MATLAB_API mxArray* Ice_InvocationFuture_waitState(void*, mxArray*, double);
ICE_MATLAB_API mxArray* Ice_InvocationFuture_results(void*);
ICE_MATLAB_API mxArray* Ice_InvocationFuture_state(void*);
ICE_MATLAB_API mxArray* Ice_InvocationFuture_cancel(void*);
ICE_MATLAB_API mxArray* Ice_InvocationFuture_check(void*);
ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_unref(void*);
-ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_wait(void*, unsigned char*);
+ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_wait(void*);
+ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_waitState(void*, mxArray*, double);
ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_fetch(void*, void**);
ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_state(void*);
ICE_MATLAB_API mxArray* Ice_GetConnectionFuture_cancel(void*);
ICE_MATLAB_API mxArray* Ice_SimpleFuture_unref(void*);
-ICE_MATLAB_API mxArray* Ice_SimpleFuture_wait(void*, unsigned char*);
+ICE_MATLAB_API mxArray* Ice_SimpleFuture_wait(void*);
+ICE_MATLAB_API mxArray* Ice_SimpleFuture_waitState(void*, mxArray*, double);
ICE_MATLAB_API mxArray* Ice_SimpleFuture_state(void*);
ICE_MATLAB_API mxArray* Ice_SimpleFuture_cancel(void*);
ICE_MATLAB_API mxArray* Ice_SimpleFuture_check(void*);
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-05 09:32:24 +0000