SoftBank Robotics documentation What's new in NAOqi 2.8?

qi::Object

Summary

Global Classes

Detailed Description

qi::AnyObject

qi::AnyObject is a specialization of qi::Object that provides type erasure on objects, similar to what qi::AnyValue does on values. It can only work on registered objects. We’ll use Graph::Drawer from the registering guide. You can make an qi::Object from a boost::shared_ptr.

qi::AnyObject obj = boost::make_shared<Graph::Drawer>();

qi::Object uses a shared_ptr semantics, so the object will be destroyed when there are no more references to it. You can also get a qi::AnyObject from a session, another service, etc.

You can call a function with call or async if you want the call to be asynchronous. You can also connect signals and change properties.

// do a synchronous call
obj.call<bool>("draw", Graph::Point(10, 20), Graph::Green);

// do an ansynchronous call
qi::Future<bool> future =
  obj.async<bool>("draw", Graph::Point(10, 20), Graph::Green);
// do stuff...
future.wait();

// connect a signal and disconnect it
int id = obj.connect("drawDone", &mycallback);
obj.disconnect(id);

// set a property and get it
obj.setProperty("origin", Graph::Point(0, 12));
Graph::Point p = obj.property<Graph::Point>("origin");
std::cout << p.y << std::endl; // 12

Signal Connection

When connecting a callback, as usual, the signature of the callback must match the signature of the signal. But since we are in a type-erased context, if this rule is not respected, the error will only appear (in the logs) when the signal is triggered, not at compile-time or at the connection.

Furthermore, the connect() function expects any type of boost::function since we don’t know that until runtime, so it must be explicitly cast to the correct type, particularly in case of boost::bind.

// this works because mycallback has a specific signature
obj.connect("drawDone", &mycallback);

// this fails at compile time because boost::bind does not force a signature
obj.connect("drawDone", boost::bind(mycallback, _1));

// this works, you must specify the signature expected by the signal
obj.connect("drawDone",
    boost::function<void(const Point&)>(boost::bind(mycallback, _1)));

qi::Object<T>

qi::Object can be specialized with T if the object is T or inherits from T.

qi::Object<Graph::Drawer> obj = boost::make_shared<Graph::Drawer>();
obj->draw(Graph::Point(11, 12), Graph::Green);

qi::Object‘s specializations do not work with remote objects yet.

Passing an object as argument

Some methods in the services you will use expect an object as argument, for instance Logger::addListener(Object<LogListener> listener);. To call this method, you must first implement the LogListener interface into your own class, and then wrap a pointer to an instance of this class into an Object<LogListener> or a qi::AnyObject that will take ownership of the pointer:

class MyLogListener: public LogListener
{
  // Implement LogListener interface
};

void someFunction()
{
  qi::AnyObject logger = session.service("Logger");
  qi::AnyObject o(boost::make_shared<LogListener>());
  logger.call("addListener", o);
}

In the example above, your instance of MyLogListener will be kept alive as long as the logger service holds a qi::AnyObject on it. The same holds true when returning objects.

Reference

typedef Object< Empty > AnyObject

qi::Object Class Reference

Introduction

More...

#include <qi/anyobject.hpp>

Public Functions

Object(GenericObject* go)
Object(T* ptr)
Object(GenericObject* go, boost::function<void(GenericObject*)> deleter)
Object(T* ptr, boost::function<void(T*)> deleter)
Object()
template<typename U>
Object(const Object<U>& o)
template<typename U>
Object<T>& operator=(const Object<U>& o)
Object(const Object& o)
Object<T>& operator=(const Object& o)
Object(const qi::Future<MaybeAnyObject>& fobj)
Object(const qi::FutureSync<MaybeAnyObject>& fobj)
template<typename U>
Object(GenericObject* go, boost::shared_ptr<U> other)
template<typename U>
Object(boost::shared_ptr<U> other)
bool operator<(const Object& b) const
template<typename U>
bool operator!=(const Object<U>& b) const
template<typename U>
bool operator==(const Object<U>& b) const
operator bool() const
operator Object<Empty>() const
boost::shared_ptr<T> asSharedPtr()
T& asT() const
T* operator->() const
T& operator*() const
bool unique() const
GenericObject* asGenericObject() const
void reset()
unsigned int use_count() const
ObjectTypeInterface* interface()
void checkT()
detail::ManagedObjectPtr managedObjectPtr()

const MetaObject& metaObject() const
qi::Future<AnyReference> metaCall(unsigned int method, const GenericFunctionParameters& params, MetaCallType callType, Signature returnSignature)
int findMethod(const std::string& name, const GenericFunctionParameters& parameters) const
qi::Future<AnyReference> metaCall(const std::string& nameWithOptionalSignature, const GenericFunctionParameters& params, MetaCallType callType, Signature returnSignature)
void metaPost(unsigned int event, const GenericFunctionParameters& params) const
void metaPost(const std::string& nameWithOptionalSignature, const GenericFunctionParameters& in) const
template<typename... Args>
()
template<typename FUNCTOR_TYPE>
qi::FutureSync<SignalLink> connect(const std::string& eventName, FUNCTOR_TYPE callback, MetaCallType threadingModel) const
qi::FutureSync<SignalLink> connect(const std::string& name, const SignalSubscriber& functor) const
qi::FutureSync<SignalLink> connect(unsigned int signal, const SignalSubscriber& subscriber) const
qi::FutureSync<SignalLink> connect(unsigned int signal, AnyObject target, unsigned int slot) const
qi::FutureSync<void> disconnect(SignalLink linkId) const
template<typename T>
qi::FutureSync<T> property(const std::string& name) const
template<typename T>
qi::FutureSync<void> setProperty(const std::string& name, const T& val) const
qi::FutureSync<AnyValue> property(unsigned int id) const
qi::FutureSync<void> setProperty(unsigned int id, const AnyValue& val) const
ExecutionContext* executionContext() const
bool isStatsEnabled() const
void enableStats(bool enable) const
ObjectStatistics stats() const
void clearStats() const
bool isTraceEnabled() const
void enableTrace(bool enable)
void forceExecutionContext(boost::shared_ptr<qi::ExecutionContext> ec)
template<typename R, typename... Args>
()
template<typename R, typename... Args>
()

Public Static Functions

void keepManagedObjectPtr(detail::ManagedObjectPtr)
void noDeleteT(T*)
void noDelete(GenericObject*)
void deleteGenericObjectOnly(GenericObject* obj)
template<typename U>
void deleteGenericObjectOnlyAndKeep(GenericObject* obj, U)
void deleteCustomDeleter(GenericObject* obj, boost::function<void(T*)> deleter)

Types

typedef typename boost::mpl::if_< typename boost::is_same< T, Empty >::type, None, Object< Empty >>::type MaybeAnyObject

Detailed Description

Type erased object that has a known interface T.

In case T is unknown, you can use qi::AnyObject which aliases to Object<qi::Empty>.

You can then use the object with type-erasure or call the object directly using the operator ->.

Functions Documentation

static void qi::Object<T>::keepManagedObjectPtr(detail::ManagedObjectPtr)
static void qi::Object<T>::noDeleteT(T*)
static void qi::Object<T>::noDelete(GenericObject*)
static void qi::Object<T>::deleteGenericObjectOnly(GenericObject* obj)
template<typename U>
static void qi::Object<T>::deleteGenericObjectOnlyAndKeep(GenericObject* obj, U)
static void qi::Object<T>::deleteCustomDeleter(GenericObject* obj, boost::function<void(T*)> deleter)
qi::Object<T>::Object(GenericObject* go)

These constructors take ownership of the underlying pointers. If a callback is given, it will be called instead of the default behavior of deleting the stored GenericObject and the underlying T object.

qi::Object<T>::Object(T* ptr)
qi::Object<T>::Object(GenericObject* go, boost::function<void(GenericObject*)> deleter)
qi::Object<T>::Object(T* ptr, boost::function<void(T*)> deleter)
qi::Object<T>::Object()
template<typename U>
qi::Object<T>::Object(const Object<U>& o)
template<typename U>
Object<T>& qi::Object<T>::operator=(const Object<U>& o)
qi::Object<T>::Object(const Object& o)
Object<T>& qi::Object<T>::operator=(const Object& o)
qi::Object<T>::Object(const qi::Future<MaybeAnyObject>& fobj)
qi::Object<T>::Object(const qi::FutureSync<MaybeAnyObject>& fobj)
template<typename U>
qi::Object<T>::Object(GenericObject* go, boost::shared_ptr<U> other)

Shares ref counter with other, which must handle the destruction of go.

template<typename U>
qi::Object<T>::Object(boost::shared_ptr<U> other)
bool qi::Object<T>::operator<(const Object& b) const
template<typename U>
bool qi::Object<T>::operator!=(const Object<U>& b) const
template<typename U>
bool qi::Object<T>::operator==(const Object<U>& b) const
qi::Object<T>::operator bool() const
qi::Object<T>::operator Object<Empty>() const
boost::shared_ptr<T> qi::Object<T>::asSharedPtr()
T& qi::Object<T>::asT() const
T* qi::Object<T>::operator->() const
T& qi::Object<T>::operator*() const
bool qi::Object<T>::unique() const
GenericObject* qi::Object<T>::asGenericObject() const
void qi::Object<T>::reset()
unsigned int qi::Object<T>::use_count() const
ObjectTypeInterface* qi::Object<T>::interface()
void qi::Object<T>::checkT()

Check tha value actually has the T interface.

detail::ManagedObjectPtr qi::Object<T>::managedObjectPtr()

const MetaObject& qi::detail::GenericObjectBounce<O>::metaObject() const
qi::Future<AnyReference> qi::detail::GenericObjectBounce<O>::metaCall(unsigned int method, const GenericFunctionParameters& params, MetaCallType callType = MetaCallType_Auto, Signature returnSignature = Signature()
int qi::detail::GenericObjectBounce<O>::findMethod(const std::string& name, const GenericFunctionParameters& parameters) const
qi::Future<AnyReference> qi::detail::GenericObjectBounce<O>::metaCall(const std::string& nameWithOptionalSignature, const GenericFunctionParameters& params, MetaCallType callType = MetaCallType_Auto, Signature returnSignature = Signature()
void qi::detail::GenericObjectBounce<O>::metaPost(unsigned int event, const GenericFunctionParameters& params) const
void qi::detail::GenericObjectBounce<O>::metaPost(const std::string& nameWithOptionalSignature, const GenericFunctionParameters& in) const
()
template<typename FUNCTOR_TYPE>
qi::FutureSync<SignalLink> qi::detail::GenericObjectBounce<O>::connect(const std::string& eventName, FUNCTOR_TYPE callback, MetaCallType threadingModel = MetaCallType_Auto) const
qi::FutureSync<SignalLink> qi::detail::GenericObjectBounce<O>::connect(const std::string& name, const SignalSubscriber& functor) const
qi::FutureSync<SignalLink> qi::detail::GenericObjectBounce<O>::connect(unsigned int signal, const SignalSubscriber& subscriber) const
qi::FutureSync<SignalLink> qi::detail::GenericObjectBounce<O>::connect(unsigned int signal, AnyObject target, unsigned int slot) const
qi::FutureSync<void> qi::detail::GenericObjectBounce<O>::disconnect(SignalLink linkId) const
template<typename T>
qi::FutureSync<T> qi::detail::GenericObjectBounce<O>::property(const std::string& name) const
template<typename T>
qi::FutureSync<void> qi::detail::GenericObjectBounce<O>::setProperty(const std::string& name, const T& val) const
qi::FutureSync<AnyValue> qi::detail::GenericObjectBounce<O>::property(unsigned int id) const
qi::FutureSync<void> qi::detail::GenericObjectBounce<O>::setProperty(unsigned int id, const AnyValue& val) const
ExecutionContext* qi::detail::GenericObjectBounce<O>::executionContext() const
bool qi::detail::GenericObjectBounce<O>::isStatsEnabled() const
void qi::detail::GenericObjectBounce<O>::enableStats(bool enable) const
ObjectStatistics qi::detail::GenericObjectBounce<O>::stats() const
void qi::detail::GenericObjectBounce<O>::clearStats() const
bool qi::detail::GenericObjectBounce<O>::isTraceEnabled() const
void qi::detail::GenericObjectBounce<O>::enableTrace(bool enable)
void qi::detail::GenericObjectBounce<O>::forceExecutionContext(boost::shared_ptr<qi::ExecutionContext> ec)
()
()