- Aldebaran documentation |
- C++ Libraries |
- index

libqi-api 2.8.7.4

- Main Page
- Related Pages
- Namespaces
- Classes
- Files
- Examples

- Namespace List
- Namespace Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
qi Namespace Reference

Deprecated in 2.5. Use int8_t from <cstdint>. More...

## Namespaces
| detail
| log
| Log functions with different levels of verbosity.
| measure
| os
| OS abstraction layer. .
| path
| Set of tools to handle SDK layouts.
| util
| version
| Version numbering API. .

## Classes
class | Actor
class | VarArguments
class | VarArguments< AnyValue >
class | CallableTypeInterface
| Signature information for both callable types FunctionTypeInterface and MethodType. More...
class | FunctionTypeInterface
struct | ArgumentTransformation
class | KeywordArguments
class | AnyArguments
| A function with AnyArguments as its sole argument will behave as if AnyFunction::fromDynamicFunction was called. More...
class | AnyFunction
class | GenericFunctionParameters
struct | ModuleInfo
class | AnyModule
class | ModuleBuilder
class | Application
| Class handling startup and teardown of an application. More...
class | ApplicationSession
struct | Atomic
class | AtomicFlagLock
struct | ObjectSerializationInfo
| Informations passed when serializing an object. More...
class | Buffer
| Class to store buffer. . More...
class | BufferReader
| Class to read const buffer. This class is intendeed to read buffer. It store an internal data cursor and an internal sub-buffer index. All offset are relative to the current position. More...
class | SteadyClock
| The SteadyClock class represents a monotonic clock. . More...
class | Clock
| The Clock class represents a system-wide clock, best suitable for timestamping events. Typically monotonic and unaffected by the system clock adjustment, altough this is not guaranteed. More...
class | SystemClock
| The SystemClock class represents the system-wide real time wall clock. It may not be monotonic: on most systems, the system time can be adjusted at any moment. More...
class | Future
struct | ExecutionOptions
| Represent execution behaviour options attached to a task that must be interpreted by an ExecutionContext. More...
class | ExecutionContext
struct | ToPost
struct | FutureValueConverter< void, void >
struct | FutureValueConverter< T, void >
struct | FutureValueConverter< void, T >
class | FutureSync
class | Promise
class | FutureException
class | FutureUserException
struct | FutureValueConverter
| Specialize this struct to provide conversion between future values. More...
struct | UnitFuture
struct | SrcFuture
class | FutureBarrier
| This class helps waiting for multiple futures at the same point. More...
class | EventLoop
| Class to handle eventloop. . More...
class | Flags
class | ScopedFutureGroup
struct | ExceptionLogError
class | AuthProvider
class | AuthProviderFactory
class | AutoService
class | ClientAuthenticator
class | ClientAuthenticatorFactory
class | AutoService< qi::AnyObject >
class | Gateway
class | ServiceDirectoryProxy
class | ServiceInfo
class | Path
| The Path class allow handling filesystem path in a cross-platform maner. The class assume that all string are encoded in UTF-8 if not specified otherwise. More...
class | DataPerf
| Class to compute and store a benchmark time. More...
class | DataPerfSuite
| A class to perform benchmarks. More...
class | PeriodicTask
| Control a task executed periodically and asynchronously. . More...
class | PropertyBase
class | PropertyImpl
class | UnsafeProperty
class | Property
class | GenericProperty
| Type-erased property, simulating a typed property but using AnyValue. More...
class | PtrUid
struct | SessionConfig
class | Session
class | SignalBase
class | Signal
class | SignalF
class | Signal< void >
struct | SignalSubscriberPrivate
class | SignalSpy
| A tool to track signal emissions, specialized for testing. A signal spy can acknowledge every signal emission of a given signal, type-erased or not. Every emission is recorded, so that they can be compared to expectations, or to produce a history. More...
class | Signature
class | MinMaxSum
| Stores min, max and sum of values fed to it. More...
class | MethodStatistics
| Store statistics about method calls. More...
class | StrandPrivate
class | Strand
struct | Infinity
class | TrackableBase
| Common base class to templates Trackable for compile-time detection. More...
class | Trackable
| Object tracking by blocking destruction while shared pointers are present. More...
class | PointerLockException
struct | TrackWithFallbackTransfo
struct | TrackSilentTransfo
class | Translator
| Localization of your source code. More...
struct | InfosKeyMask
class | FunctionTypeInterfaceEq
class | AnyIterator
class | AnyReference
class | AutoAnyReference
class | AnyValue
class | TypeImpl< AnyValue >
struct | FutureValueConverter< T, qi::AnyValue >
struct | FutureValueConverter< void, qi::AnyValue >
struct | boost_bind_result_type
struct | boost_bind_result_type< boost::_bi::bind_t< R, A, B > >
struct | boost_bind_parameter_types
struct | boost_bind_parameter_types< boost::_bi::bind_t< R, F, B > >
struct | boost_bind_function_type
class | TypeBufferImpl
class | TypeImpl< Buffer >
class | TypeImpl< boost::any >
class | GenericObject
class | TypeImpl< boost::shared_ptr< GenericObject > >
class | IntTypeInterfaceImpl
class | TypeBoolImpl
class | FloatTypeInterfaceImpl
class | ListTypeInterfaceImpl
class | TypeSimpleIteratorImpl
struct | TypeImpl< std::vector< T > >
struct | TypeImpl< std::list< T > >
struct | TypeImpl< std::set< T > >
class | VarArgsTypeInterfaceImpl
struct | TypeImpl< qi::VarArguments< T > >
class | EventTrace
class | Manageable
class | MapTypeInterfaceImpl
struct | TypeImpl< std::map< K, V, C, A > >
class | Empty
class | Object
class | WeakObject
class | TypeImpl< Object< T > >
class | OptionalTypeInterfaceImpl
class | TypeImpl< boost::optional< T > >
class | TypeImpl< boost::none_t >
class | PointerTypeInterfaceImpl
class | TypeImpl< T * >
class | TypeSharedPointerImpl
class | TypeImpl< boost::shared_ptr< T > >
class | Proxy
class | TypeProxy
class | StringTypeInterfaceImpl
class | TypeImpl< std::string >
class | TypeCStringImpl
class | TypeImpl< char * >
class | TypeImpl< char[I]>
class | TypeEquivalentString
class | StructTypeInterfaceBouncer
class | TypeImpl< std::pair< F, S > >
class | TraceAnalyzer
class | TypeOfTemplateImpl
class | TypeByPointer
| Access API that stores a T* in storage. More...
class | TypeByPointer< const T >
class | TypeByPointerPOD
class | TypeByValue
| Access api that stores a T in storage. More...
class | TypeByValue< const T >
class | DefaultTypeImplMethods
class | DefaultTypeImpl
class | TypeImpl
class | TypeImpl< void >
class | TypeImpl< T & >
class | TypeInfo
class | TypeInterface
class | DynamicObject
class | DynamicObjectBuilder
class | MetaMethodParameter
class | MetaMethod
| Representation of a method in an GenericObject. More...
class | MetaMethodBuilder
class | MetaObject
| Description of the signals and methods accessible on an ObjectTypeInterface. More...
struct | MemberAddInfo
class | MetaObjectBuilder
class | MetaProperty
class | MetaSignal
| Representation of a Signal in an GenericObject. More...
class | ObjectTypeBuilderBase
class | ObjectTypeBuilder
class | TypeOfTemplate< qi::Future >
class | TypeOfTemplate< qi::FutureSync >
class | TypeOfTemplateFutImpl
class | TypeOfTemplateImpl< qi::Future, T >
class | TypeOfTemplateImpl< qi::FutureSync, T >
class | TypeOfTemplate< qi::Promise >
class | TypeOfTemplateImpl< qi::Promise, T >
class | ProxyProperty
class | ProxySignal
| Signal proxy, using an AnyObject and signal id as backend. More...
class | IntTypeInterface
class | FloatTypeInterface
class | StringTypeInterface
class | RawTypeInterface
class | PointerTypeInterface
class | IteratorTypeInterface
class | ListTypeInterface
class | MapTypeInterface
class | StructTypeInterface
class | DynamicTypeInterface
class | VarArgsTypeInterface
class | OptionalTypeInterface
class | TypeImpl< qi::TypeInterface >
class | TypeImpl< qi::TypeInterface * >
class | ObjectTypeInterface
class | Url

## Typedefs
using | AnyVarArguments = VarArguments<>
using | DynamicFunction = boost::function< AnyReference(const AnyReferenceVector &)>
using | ModuleFactoryFunctor = boost::function< AnyModule(const qi::ModuleInfo &)>
using | AnyObject = Object< Empty >
using | ApplicationSessionOptions = ApplicationSession::Option
using | DeserializeObjectCallback = boost::function< AnyObject(const ObjectSerializationInfo &)>
| Type of callback invoked by sdeerializer when it encounters an object. More...
using | SerializeObjectCallback = boost::function< ObjectSerializationInfo(const AnyObject &)>
| Type of callback invoked by serializer when it encounters an object. More...
template<class Rep , class Ratio >
using | DurationType = boost::chrono::duration< Rep, Ratio >
| Convenience typedefs. More...
template<class ClockType >
using | TimePoint = boost::chrono::time_point< ClockType >
using | NanoSeconds = DurationType< int64_t, boost::nano >
using | MicroSeconds = DurationType< int64_t, boost::micro >
using | MilliSeconds = DurationType< int64_t, boost::milli >
using | Seconds = DurationType< int64_t, boost::ratio< 1 >>
using | Minutes = DurationType< int64_t, boost::ratio< 60 >>
using | Hours = DurationType< int64_t, boost::ratio< 3600 >>
using | Duration = NanoSeconds
using | SteadyClockTimePoint = SteadyClock::time_point
| Steady clock time point. More...
using | ClockTimePoint = Clock::time_point
| qi::Clock time point. More...
using | SystemClockTimePoint = SystemClock::time_point
| System clock time point. More...
using | FutureUniqueId = void *
template<typename A , typename B >
using | Either = boost::variant< A, B >
| Convenient alias to a variant of two types. More...
template<typename T >
using | VisitorBase = boost::static_visitor< T >
using | JsonOption = unsigned int
using | LogContext = int
| Logs context attribute value. More...
using | CapabilityMap = std::map< std::string, AnyValue >
using | AuthProviderPtr = boost::shared_ptr< AuthProvider >
using | AuthProviderFactoryPtr = boost::shared_ptr< AuthProviderFactory >
using | AnyAutoService = AutoService< qi::Empty >
using | ClientAuthenticatorPtr = boost::shared_ptr< ClientAuthenticator >
using | ClientAuthenticatorFactoryPtr = boost::shared_ptr< ClientAuthenticatorFactory >
using | ServiceInfoVector = std::vector< qi::ServiceInfo >
using | NumericPositiveOverflow = boost::numeric::positive_overflow
using | NumericNegativeOverflow = boost::numeric::negative_overflow
using | ObjectUid = PtrUid
using | PathVector = std::vector< Path >
using | codecvt_type = std::codecvt< wchar_t, char, std::mbstate_t >
| Standard std::codecvt type accepted by STL and boost. More...
using | SessionPtr = boost::shared_ptr< Session >
using | SignalLink = qi::uint64_t
using | SignalSubscriberPtr = boost::shared_ptr< SignalSubscriber >
using | SignatureVector = std::vector< Signature >
using | AnyReferenceVector = std::vector< AnyReference >
using | AnyValueVector = std::vector< AnyValue >
using | ObjectStatistics = std::map< unsigned int, MethodStatistics >
using | AnyWeakObject = WeakObject< Empty >
using | TypeIndex = boost::typeindex::type_index
using | MetaMethodParameterVector = std::vector< MetaMethodParameter >
using | int8_t = int8_t
using | int16_t = int16_t
using | int32_t = int32_t
using | int64_t = int64_t
using | uint8_t = uint8_t
using | uint16_t = uint16_t
using | uint32_t = uint32_t
using | uint64_t = uint64_t
using | UrlVector = std::vector< Url >
using | Uuid = boost::uuids::uuid
using | UuidRandomGenerator = boost::uuids::basic_random_generator< boost::random::random_device >

## Enumerations
enum | CancelOption { CancelOption::AllowSkipExecution, CancelOption::AlwaysSkipExecution, CancelOption::NeverSkipExecution }
| < If cancel have been requested for the associated scheduled task... More...
enum | FutureState { FutureState_None, FutureState_Running, FutureState_Canceled, FutureState_FinishedWithError, FutureState_FinishedWithValue }
enum | FutureCallbackType { FutureCallbackType_Sync = 0, FutureCallbackType_Async = 1, FutureCallbackType_Auto = 2 }
enum | FutureTimeout { FutureTimeout_Infinite = INT_MAX, FutureTimeout_None = 0 }
enum | AdaptFutureOption { AdaptFutureOption_None = 0, AdaptFutureOption_ForwardCancel = 1 }
enum | StreamColor { StreamColor_None = 0, StreamColor_Reset = 1, StreamColor_Bold = 2, StreamColor_Faint = 3, StreamColor_Standout = 4, StreamColor_Underline = 5, StreamColor_Blink = 6, StreamColor_Overline = 7, StreamColor_Black = 8, StreamColor_DarkRed = 9, StreamColor_DarkGreen = 10, StreamColor_Brown = 11, StreamColor_DarkBlue = 12, StreamColor_Purple = 13, StreamColor_Teal = 14, StreamColor_LightGray = 15, StreamColor_DarkGray = 16, StreamColor_Red = 17, StreamColor_Green = 18, StreamColor_Yellow = 19, StreamColor_Blue = 20, StreamColor_Fuchsia = 21, StreamColor_Turquoise = 22, StreamColor_White = 23 }
| The Stream Color enum. More...
enum | LogLevel { LogLevel_Silent = 0, LogLevel_Fatal, LogLevel_Error, LogLevel_Warning, LogLevel_Info, LogLevel_Verbose, LogLevel_Debug }
| Log level verbosity. More...
enum | LogColor { LogColor_Never, LogColor_Auto, LogColor_Always }
| Logs color mode. More...
enum | LogContextAttr { LogContextAttr_None = 0, LogContextAttr_Verbosity = 1 << 0, LogContextAttr_ShortVerbosity = 1 << 1, LogContextAttr_SystemDate = 1 << 2, LogContextAttr_Tid = 1 << 3, LogContextAttr_Category = 1 << 4, LogContextAttr_File = 1 << 5, LogContextAttr_Function = 1 << 6, LogContextAttr_Return = 1 << 7, LogContextAttr_Date = 1 << 8 }
| Logs context attribute. More...
enum | ObjectThreadingModel { ObjectThreadingModel_SingleThread = 0, ObjectThreadingModel_MultiThread = 1, ObjectThreadingModel_Default = ObjectThreadingModel_SingleThread }
| Possible thread models for an object. More...
enum | TypeKind { TypeKind_Unknown = 0, TypeKind_Void = 1, TypeKind_Int = 2, TypeKind_Float = 3, TypeKind_String = 4, TypeKind_List = 5, TypeKind_Map = 6, TypeKind_Object = 7, TypeKind_Pointer = 8, TypeKind_Tuple = 9, TypeKind_Dynamic = 10, TypeKind_Raw = 11, TypeKind_Iterator = 13, TypeKind_Function = 14, TypeKind_Signal = 15, TypeKind_Property = 16, TypeKind_VarArgs = 17, TypeKind_Optional = 18 }
enum | MetaCallType { MetaCallType_Auto = 0, MetaCallType_Direct = 1, MetaCallType_Queued = 2 }

## Functions
template<typename T >
FunctionTypeInterface * | makeFunctionTypeInterface ()
FunctionTypeInterface * | dynamicFunctionTypeInterface ()
bool | registerCppEmbeddedModule (const std::string &moduleName, boost::function< void(ModuleBuilder *)> fun)
std::vector< ModuleInfo > | listModules ()
AnyModule | import (const std::string &name)
AnyModule | import (const ModuleInfo &name)
bool | registerModuleFactory (const std::string &name, ModuleFactoryFunctor fun)
qi::Future< AnyReference > | metaCall (ExecutionContext *ec, ObjectThreadingModel objectThreadingModel, MetaCallType methodThreadingModel, MetaCallType callType, AnyObject manageable, unsigned int methodId, AnyFunction func, const GenericFunctionParameters &params, bool noCloneFirst=false, unsigned int callerId=0, qi::os::timeval postTimestamp=qi::os::timeval())
template<typename F >
auto | asyncAt (F &&callback, qi::SteadyClockTimePoint timepoint) -> decltype(qi::getEventLoop() ->asyncAt(std::forward< F >(callback), timepoint))
template<typename F >
auto | asyncDelay (F &&callback, qi::Duration delay) -> decltype(detail::asyncMaybeActor(std::forward< F >(callback), delay))
template<typename F >
auto | async (F &&callback) -> decltype(asyncDelay(std::forward< F >(callback), qi::Duration(0)))
template<typename R >
Future< R > | async (boost::function< R()> callback, uint64_t usDelay)
template<typename R >
Future< R > | async (boost::function< R()> callback, qi::Duration delay)
template<typename R >
Future< R > | async (boost::function< R()> callback, qi::SteadyClockTimePoint timepoint)
template<typename R >
Future< R > | async (detail::Function< R()> callback)
template<typename R , typename Func , typename ArgTrack >
QI_API_DEPRECATED qi::Future< R > | async (const Func &f, const ArgTrack &toTrack,...)
template<typename T , typename Duration >
Future< T > | cancelOnTimeout (Future< T > fut, Duration timeout)
long | testAndSet (long *cond)
bool | tryRaiseAtomicFlag (std::atomic< bool > &b)
bool | tryLowerAtomicFlag (std::atomic< bool > &b)
AtomicFlagLock | scopelock (std::atomic_flag &f)
| model ScopeLockable std::atomic_flag: More...
template<typename T >
T | src (const std::atomic< T > &x)
template<typename T >
AnyReference | decodeBinary (qi::BufferReader *buf, T *value, DeserializeObjectCallback onObject=DeserializeObjectCallback(), StreamContext *streamContext=0)
void | encodeBinary (qi::Buffer *buf, const AutoAnyReference &gvp, SerializeObjectCallback onObject=SerializeObjectCallback(), StreamContext *ctx=0)
AnyReference | decodeBinary (qi::BufferReader *buf, AnyReference gvp, DeserializeObjectCallback onObject=DeserializeObjectCallback(), StreamContext *ctx=0)
QI_API_DEPRECATED SteadyClockTimePoint | steadyClockNow ()
| Returns a time_point representing the current value of the clock. More...
QI_API_DEPRECATED SystemClockTimePoint | wallClockNow ()
| Returns a time_point representing the current value of the clock. More...
template<class R , class P >
std::string | to_string (const DurationType< R, P > &d)
template<class C , class D >
std::string | to_string (const boost::chrono::time_point< C, D > &t)
template<class Rep , class Period >
void | sleepFor (const boost::chrono::duration< Rep, Period > &d)
template<class R , class P >
std::string | to_string (const boost::chrono::duration< R, P > &d)
template<typename R >
void | nullConverter (void *, R &)
BOOST_CONSTEXPR ExecutionOptions | defaultExecutionOptions () BOOST_NOEXCEPT
template<typename T >
qi::Future< T > | makeFutureError (const std::string &error)
| Helper function to return a future with the error set. More...
template<typename R >
void | adaptFutureUnwrap (Future< AnyReference > &f, Promise< R > &p)
| Feed a promise from a generic future which may be unwrapped if it contains itself a future. More...
template<typename FT , typename PT >
void | adaptFuture (const Future< FT > &f, Promise< PT > &p, AdaptFutureOption option=AdaptFutureOption_ForwardCancel)
| Feed a promise from a future of possibly different type. More...
template<typename FT , typename PT , typename CONV >
void | adaptFuture (const Future< FT > &f, Promise< PT > &p, CONV converter, AdaptFutureOption option=AdaptFutureOption_ForwardCancel)
| Similar to adaptFuture(f, p) but with a custom converter. More...
template<typename T >
Future< AnyValue > | toAnyValueFuture (Future< T > future)
template<>
Future< AnyValue > | toAnyValueFuture (Future< void > future)
std::ostream & | operator<< (std::ostream &o, FutureState x)
template<typename T >
void | PromiseNoop (qi::Promise< T > &)
template<typename T >
boost::function< void()> | makeCanceler (Future< T > &future)
SrcFuture | retract (UnitFuture)
template<typename... T>
auto | futurize (T &&...t) -> decltype(UnitFuture
template<typename Proc >
auto | futurizeOutput (Proc &&p) -> decltype(ka::semilift(std::forward< Proc >(p), UnitFuture
template<typename T >
qi::FutureSync< std::vector < Future< T > > > | waitForAll (std::vector< Future< T > > &vect)
| Helper function that creates a future waiting on a vector of futures. More...
template<typename T >
qi::FutureSync< qi::Future< T > > | waitForFirst (std::vector< Future< T > > &vect)
| Helper function to wait for the first valid future. More...
template<typename RF , typename AF , typename Arg0 , typename... Args>
std::enable_if < std::is_function< RF > ::value, boost::function< RF > >::type | bindWithFallback (boost::function< void()> onFail, AF &&fun, Arg0 &&arg0, Args &&...args)
template<typename RF , typename AF , typename Arg0 , typename... Args>
std::enable_if < std::is_function< RF > ::value, boost::function< RF > >::type | bindSilent (AF &&fun, Arg0 &&arg0, Args &&...args)
template<typename RF , typename AF , typename Arg0 , typename... Args>
std::enable_if < std::is_function< RF > ::value, boost::function< RF > >::type | bind (AF &&fun, Arg0 &&arg0, Args &&...args)
template<typename AF , typename Arg0 , typename... Args>
auto | bindWithFallback (boost::function< void()> onFail, AF &&fun, Arg0 &&arg0, Args &&...args) -> typename detail::BindTransform< Arg0 >::template wrap_type< typename detail::WorkaroundVS2015< AF, Arg0, Args...>::type >
template<typename AF , typename Arg0 , typename... Args>
auto | bindSilent (AF &&fun, Arg0 &&arg0, Args &&...args) -> decltype(bindWithFallback(
template<typename AF , typename Arg0 , typename... Args>
auto | bind (AF &&fun, Arg0 &&arg0, Args &&...args) -> decltype(bindWithFallback(detail::throwPointerLockException, std::forward< AF >(fun), std::forward< Arg0 >(arg0), std::forward< Args >(args)...))
template<typename R , typename T , typename Instance , typename... Args0, typename... Args1>
auto | bind (R(T::*fun)(Args0...), Instance &&instance, Args1 &&...args1) -> decltype(bindWithFallback(detail::throwPointerLockException, fun, std::forward< Instance >(instance), std::forward< Args1 >(args1)...))
template<typename R , typename AF , typename Arg0 , typename... Args>
auto | bindWithFallback (boost::function< void()> onFail, AF &&fun, Arg0 &&arg0, Args &&...args) -> typename std::enable_if<!std::is_function< R >::value, typename detail::BindTransform< Arg0 >::template wrap_type< decltype(boost::bind< R >(std::forward< AF >(fun), detail::BindTransform< Arg0 >::transform(arg0), std::forward< Args >(args)...))>>::type
template<typename R , typename AF , typename Arg0 , typename... Args>
auto | bindSilent (AF &&fun, Arg0 &&arg0, Args &&...args) -> typename std::enable_if<!std::is_function< R >::value, decltype(bindWithFallback< R >(
template<typename R , typename AF , typename Arg0 , typename... Args>
auto | bind (AF &&fun, Arg0 &&arg0, Args &&...args) -> typename std::enable_if<!std::is_function< R >::value, decltype(bindWithFallback< R >(detail::throwPointerLockException, std::forward< AF >(fun), std::forward< Arg0 >(arg0), std::forward< Args >(args)...))>::type
template<typename F , typename T >
auto | trackWithFallback (boost::function< void()> onFail, F &&f, T &&toTrack) -> decltype(detail::BindTransform< T >::wrap(std::forward< T >(toTrack), std::forward< F >(f), std::move(onFail)))
template<typename F , typename T >
auto | track (F &&f, T &&toTrack) -> decltype(trackWithFallback(detail::throwPointerLockException, std::forward< F >(f), std::forward< T >(toTrack)))
template<typename F , typename T >
auto | trackSilent (F &&f, T &&toTrack) -> decltype(trackWithFallback(
template<typename F , typename T >
boost::function< F > | trackWithFallback (boost::function< void()> onFail, boost::function< F > f, const T &toTrack)
template<typename F , typename T >
boost::function< F > | trackSilent (boost::function< F > f, const T &toTrack)
template<typename F , typename T >
boost::function< F > | track (boost::function< F > f, const T &toTrack)
template<typename Proc , typename T >
auto | visit (Proc &&proc, T &&variant) -> decltype(boost::apply_visitor(ka::fwd< Proc >(proc), ka::fwd< T >(variant)))
EventLoop * | getEventLoop ()
| Returns the global eventloop, created on demand on first call. More...
EventLoop * | getNetworkEventLoop ()
| Returns the global network eventloop, created on demand on first call. More...
void | startEventLoop (int nthread)
| Starts the eventloop with nthread threads. Does nothing if already started. More...
template<typename E , typename = ka::EnableIf<std::is_enum<E>::value>>
auto | underlying (const E &e) -> ka::UnderlyingType< E >
StreamColor | enabledColor (StreamColor color, bool enable=true)
| Returns `color` if `enable` is true, otherwise returns no color. More...
std::string | encodeJSON (const qi::AutoAnyReference &val, JsonOption jsonPrintOption=JsonOption_None)
qi::AnyValue | decodeJSON (const std::string &in)
std::string::const_iterator | decodeJSON (const std::string::const_iterator &begin, const std::string::const_iterator &end, AnyValue &target)
template<typename O , typename S >
ExceptionLogError< ka::Decay < O >, ka::Decay< S > > | exceptionLogError (S &&category, O &&prefix)
std::ostream & | operator<< (std::ostream &, ServiceDirectoryProxy::IdValidationStatus)
std::ostream & | operator<< (std::ostream &, ServiceDirectoryProxy::ListenStatus)
std::ostream & | operator<< (std::ostream &, ServiceDirectoryProxy::ConnectionStatus)
template<typename Dst , typename Src >
Dst | numericConvert (Src v)
template<typename Dst , typename Src >
Dst | numericConvertBound (Src v)
template<typename Dst , typename Src >
bool | numericIsInRange (Src v)
codecvt_type & | unicodeFacet ()
| UTF-8 facet object getter. More...
template<typename... Args>
SessionPtr | makeSession (Args &&...args)
| QI_WARNING_DISABLE (4996, deprecated-declarations) class SignalSubscriber
std::vector< std::string > | signatureSplit (const std::string &fullSignature)
qi::Signature | makeTupleSignature (const std::vector< qi::AnyReference > &vgv, bool resolveDynamic=false, const std::string &name=std::string(), const std::vector< std::string > &names=std::vector< std::string >())
qi::Signature | makeTupleSignature (const std::vector< TypeInterface * > &vgv, const std::string &name=std::string(), const std::vector< std::string > &names=std::vector< std::string >())
qi::Signature | makeTupleSignature (const qi::Signature &element)
qi::Signature | makeListSignature (const qi::Signature &element)
qi::Signature | makeVarArgsSignature (const qi::Signature &element)
qi::Signature | makeKwArgsSignature (const qi::Signature &element)
qi::Signature | makeMapSignature (const qi::Signature &key, const qi::Signature &value)
qi::Signature | makeOptionalSignature (const qi::Signature &value)
bool | operator!= (const Signature &lhs, const Signature &rhs)
bool | operator== (const Signature &lhs, const Signature &rhs)
template<typename RF , typename AF >
boost::function< RF > | bind (const AF &fun,...)
template<typename F , typename ARG0 >
boost::function< F > | track (boost::function< F > f, const ARG0 &arg0)
| Wrap given function f with a tracking check on arg0, which must be a weak pointer or a Trackable instance. More...
template<typename F , typename ARG0 >
boost::function< F > | trackWithFallback (boost::function< void()> onFail, boost::function< F > f, const ARG0 &arg0)
| Wrap given function f with a tracking check on arg0, which must be a weak pointer or a Trackable instance. More...
template<typename Proc , typename T >
TrackWithFallbackTransfo < ka::Decay< Proc >, T > | trackWithFallbackTransfo (Proc &&fallback, T *t)
template<typename T >
TrackSilentTransfo< T > | trackSilentTransfo (T *t)
qi::Translator & | defaultTranslator (const std::string &name)
| Get a reference on the default Translator. More...
std::string | tr (const std::string &msg, const std::string &domain="", const std::string &locale="", const std::string &context="")
| Translate a message. More...
std::string | trContext (const std::string &msg, const std::string &context)
| Translate a message with a specific context. More...
bool | operator== (const AnyIterator &a, const AnyIterator &b)
bool | operator!= (const AnyIterator &a, const AnyIterator &b)
bool | operator< (const AnyReference &a, const AnyReference &b)
bool | operator== (const AnyReference &a, const AnyReference &b)
bool | operator!= (const AnyReference &a, const AnyReference &b)
AnyReference | makeGenericTuple (const AnyReferenceVector &values)
AnyReference | makeGenericTuplePtr (const std::vector< TypeInterface * > &types, const std::vector< void * > &values)
bool | operator< (const AnyValue &a, const AnyValue &b)
| Less than operator. Will compare the values within the AnyValue. More...
bool | operator== (const AnyValue &a, const AnyValue &b)
| Value equality operator. Will compare the values within. More...
bool | operator!= (const AnyValue &a, const AnyValue &b)
AnyReferenceVector | asAnyReferenceVector (const AnyValueVector &vect)
template<typename T , typename... Args>
boost::enable_if< typename detail::InterfaceImplTraits< T > ::Defined, qi::Object< T > >::type | constructObject (Args...args)
template<typename T , typename... Args>
boost::disable_if< typename detail::InterfaceImplTraits< T > ::Defined, qi::Object< T > >::type | constructObject (Args &&...args)
template<typename T , typename U >
bool | operator== (const Object< T > &a, const Object< U > &b)
template<typename T , typename U >
bool | operator!= (const Object< T > &a, const Object< U > &b)
template<typename T >
bool | operator< (const Object< T > &a, const Object< T > &b)
template<typename A >
boost::enable_if< typename detail::Accessor< A > ::is_accessor, SignalBase * > ::type | signalAccess (A acc, void *instance)
template<typename A >
boost::enable_if< typename detail::Accessor< A > ::is_accessor, PropertyBase * > ::type | propertyAccess (A acc, void *instance)
template<typename Proxy , typename Interface >
bool | registerProxyInterface ()
template<class Func , class... Args>
auto | callWithInstance (Func &&f, Args &&...args) -> decltype(std::forward< Func >(f)(std::forward< Args >(args)...))
template<class Func , class Obj , class... Args>
auto | callWithInstance (Func &&f, Obj &&o, Args &&...args) -> decltype((std::forward< Obj >(o).*std::forward< Func >(f))(std::forward< Args >(args)...))
StringTypeInterface::ManagedRawString | makeManagedString (const std::string &s)
StringTypeInterface::ManagedRawString | makeManagedString (std::string &&s)
template<typename T , typename F >
StringTypeInterface * | makeTypeEquivalentString (T *, F f)
bool | operator< (const TraceAnalyzer::FlowLink &a, const TraceAnalyzer::FlowLink &b)
template<typename T >
TypeInterface * | typeOf ()
template<typename TypeDispatcher >
TypeDispatcher & | typeDispatch (TypeDispatcher &v, AnyReference value)
template<typename T >
TypeIndex | typeId ()
template<typename T >
TypeIndex | typeIdRuntime (const T &val)
TypeInterface * | getType (const TypeIndex &typeId)
| Runtime Type factory getter. Used by typeOf<T>() More...
bool | registerType (const TypeIndex &typeId, TypeInterface *type)
| Runtime Type factory setter. More...
template<typename T >
TypeInterface * | typeOf (const T &)
| Get type from a value. No need to delete the result. More...
void | registerStruct (TypeInterface *type)
TypeInterface * | getRegisteredStruct (const qi::Signature &s)
AnyObject | makeDynamicAnyObject (DynamicObject *obj, bool destroyObject=true, const boost::optional< ObjectUid > &uid={}, boost::function< void(GenericObject *)> onDelete=boost::function< void(GenericObject *)>())
| Make an AnyObject of DynamicObject kind from a DynamicObject. More...
AnyObject | makeDynamicSharedAnyObjectImpl (DynamicObject *obj, boost::shared_ptr< Empty > other)
template<typename T >
AnyObject | makeDynamicSharedAnyObject (DynamicObject *obj, boost::shared_ptr< T > other)
ObjectTypeInterface * | getDynamicTypeInterface ()
bool | operator< (const MetaObject &a, const MetaObject &b)
template<typename T , template< class...> class PropertyType>
void | makeProxyProperty (PropertyType< T > &target, AnyObject object, const std::string &signalName)
template<typename T , template< class...> class PropertyType>
void | makeProxyProperty (ProxyProperty< T, PropertyType > &target, AnyObject object, const std::string &signalName)
template<typename T >
void | makeProxySignal (SignalF< T > &target, AnyObject object, const std::string &signalName)
template<typename T >
void | makeProxySignal (ProxySignal< T > &target, AnyObject object, const std::string &signalName)
template<typename Dispatcher >
Dispatcher & | typeDispatch (Dispatcher &dispatcher, AnyReference value)
TypeInterface * | makeTypeOfKind (const qi::TypeKind &kind)
TypeInterface * | makeFloatType (int bytelen)
TypeInterface * | makeIntType (bool issigned, int bytelen)
TypeInterface * | makeVarArgsType (TypeInterface *elementType)
TypeInterface * | makeListType (TypeInterface *elementType)
TypeInterface * | makeMapType (TypeInterface *keyType, TypeInterface *ElementType)
TypeInterface * | makeTupleType (const std::vector< TypeInterface * > &memberTypes, const std::string &name=std::string(), const std::vector< std::string > &elementNames=std::vector< std::string >())
TypeInterface * | makeOptionalType (TypeInterface *valueType)
bool | operator== (const Url &lhs, const Url &rhs)
bool | operator!= (const Url &lhs, const Url &rhs)
std::ostream & | operator<< (std::ostream &out, const Url &url)
Url | specifyUrl (const Url &specification, const Url &baseUrl)
void | sleepFor (const qi::Duration &d)
template<class Rep , class Period >
void | sleepFor (const DurationType< Rep, Period > &d)
void | sleepUntil (const SteadyClockTimePoint &t)
| Blocks the execution of the current thread until `t` has been reached. More...
template<class Duration >
void | sleepUntil (const boost::chrono::time_point< SteadyClock, Duration > &t)
void | sleepUntil (const ClockTimePoint &t)
| Blocks the execution of the current thread until `t` has been reached. More...
template<class Duration >
void | sleepUntil (const boost::chrono::time_point< Clock, Duration > &t)
void | sleepUntil (const SystemClockTimePoint &t)
| Blocks the execution of the current thread until `t` has been reached. More...
template<class Duration >
void | sleepUntil (const boost::chrono::time_point< SystemClock, Duration > &t)
std::string | toISO8601String (const SystemClockTimePoint &t)
| Return the date and time as a string in ISO 8601 format. The time is given up to millisecond precision, in UTC. The format does not include colon characters, to be suitable for inclusion in filenames on any filesystem. More...
template<class DurationTo , class TimePointFrom >
DurationTo | durationSince (const TimePointFrom &t)
| }@ More...

## Variables
QI_API_DEPRECATED typedef SystemClock | WallClock
QI_API_DEPRECATED typedef SystemClockTimePoint | WallClockTimePoint
| System clock time point. More...
const JsonOption | JsonOption_None = 0
const JsonOption | JsonOption_PrettyPrint = 1
const JsonOption | JsonOption_Expand = 2
template<template< typename > class T>
class QITYPE_TEMPLATE_API | TypeOfTemplate

## Detailed Description

Deprecated in 2.5. Use int8_t from <cstdint>.

Simple aliases to abstract a bit from implementation.

Language factory, for each language (C++, Python, ...) a factory should be registered. The factory will be used to load the module

qi::int8_t qi::int16_t Deprecated in 2.5. Use int16_t from <cstdint>. qi::int32_t Deprecated in 2.5. Use int32_t from <cstdint>. qi::int64_t Deprecated in 2.5. Use int64_t from <cstdint>. qi::uint8_t Deprecated in 2.5. Use uint8_t from <cstdint>. qi::uint16_t Deprecated in 2.5. Use uint16_t from <cstdint>. qi::uint32_t Deprecated in 2.5. Use uint32_t from <cstdint>. qi::uint64_t Deprecated in 2.5. Use uint64_t from <cstdint>.

## Typedef Documentation

using qi::AnyAutoService = typedef AutoService<qi::Empty>

Definition at line 105 of file autoservice.hpp.

typedef Object< Empty > qi::AnyObject

Definition at line 21 of file anyobject.hpp.

typedef std::vector< AnyReference > qi::AnyReferenceVector

Definition at line 26 of file anyreference.hpp.

typedef std::vector< AnyValue > qi::AnyValueVector

Definition at line 116 of file anyvalue.hpp.

using qi::AnyVarArguments = typedef VarArguments<>

Definition at line 50 of file anyfunction.hpp.

typedef WeakObject< Empty > qi::AnyWeakObject

Definition at line 361 of file object.hxx.

using qi::ApplicationSessionOptions = typedef ApplicationSession::Option

Definition at line 221 of file applicationsession.hpp.

typedef boost::shared_ptr< AuthProviderFactory > qi::AuthProviderFactoryPtr

Definition at line 36 of file authproviderfactory.hpp.

typedef boost::shared_ptr< AuthProvider > qi::AuthProviderPtr

Definition at line 60 of file authprovider.hpp.

typedef std::map< std::string, AnyValue > qi::CapabilityMap

Definition at line 21 of file authprovider.hpp.

typedef boost::shared_ptr< ClientAuthenticatorFactory > qi::ClientAuthenticatorFactoryPtr

Definition at line 27 of file clientauthenticatorfactory.hpp.

using qi::ClientAuthenticatorPtr = typedef boost::shared_ptr<ClientAuthenticator>

Definition at line 45 of file clientauthenticator.hpp.

using qi::ClockTimePoint = typedef Clock::time_point

qi::Clock time point.

Definition at line 212 of file clock.hpp.

using qi::codecvt_type = typedef std::codecvt<wchar_t, char, std::mbstate_t>

Standard std::codecvt type accepted by STL and boost.

Typedef for std::codecvt<wchar_t, char, std::mbstate_t> that can be used with boost::filesystem::path and std::locale.

Definition at line 518 of file path.hpp.

using qi::DeserializeObjectCallback = typedef boost::function<AnyObject(const ObjectSerializationInfo&)>

Type of callback invoked by sdeerializer when it encounters an object.

Definition at line 41 of file binarycodec.hpp.

using qi::Duration = typedef NanoSeconds

Definition at line 32 of file clock.hpp.

template<class Rep , class Ratio >

using qi::DurationType = typedef boost::chrono::duration<Rep, Ratio>

Convenience typedefs.

Definition at line 20 of file clock.hpp.

using qi::DynamicFunction = typedef boost::function<AnyReference(const AnyReferenceVector&)>

Definition at line 142 of file anyfunction.hpp.

template<typename A , typename B >

using qi::Either = typedef boost::variant<A, B>

Convenient alias to a variant of two types.

Definition at line 11 of file either.hpp.

using qi::FutureUniqueId = typedef void*

Definition at line 134 of file future_fwd.hpp.

using qi::Hours = typedef DurationType<int64_t, boost::ratio<3600>>

Definition at line 30 of file clock.hpp.

using qi::int16_t = typedef int16_t

Definition at line 59 of file types.hpp.

using qi::int32_t = typedef int32_t

Definition at line 60 of file types.hpp.

using qi::int64_t = typedef int64_t

Definition at line 61 of file types.hpp.

using qi::int8_t = typedef int8_t

Definition at line 58 of file types.hpp.

using qi::JsonOption = typedef unsigned int

Definition at line 16 of file jsoncodec.hpp.

using qi::LogContext = typedef int

Logs context attribute value.

Definition at line 178 of file log.hpp.

using qi::MetaMethodParameterVector = typedef std::vector<MetaMethodParameter>

Definition at line 38 of file metamethod.hpp.

using qi::MicroSeconds = typedef DurationType<int64_t, boost::micro>

Definition at line 26 of file clock.hpp.

using qi::MilliSeconds = typedef DurationType<int64_t, boost::milli>

Definition at line 27 of file clock.hpp.

using qi::Minutes = typedef DurationType<int64_t, boost::ratio<60>>

Definition at line 29 of file clock.hpp.

using qi::ModuleFactoryFunctor = typedef boost::function<AnyModule(const qi::ModuleInfo&)>

Definition at line 149 of file anymodule.hpp.

using qi::NanoSeconds = typedef DurationType<int64_t, boost::nano>

Definition at line 25 of file clock.hpp.

using qi::NumericNegativeOverflow = typedef boost::numeric::negative_overflow

Definition at line 20 of file numeric.hpp.

using qi::NumericPositiveOverflow = typedef boost::numeric::positive_overflow

Definition at line 19 of file numeric.hpp.

using qi::ObjectStatistics = typedef std::map<unsigned int, MethodStatistics>

Definition at line 120 of file manageable.hpp.

using qi::ObjectUid = typedef PtrUid

Unique identifier of an object being referred to by a qi::Object instance.

Warning
  Users: your code SHALL NOT assume that ObjectUid will always be implemented as an alias to PtrUid. We only guarantee that it is Regular, i.e. it has value semantics. See ka/concept.hpp for a complete definition of Regular. The definition of ObjectUid may be changed in the future.

Definition at line 16 of file objectuid.hpp.

using qi::PathVector = typedef std::vector<Path>

Definition at line 27 of file path.hpp.

using qi::Seconds = typedef DurationType<int64_t, boost::ratio<1>>

Definition at line 28 of file clock.hpp.

using qi::SerializeObjectCallback = typedef boost::function<ObjectSerializationInfo(const AnyObject&)>

Type of callback invoked by serializer when it encounters an object.

Definition at line 44 of file binarycodec.hpp.

using qi::ServiceInfoVector = typedef std::vector<qi::ServiceInfo>

Definition at line 50 of file serviceinfo.hpp.

using qi::SessionPtr = typedef boost::shared_ptr<Session>

Definition at line 34 of file session.hpp.

typedef qi::uint64_t qi::SignalLink

Definition at line 36 of file signal.hpp.

using qi::SignalSubscriberPtr = typedef boost::shared_ptr<SignalSubscriber>

Definition at line 328 of file signal.hpp.

using qi::SignatureVector = typedef std::vector<Signature>

Definition at line 64 of file signature.hpp.

using qi::SteadyClockTimePoint = typedef SteadyClock::time_point

Steady clock time point.

Definition at line 211 of file clock.hpp.

using qi::SystemClockTimePoint = typedef SystemClock::time_point

System clock time point.

Definition at line 213 of file clock.hpp.

template<class ClockType >

using qi::TimePoint = typedef boost::chrono::time_point<ClockType>

Definition at line 23 of file clock.hpp.

using qi::TypeIndex = typedef boost::typeindex::type_index

Definition at line 30 of file typeinterface.hpp.

using qi::uint16_t = typedef uint16_t

Definition at line 64 of file types.hpp.

using qi::uint32_t = typedef uint32_t

Definition at line 65 of file types.hpp.

using qi::uint64_t = typedef uint64_t

Definition at line 66 of file types.hpp.

using qi::uint8_t = typedef uint8_t

Definition at line 63 of file types.hpp.

using qi::UrlVector = typedef std::vector<Url>

Definition at line 155 of file url.hpp.

using qi::Uuid = typedef boost::uuids::uuid

Definition at line 12 of file uuid.hpp.

using qi::UuidRandomGenerator = typedef boost::uuids::basic_random_generator<boost::random::random_device>

Definition at line 14 of file uuid.hpp.

template<typename T >

using qi::VisitorBase = typedef boost::static_visitor<T>

Helper to create visitors.

See `visit` for an example.

There is no constraint on `T`.

Definition at line 19 of file either.hpp.

## Enumeration Type Documentation

enum qi::AdaptFutureOption

Enumerator
AdaptFutureOption_None |
AdaptFutureOption_ForwardCancel |

Definition at line 129 of file future_fwd.hpp.

enum qi::CancelOption
| strong

< If cancel have been requested for the associated scheduled task...

Enumerator
AllowSkipExecution | ... allow the execution context to not execute the task.
AlwaysSkipExecution | ... the execution context must not execute the task.
NeverSkipExecution | ... the executino context must still execute the task.

Definition at line 41 of file executioncontext.hpp.

enum qi::FutureCallbackType

Enumerator
FutureCallbackType_Sync |
FutureCallbackType_Async |
FutureCallbackType_Auto |

Definition at line 104 of file future_fwd.hpp.

enum qi::FutureState

State of the future.

Enumerator
FutureState_None | Future is not tied to a promise.
FutureState_Running | Operation pending.
FutureState_Canceled | The future has been canceled.
FutureState_FinishedWithError | The operation is finished with an error.
FutureState_FinishedWithValue | The operation is finished with a value.

Definition at line 82 of file future_fwd.hpp.

enum qi::FutureTimeout

Enumerator
FutureTimeout_Infinite |
FutureTimeout_None |

Definition at line 110 of file future_fwd.hpp.

enum qi::LogColor

Logs color mode.

Enumerator
LogColor_Never | Never show color.
LogColor_Auto | Auto color.
LogColor_Always | Always show color.

Definition at line 153 of file log.hpp.

enum qi::LogContextAttr

Logs context attribute.

Enumerator
LogContextAttr_None | No context.
LogContextAttr_Verbosity | Show logs level.
LogContextAttr_ShortVerbosity | Show short logs level.
LogContextAttr_SystemDate | Show qi::SystemClock dates.
LogContextAttr_Tid | Show threads id.
LogContextAttr_Category | Show categories.
LogContextAttr_File | Show logs files.
LogContextAttr_Function | Show functions name.
LogContextAttr_Return | Print an end line between contexts and logs.
LogContextAttr_Date | Show qi::Clock dates.

Definition at line 162 of file log.hpp.

enum qi::LogLevel

Log level verbosity.

Enumerator
LogLevel_Silent | silent log level
LogLevel_Fatal | fatal log level
LogLevel_Error | error log level
LogLevel_Warning | warning log level
LogLevel_Info | info log level
LogLevel_Verbose | verbose log level
LogLevel_Debug | debug log level

Definition at line 140 of file log.hpp.

enum qi::MetaCallType

Specifies how a call should be made. Can be used at both call-site, and callback-registration site.

Enumerator
MetaCallType_Auto | Honor the default behavior.
MetaCallType_Direct | Force a synchronous call.
MetaCallType_Queued | Force an asynchronous call in an other thread.

Definition at line 24 of file typeobject.hpp.

enum qi::ObjectThreadingModel

Possible thread models for an object.

Enumerator
ObjectThreadingModel_SingleThread | Object is not thread safe, all method calls must occur in the same thread.
ObjectThreadingModel_MultiThread | Object is thread safe, multiple calls can occur in different threads in parallel.
ObjectThreadingModel_Default |

Definition at line 33 of file manageable.hpp.

enum qi::StreamColor

The Stream Color enum.

Warning
  Only working under POSIX.

Enumerator
StreamColor_None | No Color.
StreamColor_Reset | Reset the color and mode.
StreamColor_Bold | Bold mode.
StreamColor_Faint | Faint mode.
StreamColor_Standout | Standout mode.
StreamColor_Underline | Underline mode.
StreamColor_Blink | Blink mode.
StreamColor_Overline | Overline mode.
StreamColor_Black | Black.
StreamColor_DarkRed | Dark Red.
StreamColor_DarkGreen | Dark Green.
StreamColor_Brown | Brown.
StreamColor_DarkBlue | Dark Blue.
StreamColor_Purple | Purple.
StreamColor_Teal | Teal.
StreamColor_LightGray | LightGray.
StreamColor_DarkGray | Dark Gray.
StreamColor_Red | Red.
StreamColor_Green | Green.
StreamColor_Yellow | Yellow.
StreamColor_Blue | Blue.
StreamColor_Fuchsia | Fuchsia.
StreamColor_Turquoise | Turquoise.
StreamColor_White | White.

Definition at line 19 of file iocolor.hpp.

enum qi::TypeKind

Enumerator
TypeKind_Unknown |
TypeKind_Void |
TypeKind_Int |
TypeKind_Float |
TypeKind_String |
TypeKind_List |
TypeKind_Map |
TypeKind_Object |
TypeKind_Pointer |
TypeKind_Tuple |
TypeKind_Dynamic |
TypeKind_Raw |
TypeKind_Iterator |
TypeKind_Function |
TypeKind_Signal |
TypeKind_Property |
TypeKind_VarArgs |
TypeKind_Optional |

Definition at line 54 of file fwd.hpp.

## Function Documentation

template<typename FT , typename PT >

void qi::adaptFuture | ( | const Future< FT > & | f,
|  | Promise< PT > & | p,
|  | AdaptFutureOption | option = `AdaptFutureOption_ForwardCancel`
| ) |  |

Feed a promise from a future of possibly different type.

Will monitor `f`, and bounce its state to `p`. Error and canceled state are bounced as is. Valued state is bounced through FutureValueConverter<FT, PT>::convert()

Definition at line 537 of file future.hxx.

template<typename FT , typename PT , typename CONV >

void qi::adaptFuture | ( | const Future< FT > & | f,
|  | Promise< PT > & | p,
|  | CONV | converter,
|  | AdaptFutureOption | option
| ) |  |

Similar to adaptFuture(f, p) but with a custom converter.

Definition at line 547 of file future.hxx.

template<typename R >

void qi::adaptFutureUnwrap | ( | Future< AnyReference > & | f,
|  | Promise< R > & | p
| ) |  |

Feed a promise from a generic future which may be unwrapped if it contains itself a future.

Definition at line 528 of file future.hxx.

AnyReferenceVector qi::asAnyReferenceVector | ( | const AnyValueVector & | vect | ) |
| inline

Definition at line 222 of file anyvalue.hxx.

template<typename F >

auto qi::async | ( | F && | callback | ) | -> decltype(asyncDelay(std::forward<F>(callback), qi::Duration(0)))
| inline

Definition at line 53 of file async.hpp.

template<typename R >

Future< R > qi::async | ( | boost::function< R()> | callback,
|  | uint64_t | usDelay
| ) |  |
| inline

Deprecated:
  use qi::async with qi::Duration

Deprecated:
  use qi::async with qi::Duration

Definition at line 74 of file async.hxx.

template<typename R >

Future< R > qi::async | ( | boost::function< R()> | callback,
|  | qi::Duration | delay
| ) |  |
| inline

Definition at line 80 of file async.hxx.

template<typename R >

Future< R > qi::async | ( | boost::function< R()> | callback,
|  | qi::SteadyClockTimePoint | timepoint
| ) |  |
| inline

Definition at line 86 of file async.hxx.

template<typename R >

Future< R > qi::async | ( | detail::Function< R()> | callback | ) |
| inline

Definition at line 92 of file async.hxx.

template<typename R , typename Func , typename ArgTrack >

QI_API_DEPRECATED qi::Future< R > qi::async | ( | const Func & | f,
|  | const ArgTrack & | toTrack,
|  |  | ...
| ) |  |

Deprecated:
  since 2.5

Deprecated:
  since 2.5

template<typename F >

auto qi::asyncAt | ( | F && | callback,
|  | qi::SteadyClockTimePoint | timepoint
| ) |  | -> decltype(qi::getEventLoop()->asyncAt(std::forward<F>(callback), timepoint))
| inline

Definition at line 39 of file async.hpp.

template<typename F >

auto qi::asyncDelay | ( | F && | callback,
|  | qi::Duration | delay
| ) |  | -> decltype(detail::asyncMaybeActor(std::forward<F>(callback), delay))
| inline

Definition at line 46 of file async.hpp.

template<typename RF , typename AF >

boost::function<RF> qi::bind | ( | const AF & | fun,
|  |  | ...
| ) |  |

Bind a set of arguments or placeholders to a function.

Handles first function argument of kind boost::weak_ptr and qi::Trackable: will try to lock and throw qi::PointerLockException in case of failure

template<typename RF , typename AF , typename Arg0 , typename... Args>

std::enable_if<std::is_function<RF>::value, boost::function<RF> >::type qi::bind | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  |

Definition at line 308 of file trackable.hxx.

template<typename AF , typename Arg0 , typename... Args>

auto qi::bind | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> decltype(bindWithFallback(detail::throwPointerLockException, std::forward<AF>(fun), std::forward<Arg0>(arg0), std::forward<Args>(args)...))

Definition at line 347 of file trackable.hxx.

template<typename R , typename T , typename Instance , typename... Args0, typename... Args1>

auto qi::bind | ( | R(T::*)(Args0...) | fun,
|  | Instance && | instance,
|  | Args1 &&... | args1
| ) |  | -> decltype(bindWithFallback(detail::throwPointerLockException, fun, std::forward<Instance>(instance), std::forward<Args1>(args1)...))

Definition at line 360 of file trackable.hxx.

template<typename R , typename AF , typename Arg0 , typename... Args>

auto qi::bind | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> typename std::enable_if<!std::is_function<R>::value, decltype(bindWithFallback<R>(detail::throwPointerLockException, std::forward<AF>(fun), std::forward<Arg0>(arg0), std::forward<Args>(args)...))>::type

Definition at line 399 of file trackable.hxx.

template<typename RF , typename AF , typename Arg0 , typename... Args>

std::enable_if<std::is_function<RF>::value, boost::function<RF> >::type qi::bindSilent | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  |

Definition at line 300 of file trackable.hxx.

template<typename AF , typename Arg0 , typename... Args>

auto qi::bindSilent | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> decltype(bindWithFallback(

Definition at line 341 of file trackable.hxx.

template<typename R , typename AF , typename Arg0 , typename... Args>

auto qi::bindSilent | ( | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> typename std::enable_if<!std::is_function<R>::value, decltype(bindWithFallback<R>(

Definition at line 388 of file trackable.hxx.

template<typename RF , typename AF , typename Arg0 , typename... Args>

std::enable_if<std::is_function<RF>::value, boost::function<RF> >::type qi::bindWithFallback | ( | boost::function< void()> | onFail,
|  | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  |

Definition at line 291 of file trackable.hxx.

template<typename AF , typename Arg0 , typename... Args>

auto qi::bindWithFallback | ( | boost::function< void()> | onFail,
|  | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> typename detail::BindTransform<Arg0>::template wrap_type< typename detail::WorkaroundVS2015<AF, Arg0, Args...>::type >

Definition at line 329 of file trackable.hxx.

template<typename R , typename AF , typename Arg0 , typename... Args>

auto qi::bindWithFallback | ( | boost::function< void()> | onFail,
|  | AF && | fun,
|  | Arg0 && | arg0,
|  | Args &&... | args
| ) |  | -> typename std::enable_if<!std::is_function<R>::value, typename detail::BindTransform<Arg0>::template wrap_type< decltype(boost::bind<R>(std::forward<AF>(fun), detail::BindTransform<Arg0>::transform(arg0), std::forward<Args>(args)...))>>::type

Definition at line 374 of file trackable.hxx.

template<class Func , class... Args>

auto qi::callWithInstance | ( | Func && | f,
|  | Args &&... | args
| ) |  | -> decltype(std::forward<Func>(f)(std::forward<Args>(args)...))

Definition at line 112 of file stringtypeinterface.hxx.

template<class Func , class Obj , class... Args>

auto qi::callWithInstance | ( | Func && | f,
|  | Obj && | o,
|  | Args &&... | args
| ) |  | -> decltype((std::forward<Obj>(o).*std::forward<Func>(f))(std::forward<Args>(args)...))

Definition at line 119 of file stringtypeinterface.hxx.

template<typename T , typename Duration >

Future< T > qi::cancelOnTimeout | ( | Future< T > | fut,
|  | Duration | timeout
| ) |  |

Cancels the future when the timeout expires.

The output future is the same as the input one, to allow functional composition.

Definition at line 147 of file async.hxx.

template<typename T , typename... Args>

boost::enable_if<typename detail::InterfaceImplTraits<T>::Defined, qi::Object<T> >::type qi::constructObject | ( | Args... | args | ) |

Definition at line 190 of file object.hxx.

template<typename T , typename... Args>

boost::disable_if<typename detail::InterfaceImplTraits<T>::Defined, qi::Object<T> >::type qi::constructObject | ( | Args &&... | args | ) |

Definition at line 196 of file object.hxx.

template<typename T >

AnyReference qi::decodeBinary | ( | qi::BufferReader * | buf,
|  | T * | value,
|  | DeserializeObjectCallback | onObject = `DeserializeObjectCallback()`,
|  | StreamContext * | streamContext = `0`
| ) |  |

Definition at line 74 of file binarycodec.hpp.

AnyReference qi::decodeBinary | ( | qi::BufferReader * | buf,
|  | AnyReference | gvp,
|  | DeserializeObjectCallback | onObject = `DeserializeObjectCallback()`,
|  | StreamContext * | ctx = `0`
| ) |  |

Decode content of `buf` into `gvp`.

Parameters

  buf | buffer with serialized data
  gvp | initialized AnyReference of correct type. Will be filled in.
  onObject | callback invoked each time an object is encountered.
  ctx | connection context

Returns
  the result of the deserialize type visitor

Exceptions

  std::runtime_error | when the decoding fail

qi::AnyValue qi::decodeJSON | ( | const std::string & | in | ) |

creates a GV representing a JSON string or throw on parse error.

Parameters

  in | JSON string to decode.

Returns
  a GV representing the JSON string

std::string::const_iterator qi::decodeJSON | ( | const std::string::const_iterator & | begin,
|  | const std::string::const_iterator & | end,
|  | AnyValue & | target
| ) |  |

set the input GV to represent the JSON sequence between two string iterators or throw on parse error.

Parameters

  begin | iterator to the beginning of the sequence to decode.
  end | iterator to the end of the sequence to decode.
  target | GV to set. Not modified if an error occured.

Returns
  an iterator to the last read char + 1

BOOST_CONSTEXPR ExecutionOptions qi::defaultExecutionOptions | ( |  | ) |
| inline

Definition at line 57 of file executioncontext.hpp.

qi::Translator& qi::defaultTranslator | ( | const std::string & | name | ) |

Get a reference on the default Translator.

Parameters

  name | Application or Library name

Returns
  A reference on default qi::Translator

template<class DurationTo , class TimePointFrom >

DurationTo qi::durationSince | ( | const TimePointFrom & | t | ) |
| inline

}@

Returns the duration elapsed since `t`.

Definition at line 41 of file clock.hxx.

FunctionTypeInterface* qi::dynamicFunctionTypeInterface | ( |  | ) |

Returns
  the type used by dynamic functions

StreamColor qi::enabledColor | ( | StreamColor | color,
|  | bool | enable = `true`
| ) |  |
| inline

Returns `color` if `enable` is true, otherwise returns no color.

This function can be used to easily enable or disable colors when streaming.

Definition at line 59 of file iocolor.hpp.

void qi::encodeBinary | ( | qi::Buffer * | buf,
|  | const AutoAnyReference & | gvp,
|  | SerializeObjectCallback | onObject = `SerializeObjectCallback()`,
|  | StreamContext * | ctx = `0`
| ) |  |

Encode content of `gvp` into `buf`.

Parameters

  buf | buffer that will be filled with serialized data
  gvp | AnyReference to serialize
  onObject | callback invoked each time an object is encountered.
  ctx | connection context

Exceptions

  std::runtime_error | when the encoding fail

std::string qi::encodeJSON | ( | const qi::AutoAnyReference & | val,
|  | JsonOption | jsonPrintOption = `JsonOption_None`
| ) |  |

Returns
  the value encoded in JSON.

Parameters

  val | Value to encode
  jsonPrintOption | Option to change JSON output

template<typename O , typename S >

ExceptionLogError<ka::Decay<O>, ka::Decay<S> > qi::exceptionLogError | ( | S && | category,
|  | O && | prefix
| ) |  |

Helper-function to deduce types for `ExceptionLogError`.

Example: Using catch-clauses.

* const auto logError = qi::exceptionLogError("myapp", "The function that could throw threw");
* try
* {
* functionThatMightThrow();
* }
* catch (const std::exception& ex)
* {
* logError(ex);
* }
* catch (const boost::exception& ex)
* {
* logError(ex);
* }
* catch (...)
* {
* logError();
* }
*

Example: Using ka::invoke_catch.

* ka::invoke_catch(
* qi::exceptionLogError("myapp", "The function that could throw threw"),
* functionThatMightThrow
* );
*

OStreamable O, ConvertibleTo<const char*> S

Definition at line 690 of file log.hpp.

template<typename... T>

auto qi::futurize | ( | T &&... | t | ) | -> decltype(UnitFuture

Returns a future set with the given value. Passing no value results in a Future<void>.

Example:

Future<int> f = futurize(42);
assert(f.hasValue() && f.value() == 42);
Future<void> f2 = futurize();
assert(f2.hasValue());

TODO: Remove the trailing return type when get rid of C++11.

Definition at line 1200 of file future_fwd.hpp.

template<typename Proc >

auto qi::futurizeOutput | ( | Proc && | p | ) | -> decltype(ka::semilift(std::forward<Proc>(p), UnitFuture

Returns a new function similar to the given one except that it returns a future.

This is a "semi-lifting" (see `semilift` for an explanation of the lifting notion)

Example:

// `heavyCompute` takes a `vector<int>` and returns an `int`.
// `v` is a `vector<int>`.
auto f = futurizeOutput(heavyCompute);
Future<int> res = f(v);
// ...

TODO: Remove the trailing return type when get rid of C++11.

Procedure Proc

Definition at line 1224 of file future_fwd.hpp.

ObjectTypeInterface* qi::getDynamicTypeInterface | ( |  | ) |

EventLoop* qi::getEventLoop | ( |  | ) |

Returns the global eventloop, created on demand on first call.

EventLoop* qi::getNetworkEventLoop | ( |  | ) |

Returns the global network eventloop, created on demand on first call.

TypeInterface* qi::getRegisteredStruct | ( | const qi::Signature & | s | ) |

Returns
  matching TypeInterface registered by registerStruct() or 0.

TypeInterface* qi::getType | ( | const TypeIndex & | typeId | ) |

Runtime Type factory getter. Used by typeOf<T>()

AnyModule qi::import | ( | const std::string & | name | ) |

find a module and import it, this is cross language, that's the main module entry point

this function dispatch to <lang> module factory, if the module is not already registered

AnyModule qi::import | ( | const ModuleInfo & | name | ) |

std::vector<ModuleInfo> qi::listModules | ( |  | ) |

list all available modules (cross language

template<typename T >

boost::function<void()> qi::makeCanceler | ( | Future< T > & | future | ) |
| inline

Definition at line 1092 of file future_fwd.hpp.

AnyObject qi::makeDynamicAnyObject | ( | DynamicObject * | obj,
|  | bool | destroyObject = `true`,
|  | const boost::optional< ObjectUid > & | uid = `{}`,
|  | boost::function< void(GenericObject *)> | onDelete = `boost::function< void(GenericObject *)>()`
| ) |  |

Make an AnyObject of DynamicObject kind from a DynamicObject.

template<typename T >

AnyObject qi::makeDynamicSharedAnyObject | ( | DynamicObject * | obj,
|  | boost::shared_ptr< T > | other
| ) |  |
| inline

Make an AnyObject that shares its ref counter with `other` Note that `obj` will not be destroyed when the shared counter reaches 0.

Definition at line 88 of file dynamicobject.hpp.

AnyObject qi::makeDynamicSharedAnyObjectImpl | ( | DynamicObject * | obj,
|  | boost::shared_ptr< Empty > | other
| ) |  |

TypeInterface* qi::makeFloatType | ( | int | bytelen | ) |

Returns
  a Type of kind float, bytelen can be 4 or 8

template<typename T >

FunctionTypeInterface* qi::makeFunctionTypeInterface | ( |  | ) |

template<typename T >

qi::Future< T > qi::makeFutureError | ( | const std::string & | error | ) |

Helper function to return a future with the error set.

Parameters

  error | the error message.

Definition at line 466 of file future.hxx.

AnyReference qi::makeGenericTuple | ( | const AnyReferenceVector & | values | ) |

Returns
  an allocated Tuple made from copies of

Parameters

  values |

AnyReference qi::makeGenericTuplePtr | ( | const std::vector< TypeInterface * > & | types,
|  | const std::vector< void * > & | values
| ) |  |

Returns
  a Tuple pointing to values as its storage

TypeInterface* qi::makeIntType | ( | bool | issigned,
|  | int | bytelen
| ) |  |

Returns
  a Type of kind int, bytelen can be 0,1,2,4,8

qi::Signature qi::makeKwArgsSignature | ( | const qi::Signature & | element | ) |

qi::Signature qi::makeListSignature | ( | const qi::Signature & | element | ) |

TypeInterface* qi::makeListType | ( | TypeInterface * | elementType | ) |

Returns
  a Type of kind List that can contains elements of type elementType.

StringTypeInterface::ManagedRawString qi::makeManagedString | ( | const std::string & | s | ) |
| inline

Definition at line 125 of file stringtypeinterface.hxx.

StringTypeInterface::ManagedRawString qi::makeManagedString | ( | std::string && | s | ) |
| inline

Definition at line 131 of file stringtypeinterface.hxx.

qi::Signature qi::makeMapSignature | ( | const qi::Signature & | key,
|  | const qi::Signature & | value
| ) |  |

TypeInterface* qi::makeMapType | ( | TypeInterface * | keyType,
|  | TypeInterface * | ElementType
| ) |  |

Returns
  a Type of kind Map with given key and element types

qi::Signature qi::makeOptionalSignature | ( | const qi::Signature & | value | ) |

TypeInterface* qi::makeOptionalType | ( | TypeInterface * | valueType | ) |

Returns
  a Type of kind Optional with given value

template<typename T , template< class...> class PropertyType>

void qi::makeProxyProperty | ( | PropertyType< T > & | target,
|  | AnyObject | object,
|  | const std::string & | signalName
| ) |  |

Definition at line 48 of file proxyproperty.hpp.

template<typename T , template< class...> class PropertyType>

void qi::makeProxyProperty | ( | ProxyProperty< T, PropertyType > & | target,
|  | AnyObject | object,
|  | const std::string & | signalName
| ) |  |

Definition at line 54 of file proxyproperty.hpp.

template<typename T >

void qi::makeProxySignal | ( | SignalF< T > & | target,
|  | AnyObject | object,
|  | const std::string & | signalName
| ) |  |

Definition at line 45 of file proxysignal.hpp.

template<typename T >

void qi::makeProxySignal | ( | ProxySignal< T > & | target,
|  | AnyObject | object,
|  | const std::string & | signalName
| ) |  |

Definition at line 52 of file proxysignal.hpp.

template<typename... Args>

SessionPtr qi::makeSession | ( | Args &&... | args | ) |

Definition at line 241 of file session.hpp.

qi::Signature qi::makeTupleSignature | ( | const std::vector< qi::AnyReference > & | vgv,
|  | bool | resolveDynamic = `false`,
|  | const std::string & | name = `std::string()`,
|  | const std::vector< std::string > & | names = `std::vector< std::string >()`
| ) |  |

qi::Signature qi::makeTupleSignature | ( | const std::vector< TypeInterface * > & | vgv,
|  | const std::string & | name = `std::string()`,
|  | const std::vector< std::string > & | names = `std::vector< std::string >()`
| ) |  |

qi::Signature qi::makeTupleSignature | ( | const qi::Signature & | element | ) |

TypeInterface* qi::makeTupleType | ( | const std::vector< TypeInterface * > & | memberTypes,
|  | const std::string & | name = `std::string()`,
|  | const std::vector< std::string > & | elementNames = `std::vector< std::string >()`
| ) |  |

Returns
  a Type of kind Tuple with givent memberTypes

template<typename T , typename F >

StringTypeInterface* qi::makeTypeEquivalentString | ( | T * | ,
|  | F | f
| ) |  |

Definition at line 170 of file stringtypeinterface.hxx.

TypeInterface* qi::makeTypeOfKind | ( | const qi::TypeKind & | kind | ) |

Returns
  a Type of the specified Kind. This do not work for list, map and tuple. kind Int and Float will create the biggest possible type. use makeFloatType and makeIntType to be more specific.

qi::Signature qi::makeVarArgsSignature | ( | const qi::Signature & | element | ) |

TypeInterface* qi::makeVarArgsType | ( | TypeInterface * | elementType | ) |

Returns
  a Type of kind VarArgs that can contains elements of type elementType.

qi::Future<AnyReference> qi::metaCall | ( | ExecutionContext * | ec,
|  | ObjectThreadingModel | objectThreadingModel,
|  | MetaCallType | methodThreadingModel,
|  | MetaCallType | callType,
|  | AnyObject | manageable,
|  | unsigned int | methodId,
|  | AnyFunction | func,
|  | const GenericFunctionParameters & | params,
|  | bool | noCloneFirst = `false`,
|  | unsigned int | callerId = `0`,
|  | qi::os::timeval | postTimestamp = `qi::os::timeval()`
| ) |  |

Make a call honoring ThreadingModel requirements

Check the following rules in order:

- If methodThreadingModel is not auto, honor it, overriding callType
- If el is set, force call in it (synchronously if we are in it).
- If callType is set (not auto), honor it.
- Be synchronous.

When the call is finally made, if objectThreadingModel is SingleThread, acquire the object lock.

Parameters

  ec | context into which the call will be scheduled
  objectThreadingModel | the threading model of the called object
  methodThreadingModel | the threading model of the specific method
  callType | the requested threading model
  manageable | the object on which to make the call
  methodId | the method id of the object to call
  func | the function to call
  params | the arguments of the call
  noCloneFirst | whether the first argument of the call should be cloned or not
  callerId | thread id of caller, for tracing purposes
  postTimestamp | the time when the call was requested

template<typename R >

void qi::nullConverter | ( | void * | ,
|  | R & |
| ) |  |

Definition at line 15 of file eventloop.hxx.

template<typename Dst , typename Src >

Dst qi::numericConvert | ( | Src | v | ) |

Converts a value of an arithmetic source type into the equivalent value of the arithmetic destination type. If the result would overflow or underflow, throws respectively a qi::NumericPositiveOverflow or a qi::NumericNegativeOverflow exception.

Note: It is undefined behavior to convert a floating number that is NaN.

Example: Converting from std::uint8_t to std::int8_t

* std::uint8_t a = 78u;
* auto b = qi::numericConvert<std::int8_t>(a); // b == 78
*

Example: Overflowing

* std::uint8_t a = 145u;
* auto b = qi::numericConvert<std::int8_t>(a); // throws a NumericPositiveOverflow exception.
*

Example: Underflowing

* std::int8_t a = -37;
* auto b = qi::numericConvert<std::uint8_t>(a); // throws a NumericNegativeOverflow exception.
*

Arithmetic Dst Arithmetic Src

Definition at line 50 of file numeric.hpp.

template<typename Dst , typename Src >

Dst qi::numericConvertBound | ( | Src | v | ) |

Converts a value of an arithmetic source type into the equivalent value of the arithmetic destination type. If the result would overflow or underflow, returns respectively the max or the min of the destination type.

Note: It is undefined behavior to convert a floating number that is NaN.

Example: Converting from std::uint8_t to std::int8_t

* std::uint8_t a = 78u;
* auto b = qi::numericConvertBound<std::int8_t>(a); // b == 78
*

Example: Overflowing

* std::uint8_t a = 145u;
* auto b = qi::numericConvertBound<std::int8_t>(a); // b == INT8_MAX
*

Example: Underflowing

* std::int8_t a = -37;
* auto b = qi::numericConvertBound<std::uint8_t>(a); // b == UINT8_MIN
*

Arithmetic Dst Arithmetic Src

Definition at line 83 of file numeric.hpp.

template<typename Dst , typename Src >

bool qi::numericIsInRange | ( | Src | v | ) |

Returns true if a value of an arithmetic source type is in the range of an arithmetic destination type.

Arithmetic Dst Arithmetic Src

Definition at line 103 of file numeric.hpp.

bool qi::operator!= | ( | const AnyIterator & | a,
|  | const AnyIterator & | b
| ) |  |
| inline

Definition at line 60 of file anyiterator.hxx.

bool qi::operator!= | ( | const AnyValue & | a,
|  | const AnyValue & | b
| ) |  |
| inline

Definition at line 196 of file anyvalue.hxx.

bool qi::operator!= | ( | const Url & | lhs,
|  | const Url & | rhs
| ) |  |
| inline

Compares the url strings.

Definition at line 150 of file url.hpp.

bool qi::operator!= | ( | const Signature & | lhs,
|  | const Signature & | rhs
| ) |  |
| inline

Definition at line 157 of file signature.hpp.

bool qi::operator!= | ( | const AnyReference & | a,
|  | const AnyReference & | b
| ) |  |
| inline

Definition at line 289 of file anyreference.hxx.

template<typename T , typename U >

bool qi::operator!= | ( | const Object< T > & | a,
|  | const Object< U > & | b
| ) |  |

Definition at line 578 of file object.hxx.

bool qi::operator< | ( | const TraceAnalyzer::FlowLink & | a,
|  | const TraceAnalyzer::FlowLink & | b
| ) |  |
| inline

Definition at line 50 of file traceanalyzer.hpp.

bool qi::operator< | ( | const AnyValue & | a,
|  | const AnyValue & | b
| ) |  |
| inline

Less than operator. Will compare the values within the AnyValue.

Definition at line 231 of file anyvalue.hxx.

bool qi::operator< | ( | const MetaObject & | a,
|  | const MetaObject & | b
| ) |  |

bool qi::operator< | ( | const AnyReference & | a,
|  | const AnyReference & | b
| ) |  |

template<typename T >

bool qi::operator< | ( | const Object< T > & | a,
|  | const Object< T > & | b
| ) |  |

Definition at line 584 of file object.hxx.

std::ostream& qi::operator<< | ( | std::ostream & | o,
|  | FutureState | x
| ) |  |
| inline

Definition at line 90 of file future_fwd.hpp.

std::ostream& qi::operator<< | ( | std::ostream & | ,
|  | ServiceDirectoryProxy::IdValidationStatus |
| ) |  |

std::ostream& qi::operator<< | ( | std::ostream & | ,
|  | ServiceDirectoryProxy::ListenStatus |
| ) |  |

std::ostream& qi::operator<< | ( | std::ostream & | ,
|  | ServiceDirectoryProxy::ConnectionStatus |
| ) |  |

std::ostream& qi::operator<< | ( | std::ostream & | out,
|  | const Url & | url
| ) |  |

bool qi::operator== | ( | const AnyIterator & | a,
|  | const AnyIterator & | b
| ) |  |
| inline

Definition at line 55 of file anyiterator.hxx.

bool qi::operator== | ( | const AnyValue & | a,
|  | const AnyValue & | b
| ) |  |
| inline

Value equality operator. Will compare the values within.

Definition at line 236 of file anyvalue.hxx.

bool qi::operator== | ( | const Url & | lhs,
|  | const Url & | rhs
| ) |  |

Compares the url strings.

bool qi::operator== | ( | const Signature & | lhs,
|  | const Signature & | rhs
| ) |  |

bool qi::operator== | ( | const AnyReference & | a,
|  | const AnyReference & | b
| ) |  |

template<typename T , typename U >

bool qi::operator== | ( | const Object< T > & | a,
|  | const Object< U > & | b
| ) |  |

Compares identities, not values.

The uid identifies the pointer initially used to create the Object. Thus, if an object crosses the network boundaries, its (local) memory address will change but the uid will be the same.

Definition at line 571 of file object.hxx.

template<typename T >

void qi::PromiseNoop | ( | qi::Promise< T > & |  | ) |

Helper function that does nothing on future cancelation

Deprecated:
  since 2.5:

Definition at line 1058 of file future_fwd.hpp.

template<typename A >

boost::enable_if<typename detail::Accessor<A>::is_accessor, PropertyBase*>::type qi::propertyAccess | ( | A | acc,
|  | void * | instance
| ) |  |

Definition at line 172 of file objecttypebuilder.hxx.

qi::QI_WARNING_DISABLE | ( | 4996 | ,
|  | deprecated- | declarations
| ) |  |

Event subscriber info.

Only one of handler or target must be set. This class is copyable but has entity semantics.

Perform the call.

Threading rules in order:

- Honor threadingModel if set (not auto)
- Honor callTypoe if set (not auto)
- Be asynchronous

Returns
  the identifier of the subscription (aka link)

Try to extract exact signature of this subscriber.

Returns
  the signature, or an invalid signature if extraction is impossible

Definition at line 264 of file signal.hpp.

bool qi::registerCppEmbeddedModule | ( | const std::string & | moduleName,
|  | boost::function< void(ModuleBuilder *)> | fun
| ) |  |

register a module into the module map

bool qi::registerModuleFactory | ( | const std::string & | name,
|  | ModuleFactoryFunctor | fun
| ) |  |

Register a module factory for a given language

template<typename Proxy , typename Interface >

bool qi::registerProxyInterface | ( |  | ) |

Register `Proxy` as a proxy class for interface `Interface`. Required to allow the typesystem to construct an Object<Interface> from an AnyObject. Proxy must be constructible with an AnyObject as argument

Returns
  unused value, present to ease registration at static initialisation

Definition at line 150 of file proxyregister.hpp.

void qi::registerStruct | ( | TypeInterface * | type | ) |

Register type for signature -> TypeInterface factory.

bool qi::registerType | ( | const TypeIndex & | typeId,
|  | TypeInterface * | type
| ) |  |

Runtime Type factory setter.

SrcFuture qi::retract | ( | UnitFuture |  | ) |
| inline

Definition at line 1182 of file future_fwd.hpp.

AtomicFlagLock qi::scopelock | ( | std::atomic_flag & | f | ) |
| inline

model ScopeLockable std::atomic_flag:

Definition at line 312 of file atomic.hpp.

template<typename A >

boost::enable_if<typename detail::Accessor<A>::is_accessor, SignalBase*>::type qi::signalAccess | ( | A | acc,
|  | void * | instance
| ) |  |

Definition at line 164 of file objecttypebuilder.hxx.

std::vector<std::string> qi::signatureSplit | ( | const std::string & | fullSignature | ) |

template<class Rep , class Period >

void qi::sleepFor | ( | const boost::chrono::duration< Rep, Period > & | d | ) |

Definition at line 17 of file clock.hxx.

void qi::sleepFor | ( | const qi::Duration & | d | ) |

Blocks the execution of the current thread for at least `d`.

template<class Rep , class Period >

void qi::sleepFor | ( | const DurationType< Rep, Period > & | d | ) |
| inline

void qi::sleepUntil | ( | const SteadyClockTimePoint & | t | ) |

Blocks the execution of the current thread until `t` has been reached.

This is equivalent to sleepFor(t - SteadyClockTimePoint::now())

template<class Duration >

void qi::sleepUntil | ( | const boost::chrono::time_point< SteadyClock, Duration > & | t | ) |
| inline

Definition at line 23 of file clock.hxx.

void qi::sleepUntil | ( | const ClockTimePoint & | t | ) |

Blocks the execution of the current thread until `t` has been reached.

template<class Duration >

void qi::sleepUntil | ( | const boost::chrono::time_point< Clock, Duration > & | t | ) |
| inline

Definition at line 29 of file clock.hxx.

void qi::sleepUntil | ( | const SystemClockTimePoint & | t | ) |

Blocks the execution of the current thread until `t` has been reached.

Adjustments of the clock are taken into account. Thus the duration of the block might, but might not, be less or more than t - SystemClock::now()

template<class Duration >

void qi::sleepUntil | ( | const boost::chrono::time_point< SystemClock, Duration > & | t | ) |
| inline

Definition at line 35 of file clock.hxx.

Url qi::specifyUrl | ( | const Url & | specification,
|  | const Url & | baseUrl
| ) |  |

Use specified parts of the given URL to be set over the given base URL.

Parameters

  specification | An URL that may be incomplete, which specified parts must be kept.
  baseUrl | A supposedly complete URL, which parts will be used to fill in the specified URL.

template<typename T >

T qi::src | ( | const std::atomic< T > & | x | ) |

Definition at line 318 of file atomic.hpp.

void qi::startEventLoop | ( | int | nthread | ) |

Starts the eventloop with nthread threads. Does nothing if already started.

Parameters

  nthread | Set the minimum number of worker threads in the pool.

QI_API_DEPRECATED SteadyClockTimePoint qi::steadyClockNow | ( |  | ) |
| inline

Returns a time_point representing the current value of the clock.

Definition at line 220 of file clock.hpp.

long qi::testAndSet | ( | long * | cond | ) |
| inline

Cross-platform implementation of atomic Test-And-Set.

Parameters

  cond | pointer to the value to test and set.

Returns
  true (1) if cond is 0, false (0) otherwise.

Definition at line 48 of file atomic.hpp.

template<class R , class P >

std::string qi::to_string | ( | const boost::chrono::duration< R, P > & | d | ) |
| inline

Definition at line 90 of file clock.hxx.

template<class R , class P >

std::string qi::to_string | ( | const DurationType< R, P > & | d | ) |
| inline

template<class C , class D >

std::string qi::to_string | ( | const boost::chrono::time_point< C, D > & | t | ) |
| inline

Definition at line 99 of file clock.hxx.

template<typename T >

Future< AnyValue > qi::toAnyValueFuture | ( | Future< T > | future | ) |

Definition at line 556 of file future.hxx.

template<>

Future<AnyValue> qi::toAnyValueFuture | ( | Future< void > | future | ) |
| inline

Definition at line 565 of file future.hxx.

std::string qi::toISO8601String | ( | const SystemClockTimePoint & | t | ) |

Return the date and time as a string in ISO 8601 format. The time is given up to millisecond precision, in UTC. The format does not include colon characters, to be suitable for inclusion in filenames on any filesystem.

For instance the string for a quarter past nine PM on April 3rd, 2001 is "2001-04-03T211500.000Z"

std::string qi::tr | ( | const std::string & | msg,
|  | const std::string & | domain = `""`,
|  | const std::string & | locale = `""`,
|  | const std::string & | context = `""`
| ) |  |

Translate a message.

Parameters

  msg | Message to translate
  domain | Domain name
  locale | Locale name
  context | Context of the msg

Returns
  The translated message

template<typename F , typename ARG0 >

boost::function<F> qi::track | ( | boost::function< F > | f,
|  | const ARG0 & | arg0
| ) |  |

Wrap given function f with a tracking check on arg0, which must be a weak pointer or a Trackable instance.

Returns
  a function that, when called:
  - If lock can be acquired, calls f
  - Else throws qi::PointerLockException

template<typename F , typename T >

auto qi::track | ( | F && | f,
|  | T && | toTrack
| ) |  | -> decltype(trackWithFallback(detail::throwPointerLockException, std::forward<F>(f), std::forward<T>(toTrack)))

Definition at line 420 of file trackable.hxx.

template<typename F , typename T >

boost::function<F> qi::track | ( | boost::function< F > | f,
|  | const T & | toTrack
| ) |  |

Definition at line 445 of file trackable.hxx.

template<typename F , typename T >

auto qi::trackSilent | ( | F && | f,
|  | T && | toTrack
| ) |  | -> decltype(trackWithFallback(

Definition at line 427 of file trackable.hxx.

template<typename F , typename T >

boost::function<F> qi::trackSilent | ( | boost::function< F > | f,
|  | const T & | toTrack
| ) |  |

Definition at line 440 of file trackable.hxx.

template<typename T >

TrackSilentTransfo<T> qi::trackSilentTransfo | ( | T * | t | ) |

Helper to deduce types to construct a TrackSilentTransfo.

Trackable T

Definition at line 172 of file trackable.hpp.

template<typename F , typename ARG0 >

boost::function<F> qi::trackWithFallback | ( | boost::function< void()> | onFail,
|  | boost::function< F > | f,
|  | const ARG0 & | arg0
| ) |  |

Wrap given function f with a tracking check on arg0, which must be a weak pointer or a Trackable instance.

Returns
  a function that, when called:
  - If lock can be acquired, calls f
  - Else calls onFail

template<typename F , typename T >

auto qi::trackWithFallback | ( | boost::function< void()> | onFail,
|  | F && | f,
|  | T && | toTrack
| ) |  | -> decltype(detail::BindTransform<T>::wrap(std::forward<T>(toTrack), std::forward<F>(f), std::move(onFail)))

Definition at line 413 of file trackable.hxx.

template<typename F , typename T >

boost::function<F> qi::trackWithFallback | ( | boost::function< void()> | onFail,
|  | boost::function< F > | f,
|  | const T & | toTrack
| ) |  |

Definition at line 434 of file trackable.hxx.

template<typename Proc , typename T >

TrackWithFallbackTransfo<ka::Decay<Proc>, T> qi::trackWithFallbackTransfo | ( | Proc && | fallback,
|  | T * | t
| ) |  |

Helper to deduce types to construct a TrackWithFallbackTransfo.

Procedure<void ()> Proc, Trackable T

Definition at line 143 of file trackable.hpp.

std::string qi::trContext | ( | const std::string & | msg,
|  | const std::string & | context
| ) |  |

Translate a message with a specific context.

Parameters

  msg | Message to translate
  context | Context of the msg

Returns
  The translated message

bool qi::tryLowerAtomicFlag | ( | std::atomic< bool > & | b | ) |
| inline

Inverse operation of tryRaiseAtomicFlag. True if the atomic flag was successfully lowered (i.e. set to false). If it was already lowered, false is returned. Lemma tryLowerAtomicFlag.0: If the flag is up (true), tryLowerAtomicFlag() atomically lowers it (i.e. makes it false).

Definition at line 251 of file atomic.hpp.

bool qi::tryRaiseAtomicFlag | ( | std::atomic< bool > & | b | ) |
| inline

True if the atomic flag was successfully raised (i.e. set to true). If it was already raised, false is returned. Lemma tryRaiseAtomicFlag.0: If the flag is down (false), tryRaiseAtomicFlag() atomically raises it (i.e. makes it true).

Definition at line 238 of file atomic.hpp.

template<typename TypeDispatcher >

TypeDispatcher& qi::typeDispatch | ( | TypeDispatcher & | v,
|  | AnyReference | value
| ) |  |

Definition at line 13 of file typedispatcher.hxx.

template<typename Dispatcher >

Dispatcher& qi::typeDispatch | ( | Dispatcher & | dispatcher,
|  | AnyReference | value
| ) |  |

Invoke one of the visitor functions in dispatcher based on kind(). Dispatcher must implement TypeDispatcher.

template<typename T >

TypeIndex qi::typeId | ( |  | ) |

Definition at line 33 of file typeinterface.hpp.

template<typename T >

TypeIndex qi::typeIdRuntime | ( | const T & | val | ) |

Definition at line 38 of file typeinterface.hpp.

template<typename T >

TypeInterface * qi::typeOf | ( |  | ) |

Get type from a type. Will return a static TypeImpl<T> if T is not registered

Definition at line 94 of file type.hxx.

template<typename T >

TypeInterface* qi::typeOf | ( | const T & |  | ) |

Get type from a value. No need to delete the result.

Definition at line 206 of file typeinterface.hpp.

template<typename E , typename = ka::EnableIf<std::is_enum<E>::value>>

auto qi::underlying | ( | const E & | e | ) | -> ka::UnderlyingType<E>

Enumeration E

This overload is only available for enum types through SFINAE because std::underlying_type has undefined behavior for non-enum types.

Definition at line 22 of file flags.hpp.

codecvt_type& qi::unicodeFacet | ( |  | ) |

UTF-8 facet object getter.

Returns
  UTF-8 implementation for std::codecvt<wchar_t, char, std::mbstate_t>

Return a facet object that can be used by stl (iostream, locale, ...) and std::locale compliant library like boost::filesystem.

This class allow conversion between UTF-8 (char) and UTF-16/UTF-32 (wchar).

template<typename Proc , typename T >

auto qi::visit | ( | Proc && | proc,
|  | T && | variant
| ) |  | -> decltype(boost::apply_visitor(ka::fwd<Proc>(proc), ka::fwd<T>(variant)))

Applies the polymorphic procedure on the content of a 'sum type' (`Either`, `boost::variant`...).

Example: Defining a visitor and applying it.

* struct Norm : VisitorBase<std::size_t>
* {
* std::size_t operator()(const std::string& x) const
* {
* return x.size();
* }
* std::size_t operator()(int i) const
* {
* return i;
* }
* };
*
* // In a function:
* using E = Either<std::string, int>;
* {
* E e{"abc"};
* std::size_t i = visit(Norm{}, e); // i == 3
* }
* {
* E e{12};
* std::size_t i = visit(Norm{}, e); // i == 12
* }
*

PolymorphicProcedure<U (A || ...)> Proc, boost::variant<A...> T

Definition at line 53 of file either.hpp.

template<typename T >

qi::FutureSync<std::vector<Future<T> > > qi::waitForAll | ( | std::vector< Future< T > > & | vect | ) |

Helper function that creates a future waiting on a vector of futures.

Parameters

  vect | The vector of futures to wait on.

    * Returns a future that is set when all input futures are set, either on error
    * or with a valid value.
    *
    * Note: Cancelling the returned future cancels all underlying futures.
    *

Definition at line 239 of file futurebarrier.hpp.

template<typename T >

qi::FutureSync< qi::Future<T> > qi::waitForFirst | ( | std::vector< Future< T > > & | vect | ) |

Helper function to wait for the first valid future.

Parameters

  vect | The vector of futures to wait on.

Returns
  The first valid future, or an error.

    * This function will wait on all the futures of the vector. It returns the
    * first valid future that returns. If no future is valid, a future set with
    * an error is returned.
    *

Definition at line 261 of file futurebarrier.hpp.

QI_API_DEPRECATED SystemClockTimePoint qi::wallClockNow | ( |  | ) |
| inline

Returns a time_point representing the current value of the clock.

Definition at line 226 of file clock.hpp.

## Variable Documentation

const JsonOption qi::JsonOption_Expand = 2

Definition at line 19 of file jsoncodec.hpp.

const JsonOption qi::JsonOption_None = 0

Definition at line 17 of file jsoncodec.hpp.

const JsonOption qi::JsonOption_PrettyPrint = 1

Definition at line 18 of file jsoncodec.hpp.

template<template< typename > class T>

class QITYPE_TEMPLATE_API qi::TypeOfTemplate

Definition at line 136 of file type.hxx.

QI_API_DEPRECATED typedef SystemClock qi::WallClock

Definition at line 209 of file clock.hpp.

QI_API_DEPRECATED typedef SystemClockTimePoint qi::WallClockTimePoint

System clock time point.

Definition at line 216 of file clock.hpp.