libqi-api  2.8.7.4
 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 >
FunctionTypeInterfacemakeFunctionTypeInterface ()
 
FunctionTypeInterfacedynamicFunctionTypeInterface ()
 
bool registerCppEmbeddedModule (const std::string &moduleName, boost::function< void(ModuleBuilder *)> fun)
 
std::vector< ModuleInfolistModules ()
 
AnyModule import (const std::string &name)
 
AnyModule import (const ModuleInfo &name)
 
bool registerModuleFactory (const std::string &name, ModuleFactoryFunctor fun)
 
qi::Future< AnyReferencemetaCall (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 >
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< AnyValuetoAnyValueFuture (Future< T > future)
 
template<>
Future< AnyValuetoAnyValueFuture (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)))
 
EventLoopgetEventLoop ()
 Returns the global eventloop, created on demand on first call. More...
 
EventLoopgetNetworkEventLoop ()
 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_typeunicodeFacet ()
 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::TranslatordefaultTranslator (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 >
StringTypeInterfacemakeTypeEquivalentString (T *, F f)
 
bool operator< (const TraceAnalyzer::FlowLink &a, const TraceAnalyzer::FlowLink &b)
 
template<typename T >
TypeInterfacetypeOf ()
 
template<typename TypeDispatcher >
TypeDispatcher & typeDispatch (TypeDispatcher &v, AnyReference value)
 
template<typename T >
TypeIndex typeId ()
 
template<typename T >
TypeIndex typeIdRuntime (const T &val)
 
TypeInterfacegetType (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 >
TypeInterfacetypeOf (const T &)
 Get type from a value. No need to delete the result. More...
 
void registerStruct (TypeInterface *type)
 
TypeInterfacegetRegisteredStruct (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)
 
ObjectTypeInterfacegetDynamicTypeInterface ()
 
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)
 
TypeInterfacemakeTypeOfKind (const qi::TypeKind &kind)
 
TypeInterfacemakeFloatType (int bytelen)
 
TypeInterfacemakeIntType (bool issigned, int bytelen)
 
TypeInterfacemakeVarArgsType (TypeInterface *elementType)
 
TypeInterfacemakeListType (TypeInterface *elementType)
 
TypeInterfacemakeMapType (TypeInterface *keyType, TypeInterface *ElementType)
 
TypeInterfacemakeTupleType (const std::vector< TypeInterface * > &memberTypes, const std::string &name=std::string(), const std::vector< std::string > &elementNames=std::vector< std::string >())
 
TypeInterfacemakeOptionalType (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

Definition at line 105 of file autoservice.hpp.

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.

Definition at line 361 of file object.hxx.

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.

Definition at line 27 of file clientauthenticatorfactory.hpp.

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

Definition at line 45 of file clientauthenticator.hpp.

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.

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.

Steady clock time point.

Definition at line 211 of file clock.hpp.

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

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.

Enumerator
FutureCallbackType_Sync 
FutureCallbackType_Async 
FutureCallbackType_Auto 

Definition at line 104 of file future_fwd.hpp.

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.

Enumerator
FutureTimeout_Infinite 
FutureTimeout_None 

Definition at line 110 of file future_fwd.hpp.

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.

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.

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.

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.

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.

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.

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
bufbuffer with serialized data
gvpinitialized AnyReference of correct type. Will be filled in.
onObjectcallback invoked each time an object is encountered.
ctxconnection context
Returns
the result of the deserialize type visitor
Exceptions
std::runtime_errorwhen the decoding fail
qi::AnyValue qi::decodeJSON ( const std::string &  in)

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

Parameters
inJSON 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
beginiterator to the beginning of the sequence to decode.
enditerator to the end of the sequence to decode.
targetGV 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
nameApplication 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
bufbuffer that will be filled with serialized data
gvpAnyReference to serialize
onObjectcallback invoked each time an object is encountered.
ctxconnection context
Exceptions
std::runtime_errorwhen the encoding fail
std::string qi::encodeJSON ( const qi::AutoAnyReference val,
JsonOption  jsonPrintOption = JsonOption_None 
)
Returns
the value encoded in JSON.
Parameters
valValue to encode
jsonPrintOptionOption 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
errorthe 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 
)

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
eccontext into which the call will be scheduled
objectThreadingModelthe threading model of the called object
methodThreadingModelthe threading model of the specific method
callTypethe requested threading model
manageablethe object on which to make the call
methodIdthe method id of the object to call
functhe function to call
paramsthe arguments of the call
noCloneFirstwhether the first argument of the call should be cloned or not
callerIdthread id of caller, for tracing purposes
postTimestampthe 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 ( 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 ( 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
specificationAn URL that may be incomplete, which specified parts must be kept.
baseUrlA 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
nthreadSet 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
condpointer 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
msgMessage to translate
domainDomain name
localeLocale name
contextContext 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:
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
msgMessage to translate
contextContext 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
vectThe 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
vectThe 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.