| ►Neos | |
| Cportable_archive_exception | Exception being thrown when serialization cannot proceed |
| ►Cportable_iarchive | Portable binary input archive using little endian format |
| Cdummy | |
| ►Cportable_oarchive | Portable binary output archive using little endian format |
| Cdummy | |
| ►Nqx | Root namespace for all QxOrm library features |
| ►Ncache | Provide basic thread-safe cache feature to backup and restore any kind of objects (for example, object fetched from database) |
| ►Ndetail | Internal helper tools for qx::cache namespace |
| CQxCache | |
| ►Ncvt | Provide global functions to convert any kind of objects to/from QString and QVariant format |
| ►Ndetail | Internal helper tools for qx::cvt namespace |
| ►Nhelper | |
| CQxConvertHelper_Container | |
| CQxConvertHelper_Enum | |
| CQxConvertHelper_Generic | |
| CQxConvertHelper_Persistable | |
| CQxConvertHelper_Ptr | |
| CQxConvertHelper_Registered | |
| CQxConvert_FromJson | |
| CQxConvert_FromJson< boost::scoped_ptr< T > > | |
| CQxConvert_FromJson< boost::shared_ptr< T > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4, T5 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| CQxConvert_FromJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| CQxConvert_FromJson< boost::unordered_map< Key, Value > > | |
| CQxConvert_FromJson< boost::unordered_map< QString, Value > > | |
| CQxConvert_FromJson< boost::unordered_map< std::string, Value > > | |
| CQxConvert_FromJson< boost::unordered_map< std::wstring, Value > > | |
| CQxConvert_FromJson< boost::unordered_multimap< Key, Value > > | |
| CQxConvert_FromJson< boost::unordered_multiset< T > > | |
| CQxConvert_FromJson< boost::unordered_set< T > > | |
| CQxConvert_FromJson< QBrush > | |
| CQxConvert_FromJson< QColor > | |
| CQxConvert_FromJson< QFlags< T > > | |
| CQxConvert_FromJson< QFont > | |
| CQxConvert_FromJson< QHash< Key, Value > > | |
| CQxConvert_FromJson< QHash< QString, Value > > | |
| CQxConvert_FromJson< QHash< std::string, Value > > | |
| CQxConvert_FromJson< QHash< std::wstring, Value > > | |
| CQxConvert_FromJson< QImage > | |
| CQxConvert_FromJson< QList< T > > | |
| CQxConvert_FromJson< QMap< Key, Value > > | |
| CQxConvert_FromJson< QMap< QString, Value > > | |
| CQxConvert_FromJson< QMap< std::string, Value > > | |
| CQxConvert_FromJson< QMap< std::wstring, Value > > | |
| CQxConvert_FromJson< QMultiHash< Key, Value > > | |
| CQxConvert_FromJson< QMultiMap< Key, Value > > | |
| CQxConvert_FromJson< QObject > | |
| CQxConvert_FromJson< QPicture > | |
| CQxConvert_FromJson< QPixmap > | |
| CQxConvert_FromJson< QPoint > | |
| CQxConvert_FromJson< QRect > | |
| CQxConvert_FromJson< QRegion > | |
| CQxConvert_FromJson< QScopedPointer< T > > | |
| CQxConvert_FromJson< QSharedPointer< T > > | |
| CQxConvert_FromJson< QSize > | |
| CQxConvert_FromJson< QSqlError > | |
| CQxConvert_FromJson< QStringList > | |
| CQxConvert_FromJson< QUrl > | |
| CQxConvert_FromJson< QVariantHash > | |
| CQxConvert_FromJson< QVariantMap > | |
| CQxConvert_FromJson< QWeakPointer< T > > | |
| CQxConvert_FromJson< qx::dao::detail::IxSqlElement > | |
| CQxConvert_FromJson< qx::dao::ptr< T > > | |
| CQxConvert_FromJson< qx::IxPersistable > | |
| CQxConvert_FromJson< qx::QxCollection< Key, Value > > | |
| CQxConvert_FromJson< qx::QxCollection< QString, Value > > | |
| CQxConvert_FromJson< qx::QxCollection< std::string, Value > > | |
| CQxConvert_FromJson< qx::QxCollection< std::wstring, Value > > | |
| CQxConvert_FromJson< qx::QxInvalidValue > | |
| CQxConvert_FromJson< qx::QxInvalidValueX > | |
| CQxConvert_FromJson< qx::QxSqlQuery > | |
| CQxConvert_FromJson< qx::service::IxParameter > | |
| CQxConvert_FromJson< qx::service::IxService > | |
| CQxConvert_FromJson< qx::service::QxTransaction > | |
| CQxConvert_FromJson< std::list< T > > | |
| CQxConvert_FromJson< std::map< Key, Value > > | |
| CQxConvert_FromJson< std::map< QString, Value > > | |
| CQxConvert_FromJson< std::map< std::string, Value > > | |
| CQxConvert_FromJson< std::map< std::wstring, Value > > | |
| CQxConvert_FromJson< std::optional< T > > | |
| CQxConvert_FromJson< std::pair< T1, T2 > > | |
| CQxConvert_FromJson< std::set< T > > | |
| CQxConvert_FromJson< std::shared_ptr< T > > | |
| CQxConvert_FromJson< std::tuple< T0, T1 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4, T5 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4, T5, T6 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| CQxConvert_FromJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| CQxConvert_FromJson< std::unique_ptr< T > > | |
| CQxConvert_FromJson< std::unordered_map< Key, Value > > | |
| CQxConvert_FromJson< std::unordered_map< QString, Value > > | |
| CQxConvert_FromJson< std::unordered_map< std::string, Value > > | |
| CQxConvert_FromJson< std::unordered_map< std::wstring, Value > > | |
| CQxConvert_FromJson< std::unordered_multimap< Key, Value > > | |
| CQxConvert_FromJson< std::unordered_multiset< T > > | |
| CQxConvert_FromJson< std::unordered_set< T > > | |
| CQxConvert_FromJson< std::vector< T > > | |
| CQxConvert_FromString | |
| CQxConvert_FromString< std::optional< T > > | |
| CQxConvert_FromVariant | |
| CQxConvert_FromVariant< std::optional< T > > | |
| CQxConvert_ToJson | |
| CQxConvert_ToJson< boost::scoped_ptr< T > > | |
| CQxConvert_ToJson< boost::shared_ptr< T > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4, T5 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| CQxConvert_ToJson< boost::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| CQxConvert_ToJson< boost::unordered_map< Key, Value > > | |
| CQxConvert_ToJson< boost::unordered_map< QString, Value > > | |
| CQxConvert_ToJson< boost::unordered_map< std::string, Value > > | |
| CQxConvert_ToJson< boost::unordered_map< std::wstring, Value > > | |
| CQxConvert_ToJson< boost::unordered_multimap< Key, Value > > | |
| CQxConvert_ToJson< boost::unordered_multiset< T > > | |
| CQxConvert_ToJson< boost::unordered_set< T > > | |
| CQxConvert_ToJson< QBrush > | |
| CQxConvert_ToJson< QColor > | |
| CQxConvert_ToJson< QFlags< T > > | |
| CQxConvert_ToJson< QFont > | |
| CQxConvert_ToJson< QHash< Key, Value > > | |
| CQxConvert_ToJson< QHash< QString, Value > > | |
| CQxConvert_ToJson< QHash< std::string, Value > > | |
| CQxConvert_ToJson< QHash< std::wstring, Value > > | |
| CQxConvert_ToJson< QImage > | |
| CQxConvert_ToJson< QList< T > > | |
| CQxConvert_ToJson< QMap< Key, Value > > | |
| CQxConvert_ToJson< QMap< QString, Value > > | |
| CQxConvert_ToJson< QMap< std::string, Value > > | |
| CQxConvert_ToJson< QMap< std::wstring, Value > > | |
| CQxConvert_ToJson< QMultiHash< Key, Value > > | |
| CQxConvert_ToJson< QMultiMap< Key, Value > > | |
| CQxConvert_ToJson< QObject > | |
| CQxConvert_ToJson< QPicture > | |
| CQxConvert_ToJson< QPixmap > | |
| CQxConvert_ToJson< QPoint > | |
| CQxConvert_ToJson< QRect > | |
| CQxConvert_ToJson< QRegion > | |
| CQxConvert_ToJson< QScopedPointer< T > > | |
| CQxConvert_ToJson< QSharedPointer< T > > | |
| CQxConvert_ToJson< QSize > | |
| CQxConvert_ToJson< QSqlError > | |
| CQxConvert_ToJson< QStringList > | |
| CQxConvert_ToJson< QUrl > | |
| CQxConvert_ToJson< QVariantHash > | |
| CQxConvert_ToJson< QVariantMap > | |
| CQxConvert_ToJson< QWeakPointer< T > > | |
| CQxConvert_ToJson< qx::dao::detail::IxSqlElement > | |
| CQxConvert_ToJson< qx::dao::ptr< T > > | |
| CQxConvert_ToJson< qx::IxPersistable > | |
| CQxConvert_ToJson< qx::QxCollection< Key, Value > > | |
| CQxConvert_ToJson< qx::QxCollection< QString, Value > > | |
| CQxConvert_ToJson< qx::QxCollection< std::string, Value > > | |
| CQxConvert_ToJson< qx::QxCollection< std::wstring, Value > > | |
| CQxConvert_ToJson< qx::QxInvalidValue > | |
| CQxConvert_ToJson< qx::QxInvalidValueX > | |
| CQxConvert_ToJson< qx::QxSqlQuery > | |
| CQxConvert_ToJson< qx::service::IxParameter > | |
| CQxConvert_ToJson< qx::service::IxService > | |
| CQxConvert_ToJson< qx::service::QxTransaction > | |
| CQxConvert_ToJson< std::list< T > > | |
| CQxConvert_ToJson< std::map< Key, Value > > | |
| CQxConvert_ToJson< std::map< QString, Value > > | |
| CQxConvert_ToJson< std::map< std::string, Value > > | |
| CQxConvert_ToJson< std::map< std::wstring, Value > > | |
| CQxConvert_ToJson< std::optional< T > > | |
| CQxConvert_ToJson< std::pair< T1, T2 > > | |
| CQxConvert_ToJson< std::set< T > > | |
| CQxConvert_ToJson< std::shared_ptr< T > > | |
| CQxConvert_ToJson< std::tuple< T0, T1 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4, T5 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4, T5, T6 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| CQxConvert_ToJson< std::tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| CQxConvert_ToJson< std::unique_ptr< T > > | |
| CQxConvert_ToJson< std::unordered_map< Key, Value > > | |
| CQxConvert_ToJson< std::unordered_map< QString, Value > > | |
| CQxConvert_ToJson< std::unordered_map< std::string, Value > > | |
| CQxConvert_ToJson< std::unordered_map< std::wstring, Value > > | |
| CQxConvert_ToJson< std::unordered_multimap< Key, Value > > | |
| CQxConvert_ToJson< std::unordered_multiset< T > > | |
| CQxConvert_ToJson< std::unordered_set< T > > | |
| CQxConvert_ToJson< std::vector< T > > | |
| CQxConvert_ToString | |
| CQxConvert_ToString< std::optional< T > > | |
| CQxConvert_ToVariant | |
| CQxConvert_ToVariant< std::optional< T > > | |
| CQxConvert_WithIndex_FromString | |
| CQxConvert_WithIndex_FromVariant | |
| CQxConvert_WithIndex_ToString | |
| CQxConvert_WithIndex_ToVariant | |
| CQxConvertHelper | |
| CQxConvertHelper_FromJson | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_FromJson< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxConvertHelper_FromString | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_FromString< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxConvertHelper_FromVariant | |
| CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| ►CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CcvtQVariant | |
| CcvtQVariant< true, dummy > | |
| CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_FromVariant< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxConvertHelper_ToJson | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_ToJson< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxConvertHelper_ToString | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_ToString< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxConvertHelper_ToVariant | |
| CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Container > | |
| CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Enum > | |
| ►CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Generic > | |
| CcvtQVariant | |
| CcvtQVariant< true, dummy > | |
| CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Persistable > | |
| CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Ptr > | |
| CQxConvertHelper_ToVariant< T, qx::cvt::detail::helper::QxConvertHelper_Registered > | |
| CQxSerializeJsonRegistered | |
| CQxSerializeJsonRegistered_Helper | |
| Ccontext | |
| ►Ndao | Database communication used by persistence engine (ORM - Object Relational Mapping) |
| ►Ndetail | Internal helper tools for qx::dao namespace |
| CIxDao_Helper | Qx::dao::detail::IxDao_Helper : helper class to communicate with database |
| CIxDao_Timer | Qx::dao::detail::IxDao_Timer : scoped timer to measure database elapsed times (using C++ RAII) |
| CIxSqlElement | Qx::dao::detail::IxSqlElement : common interface for all SQL elements to build SQL query |
| CIxSqlGenerator | Qx::dao::detail::IxSqlGenerator : common interface for all SQL generators to build SQL query specific for each database |
| CQxDao_Count | |
| CQxDao_Count_WithRelation | |
| CQxDao_CreateTable | |
| CQxDao_DeleteAll | |
| CQxDao_DeleteById | |
| CQxDao_ExecuteQuery | |
| CQxDao_Exist | |
| CQxDao_FetchAll | |
| CQxDao_FetchAll_WithRelation | |
| CQxDao_FetchById | |
| CQxDao_FetchById_WithRelation | |
| CQxDao_Insert | |
| CQxDao_Insert_WithRelation | |
| CQxDao_IsDirty | |
| CQxDao_IsDirty_Container | |
| CQxDao_IsDirty_Generic | |
| CQxDao_IsDirty_Ptr | |
| CQxDao_Save | |
| CQxDao_Save_WithRelation | |
| CQxDao_Save_WithRelation_Recursive | |
| CQxDao_Trigger | |
| CQxDao_Update | |
| CQxDao_Update_Optimized | |
| CQxDao_Update_WithRelation | |
| CQxDaoAsyncParams | Qx::dao::detail::QxDaoAsyncParams : all parameters for qx::QxDaoAsync class to execute queries |
| CQxDaoAsyncRunner | Qx::dao::detail::QxDaoAsyncRunner : class with a slot to execute queries in another thread |
| CQxSqlCompare | Qx::dao::detail::QxSqlCompare : SQL element to compare value (==, <, >, <=, >=, LIKE, NOT LIKE, etc.) |
| CQxSqlElementTemp | Qx::dao::detail::QxSqlElementTemp : temporary SQL element (need to be cloned to be used) |
| CQxSqlEmbedQuery | Qx::dao::detail::QxSqlEmbedQuery : SQL element to embed a SQL sub-query inside a parent SQL query |
| CQxSqlExpression | Qx::dao::detail::QxSqlExpression : SQL element to build a SQL expression (WHERE, AND, OR, etc.) |
| CQxSqlFreeText | Qx::dao::detail::QxSqlFreeText : possibility to add free text to SQL query |
| CQxSqlGenerator_MSSQLServer | Qx::dao::detail::QxSqlGenerator_MSSQLServer : SQL generator for Microsoft SQL Server database |
| CQxSqlGenerator_MySQL | Qx::dao::detail::QxSqlGenerator_MySQL : SQL generator for MySQL database |
| CQxSqlGenerator_Oracle | Qx::dao::detail::QxSqlGenerator_Oracle : SQL generator for Oracle database |
| CQxSqlGenerator_PostgreSQL | Qx::dao::detail::QxSqlGenerator_PostgreSQL : SQL generator for PostgreSQL database |
| CQxSqlGenerator_SQLite | Qx::dao::detail::QxSqlGenerator_SQLite : SQL generator for SQLite database |
| CQxSqlGenerator_Standard | Qx::dao::detail::QxSqlGenerator_Standard : SQL generator to build standard SQL query |
| CQxSqlIn | Qx::dao::detail::QxSqlIn : SQL element to verify a list of values (IN, NOT IN, etc.) |
| CQxSqlIsBetween | Qx::dao::detail::QxSqlIsBetween : SQL element to verify if a value is included into 2 other values |
| CQxSqlIsNull | Qx::dao::detail::QxSqlIsNull : SQL element to verify if a value is null or not null (IS NULL, IS NOT NULL) |
| CQxSqlLimit | Qx::dao::detail::QxSqlLimit : SQL element to limit rows count fetched from database |
| CQxSqlQueryHelper_CreateTable | |
| CQxSqlQueryHelper_DeleteById | |
| CQxSqlQueryHelper_Exist | |
| CQxSqlQueryHelper_FetchAll | |
| CQxSqlQueryHelper_FetchAll_WithRelation | |
| CQxSqlQueryHelper_FetchById | |
| CQxSqlQueryHelper_FetchById_WithRelation | |
| CQxSqlQueryHelper_Insert | |
| CQxSqlQueryHelper_Update | |
| CQxSqlSort | Qx::dao::detail::QxSqlSort : SQL element to sort or to group list of elements fetched from database (ORDER BY, GROUP BY) |
| Cptr | Qx::dao::ptr<T> : provide a classic smart-pointer (like boost::shared_ptr<T> or QSharedPointer<T>) with some features associated with QxDao module of QxOrm library |
| Csave_mode | Qx::dao::save_mode : to improve performance, if you know that you are just inserting or updating items in database |
| Csql_error | Qx::dao::sql_error : define a SQL error exception and retrieve QSqlError type of Qt library |
| Csql_join | Qx::dao::sql_join : define how to join 2 tables into SQL query (LEFT OUTER JOIN, INNER JOIN, etc...) |
| Cstrategy | Qx::dao::strategy : class inheritance strategy and database (Concrete Table Inheritance is the default strategy used by QxOrm library) |
| ►Nforeach | Foreach-style (based on BOOST_FOREACH macro) to iterate over all stl, boost and Qt containers + qx::QxCollection<Key, Value> QxOrm library container |
| Cqx_deref | |
| Cqx_deref_boost_or_qx | |
| Cqx_deref_boost_or_qx< T, C, true > | |
| Cqx_deref_deduce | |
| Cqx_deref_deduce< T, C, true > | |
| ►Nmemory | QxOrm library memory leak detection (by Wu Yongwei) |
| C__debug_new_counter | |
| C__debug_new_recorder | |
| C__nvwa_compile_time_error | |
| C__nvwa_compile_time_error< true > | |
| ►Cbool_array | |
| C_Element | |
| ►Cclass_level_lock | |
| Clock | |
| Cdelete_object | |
| Cdereference | |
| Cdereference_less | |
| Cfast_mutex | |
| Cfast_mutex_autolock | |
| Cfixed_mem_pool | |
| ►Cmem_pool_base | |
| C_Block_list | |
| ►Cobject_level_lock | |
| Clock | |
| Coutput_object | |
| Cstatic_mem_pool | |
| Cstatic_mem_pool_set | |
| ►Nmodel_view | |
| ►Ndetail | |
| CQxNestedModel | |
| ►CQxNestedModel_Container | |
| CinsertItem_Helper | |
| CinsertItem_Helper< const std::pair< U1, U2 >, false > | |
| CinsertItem_Helper< std::pair< U1, U2 >, false > | |
| CinsertItem_Helper< U, false > | |
| CQxNestedModel_Creator | |
| CQxNestedModel_Creator< T, M, true > | |
| CQxNestedModel_Generic | |
| CQxNestedModel_Helper | |
| CQxNestedModel_Helper< T, true > | |
| CQxNestedModel_Ptr | |
| CQxModelRowCompare | Qx::QxModelRowCompare : functor used to provide sort feature for all models based on qx::IxModel interface (please note that you can also use QSortFilterProxyModel Qt class to sort your model) |
| ►Nserialization | QxOrm library serialization engine based on boost::serialization library |
| ►Ndetail | Internal helper tools for qx::serialization namespace |
| Cbase_class | |
| Cbase_class< qx::trait::no_base_class_defined > | |
| Cloader | |
| Csaver | |
| ►Nhelper | |
| CQxSerializeCheckInstance | Qx::serialization::helper::QxSerializeCheckInstance : check instance during serialization process to avoid infinite loop with circular references (using RAII) |
| ►Nservice | QxOrm library services engine to provide easy and powerful way to create C++ application server (to transfer data over network) |
| CIxParameter | Qx::service::IxParameter : common interface for all parameters transfered by QxService module of QxOrm library |
| CIxService | Qx::service::IxService : common interface for all services defined with QxService module of QxOrm library |
| CQxClientAsync | Qx::service::QxClientAsync : class helper to easily execute an asynchronous transaction using a multi-thread process |
| CQxConnect | Qx::service::QxConnect : define connection parameters used by QxService module of QxOrm library (this class is a singleton) |
| CQxServer | Qx::service::QxServer : server side to manage a thread pool of incoming connections (new request from client) |
| CQxService | Qx::service::QxService<INPUT, OUTPUT> : concrete service class with INPUT parameters and OUTPUT parameters |
| CQxThread | Qx::service::QxThread : thread to execute a transaction of QxService module |
| CQxThreadPool | Qx::service::QxThreadPool : thread-safe thread pool to manage list of threads for executing all transactions of QxService module |
| CQxTools | Qx::service::QxTools : provide some tools to read/write on socket all datas transfered by QxService module of QxOrm library |
| CQxTransaction | Qx::service::QxTransaction : transaction of QxService module (contains request from client and reply from server) |
| ►Ntrait | QxOrm library traits (template metaprogramming) not available in boost::type_traits library |
| ►Ndetail | Internal helper tools for qx::trait namespace |
| Cgeneric_container_base | |
| Cgeneric_container_base_key_value_multi_std_style | |
| Cgeneric_container_base_key_value_qt_style | |
| Cgeneric_container_base_key_value_std_style | |
| Cgeneric_container_base_key_value_without_reserve | |
| Cgeneric_container_base_multi_set | |
| Cgeneric_container_base_set | |
| Cgeneric_container_base_without_reserve | |
| Cget_sql_type | |
| Cget_sql_type_helper | |
| Cis_valid_primary_key | Qx::trait::is_valid_primary_key<T>(const T & t) : return true if t can be a valid primary key to be inserted into a database, otherwise return false |
| Cis_valid_primary_key< int > | |
| Cis_valid_primary_key< long > | |
| Cis_valid_primary_key< long long > | |
| Cis_valid_primary_key< QByteArray > | |
| Cis_valid_primary_key< QString > | |
| Cis_valid_primary_key< QVariant > | |
| Cis_valid_primary_key< short > | |
| Cis_valid_primary_key< std::string > | |
| Cis_valid_primary_key< std::wstring > | |
| ►Carchive_wide_traits | |
| CcvtQByteArray | |
| CcvtQByteArray< true, dummy > | |
| CcvtQString | |
| CcvtQString< true, dummy > | |
| Cconstruct_null_qvariant | Qx::trait::construct_null_qvariant<T>::get() : create a NULL QVariant which matches QVariant::Type with type T |
| Cconstruct_null_qvariant< bool & > | |
| Cconstruct_null_qvariant< bool > | |
| Cconstruct_null_qvariant< const bool & > | |
| Cconstruct_null_qvariant< const bool > | |
| Cconstruct_null_qvariant< const double & > | |
| Cconstruct_null_qvariant< const double > | |
| Cconstruct_null_qvariant< const float & > | |
| Cconstruct_null_qvariant< const float > | |
| Cconstruct_null_qvariant< const int & > | |
| Cconstruct_null_qvariant< const int > | |
| Cconstruct_null_qvariant< const long & > | |
| Cconstruct_null_qvariant< const long > | |
| Cconstruct_null_qvariant< const long long & > | |
| Cconstruct_null_qvariant< const long long > | |
| Cconstruct_null_qvariant< const QBitArray & > | |
| Cconstruct_null_qvariant< const QBitArray > | |
| Cconstruct_null_qvariant< const QBrush & > | |
| Cconstruct_null_qvariant< const QBrush > | |
| Cconstruct_null_qvariant< const QByteArray & > | |
| Cconstruct_null_qvariant< const QByteArray > | |
| Cconstruct_null_qvariant< const QColor & > | |
| Cconstruct_null_qvariant< const QColor > | |
| Cconstruct_null_qvariant< const QDate & > | |
| Cconstruct_null_qvariant< const QDate > | |
| Cconstruct_null_qvariant< const QDateTime & > | |
| Cconstruct_null_qvariant< const QDateTime > | |
| Cconstruct_null_qvariant< const QFont & > | |
| Cconstruct_null_qvariant< const QFont > | |
| Cconstruct_null_qvariant< const QImage & > | |
| Cconstruct_null_qvariant< const QImage > | |
| Cconstruct_null_qvariant< const QPixmap & > | |
| Cconstruct_null_qvariant< const QPixmap > | |
| Cconstruct_null_qvariant< const QRegion & > | |
| Cconstruct_null_qvariant< const QRegion > | |
| Cconstruct_null_qvariant< const QString & > | |
| Cconstruct_null_qvariant< const QString > | |
| Cconstruct_null_qvariant< const QStringList & > | |
| Cconstruct_null_qvariant< const QStringList > | |
| Cconstruct_null_qvariant< const QTime & > | |
| Cconstruct_null_qvariant< const QTime > | |
| Cconstruct_null_qvariant< const QUuid & > | |
| Cconstruct_null_qvariant< const QUuid > | |
| Cconstruct_null_qvariant< const qx::QxDateNeutral & > | |
| Cconstruct_null_qvariant< const qx::QxDateNeutral > | |
| Cconstruct_null_qvariant< const qx::QxDateTimeNeutral & > | |
| Cconstruct_null_qvariant< const qx::QxDateTimeNeutral > | |
| Cconstruct_null_qvariant< const qx::QxTimeNeutral & > | |
| Cconstruct_null_qvariant< const qx::QxTimeNeutral > | |
| Cconstruct_null_qvariant< const short & > | |
| Cconstruct_null_qvariant< const short > | |
| Cconstruct_null_qvariant< const std::string & > | |
| Cconstruct_null_qvariant< const std::string > | |
| Cconstruct_null_qvariant< const std::wstring & > | |
| Cconstruct_null_qvariant< const std::wstring > | |
| Cconstruct_null_qvariant< const unsigned int & > | |
| Cconstruct_null_qvariant< const unsigned int > | |
| Cconstruct_null_qvariant< const unsigned long & > | |
| Cconstruct_null_qvariant< const unsigned long > | |
| Cconstruct_null_qvariant< const unsigned long long & > | |
| Cconstruct_null_qvariant< const unsigned long long > | |
| Cconstruct_null_qvariant< const unsigned short & > | |
| Cconstruct_null_qvariant< const unsigned short > | |
| Cconstruct_null_qvariant< double & > | |
| Cconstruct_null_qvariant< double > | |
| Cconstruct_null_qvariant< float & > | |
| Cconstruct_null_qvariant< float > | |
| Cconstruct_null_qvariant< int & > | |
| Cconstruct_null_qvariant< int > | |
| Cconstruct_null_qvariant< long & > | |
| Cconstruct_null_qvariant< long > | |
| Cconstruct_null_qvariant< long long & > | |
| Cconstruct_null_qvariant< long long > | |
| Cconstruct_null_qvariant< QBitArray & > | |
| Cconstruct_null_qvariant< QBitArray > | |
| Cconstruct_null_qvariant< QBrush & > | |
| Cconstruct_null_qvariant< QBrush > | |
| Cconstruct_null_qvariant< QByteArray & > | |
| Cconstruct_null_qvariant< QByteArray > | |
| Cconstruct_null_qvariant< QColor & > | |
| Cconstruct_null_qvariant< QColor > | |
| Cconstruct_null_qvariant< QDate & > | |
| Cconstruct_null_qvariant< QDate > | |
| Cconstruct_null_qvariant< QDateTime & > | |
| Cconstruct_null_qvariant< QDateTime > | |
| Cconstruct_null_qvariant< QFont & > | |
| Cconstruct_null_qvariant< QFont > | |
| Cconstruct_null_qvariant< QImage & > | |
| Cconstruct_null_qvariant< QImage > | |
| Cconstruct_null_qvariant< QPixmap & > | |
| Cconstruct_null_qvariant< QPixmap > | |
| Cconstruct_null_qvariant< QRegion & > | |
| Cconstruct_null_qvariant< QRegion > | |
| Cconstruct_null_qvariant< QString & > | |
| Cconstruct_null_qvariant< QString > | |
| Cconstruct_null_qvariant< QStringList & > | |
| Cconstruct_null_qvariant< QStringList > | |
| Cconstruct_null_qvariant< QTime & > | |
| Cconstruct_null_qvariant< QTime > | |
| Cconstruct_null_qvariant< QUuid & > | |
| Cconstruct_null_qvariant< QUuid > | |
| Cconstruct_null_qvariant< qx::QxDateNeutral & > | |
| Cconstruct_null_qvariant< qx::QxDateNeutral > | |
| Cconstruct_null_qvariant< qx::QxDateTimeNeutral & > | |
| Cconstruct_null_qvariant< qx::QxDateTimeNeutral > | |
| Cconstruct_null_qvariant< qx::QxTimeNeutral & > | |
| Cconstruct_null_qvariant< qx::QxTimeNeutral > | |
| Cconstruct_null_qvariant< short & > | |
| Cconstruct_null_qvariant< short > | |
| Cconstruct_null_qvariant< std::string & > | |
| Cconstruct_null_qvariant< std::string > | |
| Cconstruct_null_qvariant< std::wstring & > | |
| Cconstruct_null_qvariant< std::wstring > | |
| Cconstruct_null_qvariant< unsigned int & > | |
| Cconstruct_null_qvariant< unsigned int > | |
| Cconstruct_null_qvariant< unsigned long & > | |
| Cconstruct_null_qvariant< unsigned long > | |
| Cconstruct_null_qvariant< unsigned long long & > | |
| Cconstruct_null_qvariant< unsigned long long > | |
| Cconstruct_null_qvariant< unsigned short & > | |
| Cconstruct_null_qvariant< unsigned short > | |
| ►Cconstruct_ptr | Qx::trait::construct_ptr<T>::get(T & t, bool bReset = false) : instantiate (or reset) a new pointer, support both nude-pointer and smart-pointer of boost, Qt and QxOrm libraries |
| Cnew_ptr | |
| Cnew_ptr< true, dummy > | |
| Cconstruct_ptr< boost::intrusive_ptr< T > > | |
| Cconstruct_ptr< boost::scoped_ptr< T > > | |
| Cconstruct_ptr< boost::shared_ptr< T > > | |
| Cconstruct_ptr< QScopedPointer< T > > | |
| Cconstruct_ptr< QSharedPointer< T > > | |
| Cconstruct_ptr< qx::dao::ptr< T > > | |
| Cconstruct_ptr< std::shared_ptr< T > > | |
| Cconstruct_ptr< std::unique_ptr< T > > | |
| Cgeneric_container | Qx::trait::generic_container<T> : provide some tools to manage all containers without knowing its type |
| Cgeneric_container< boost::unordered_map< Key, Value > > | |
| Cgeneric_container< boost::unordered_multimap< Key, Value > > | |
| Cgeneric_container< boost::unordered_multiset< T > > | |
| Cgeneric_container< boost::unordered_set< T > > | |
| Cgeneric_container< QHash< Key, Value > > | |
| Cgeneric_container< QList< T > > | |
| Cgeneric_container< QMap< Key, Value > > | |
| Cgeneric_container< QMultiHash< Key, Value > > | |
| Cgeneric_container< QMultiMap< Key, Value > > | |
| Cgeneric_container< QSet< T > > | |
| Cgeneric_container< qx::QxCollection< Key, Value > > | |
| Cgeneric_container< std::list< T > > | |
| Cgeneric_container< std::map< Key, Value > > | |
| Cgeneric_container< std::set< T > > | |
| Cgeneric_container< std::unordered_map< Key, Value > > | |
| Cgeneric_container< std::unordered_multimap< Key, Value > > | |
| Cgeneric_container< std::unordered_multiset< T > > | |
| Cgeneric_container< std::unordered_set< T > > | |
| Cgeneric_container< std::vector< T > > | |
| ►Cgeneric_container_item | |
| Cnew_Helper | |
| Cnew_Helper< false, T, dummy > | |
| Cvalue_qx_Helper | |
| Cvalue_qx_Helper< false, T, U, dummy > | |
| Cget_base_class | Qx::trait::get_base_class<T>::type : retrieve base class of type T registered into QxOrm context and return qx::trait::no_base_class_defined if no base class defined |
| Cget_base_class_2 | |
| Cget_class_name | Qx::trait::get_class_name<T>::get() : return class name of type T under const char * format, T must be registered with QX_REGISTER_CLASS_NAME(T) macro |
| Cget_primary_key | Qx::trait::get_primary_key<T>::type : return primary key type of T, by default primary key is long type, use QX_REGISTER_PRIMARY_KEY() macro to register another type (for example QX_REGISTER_PRIMARY_KEY(T, QString)) |
| Cget_sql_type | Qx::trait::get_sql_type<T>::get() : return type name under const char * format used by database engine to map a C++ type T |
| Cget_sql_type< boost::intrusive_ptr< T > > | |
| Cget_sql_type< boost::optional< T > > | |
| Cget_sql_type< boost::scoped_ptr< T > > | |
| Cget_sql_type< boost::shared_ptr< T > > | |
| Cget_sql_type< boost::tuple< T1, T2 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4, T5 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4, T5, T6 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4, T5, T6, T7 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| Cget_sql_type< boost::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| Cget_sql_type< QScopedPointer< T > > | |
| Cget_sql_type< QSharedPointer< T > > | |
| Cget_sql_type< qx::dao::ptr< T > > | |
| Cget_sql_type< std::optional< T > > | |
| Cget_sql_type< std::pair< T1, T2 > > | |
| Cget_sql_type< std::shared_ptr< T > > | |
| Cget_sql_type< std::tuple< T1, T2 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4, T5 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4, T5, T6 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4, T5, T6, T7 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4, T5, T6, T7, T8 > > | |
| Cget_sql_type< std::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | |
| Cget_sql_type< std::unique_ptr< T > > | |
| Chas_operator_equal_equal | Qx::trait::has_operator_equal_equal<T>::value : return true if T provides operator==() function, T must be registered with QX_TYPE_HAS_OPERATOR_EQUAL_EQUAL(T) macro |
| Cis_archive_printable | Qx::trait::is_archive_printable<T>::value : define if a boost::archive type is readable by a human (for example XML archive) or not (for example binary archive) |
| Cis_archive_printable< boost::archive::polymorphic_iarchive > | |
| Cis_archive_printable< boost::archive::polymorphic_oarchive > | |
| Cis_archive_printable< boost::archive::text_iarchive > | |
| Cis_archive_printable< boost::archive::text_oarchive > | |
| Cis_archive_printable< boost::archive::text_wiarchive > | |
| Cis_archive_printable< boost::archive::text_woarchive > | |
| Cis_archive_printable< boost::archive::xml_iarchive > | |
| Cis_archive_printable< boost::archive::xml_oarchive > | |
| Cis_archive_printable< boost::archive::xml_wiarchive > | |
| Cis_archive_printable< boost::archive::xml_woarchive > | |
| Cis_archive_wide | Qx::trait::is_archive_wide<T>::value : define if a boost::archive type uses wide string character and stream (for example std::wstring) or not (for example std::string) |
| Cis_archive_wide< boost::archive::binary_wiarchive > | |
| Cis_archive_wide< boost::archive::binary_woarchive > | |
| Cis_archive_wide< boost::archive::text_wiarchive > | |
| Cis_archive_wide< boost::archive::text_woarchive > | |
| Cis_archive_wide< boost::archive::xml_wiarchive > | |
| Cis_archive_wide< boost::archive::xml_woarchive > | |
| Cis_base_class_defined | |
| Cis_boost_intrusive_ptr | Qx::trait::is_boost_intrusive_ptr<T>::value : return true if T is a boost::intrusive_ptr<> smart-pointer, otherwise return false |
| Cis_boost_intrusive_ptr< boost::intrusive_ptr< T > & > | |
| Cis_boost_intrusive_ptr< boost::intrusive_ptr< T > > | |
| Cis_boost_intrusive_ptr< const boost::intrusive_ptr< T > & > | |
| Cis_boost_intrusive_ptr< const boost::intrusive_ptr< T > > | |
| Cis_boost_scoped_ptr | Qx::trait::is_boost_scoped_ptr<T>::value : return true if T is a boost::scoped_ptr<> smart-pointer, otherwise return false |
| Cis_boost_scoped_ptr< boost::scoped_ptr< T > & > | |
| Cis_boost_scoped_ptr< boost::scoped_ptr< T > > | |
| Cis_boost_scoped_ptr< const boost::scoped_ptr< T > & > | |
| Cis_boost_scoped_ptr< const boost::scoped_ptr< T > > | |
| Cis_boost_shared_ptr | Qx::trait::is_boost_shared_ptr<T>::value : return true if T is a boost::shared_ptr<> smart-pointer, otherwise return false |
| Cis_boost_shared_ptr< boost::shared_ptr< T > & > | |
| Cis_boost_shared_ptr< boost::shared_ptr< T > > | |
| Cis_boost_shared_ptr< const boost::shared_ptr< T > & > | |
| Cis_boost_shared_ptr< const boost::shared_ptr< T > > | |
| Cis_boost_unordered_map | Qx::trait::is_boost_unordered_map<T>::value : return true if T is a boost::unordered_map<> or boost::unordered_multimap<> container, otherwise return false |
| Cis_boost_unordered_map< boost::unordered_map< Key, Value > & > | |
| Cis_boost_unordered_map< boost::unordered_map< Key, Value > > | |
| Cis_boost_unordered_map< boost::unordered_multimap< Key, Value > & > | |
| Cis_boost_unordered_map< boost::unordered_multimap< Key, Value > > | |
| Cis_boost_unordered_map< const boost::unordered_map< Key, Value > & > | |
| Cis_boost_unordered_map< const boost::unordered_map< Key, Value > > | |
| Cis_boost_unordered_map< const boost::unordered_multimap< Key, Value > & > | |
| Cis_boost_unordered_map< const boost::unordered_multimap< Key, Value > > | |
| Cis_boost_unordered_set | Qx::trait::is_boost_unordered_set<T>::value : return true if T is a boost::unordered_set<> or boost::unordered_multiset<> container, otherwise return false |
| Cis_boost_unordered_set< boost::unordered_multiset< T > & > | |
| Cis_boost_unordered_set< boost::unordered_multiset< T > > | |
| Cis_boost_unordered_set< boost::unordered_set< T > & > | |
| Cis_boost_unordered_set< boost::unordered_set< T > > | |
| Cis_boost_unordered_set< const boost::unordered_multiset< T > & > | |
| Cis_boost_unordered_set< const boost::unordered_multiset< T > > | |
| Cis_boost_unordered_set< const boost::unordered_set< T > & > | |
| Cis_boost_unordered_set< const boost::unordered_set< T > > | |
| Cis_boost_weak_ptr | Qx::trait::is_boost_weak_ptr<T>::value : return true if T is a boost::weak_ptr<> smart-pointer, otherwise return false |
| Cis_boost_weak_ptr< boost::weak_ptr< T > & > | |
| Cis_boost_weak_ptr< boost::weak_ptr< T > > | |
| Cis_boost_weak_ptr< const boost::weak_ptr< T > & > | |
| Cis_boost_weak_ptr< const boost::weak_ptr< T > > | |
| Cis_container | Qx::trait::is_container<T>::value : return true if T is a container from stl, boost, Qt or QxOrm library, otherwise return false |
| Cis_container< boost::unordered_map< Key, Value > & > | |
| Cis_container< boost::unordered_map< Key, Value > > | |
| Cis_container< boost::unordered_multimap< Key, Value > & > | |
| Cis_container< boost::unordered_multimap< Key, Value > > | |
| Cis_container< boost::unordered_multiset< T > & > | |
| Cis_container< boost::unordered_multiset< T > > | |
| Cis_container< boost::unordered_set< T > & > | |
| Cis_container< boost::unordered_set< T > > | |
| Cis_container< const boost::unordered_map< Key, Value > & > | |
| Cis_container< const boost::unordered_map< Key, Value > > | |
| Cis_container< const boost::unordered_multimap< Key, Value > & > | |
| Cis_container< const boost::unordered_multimap< Key, Value > > | |
| Cis_container< const boost::unordered_multiset< T > & > | |
| Cis_container< const boost::unordered_multiset< T > > | |
| Cis_container< const boost::unordered_set< T > & > | |
| Cis_container< const boost::unordered_set< T > > | |
| Cis_container< const QHash< Key, Value > & > | |
| Cis_container< const QHash< Key, Value > > | |
| Cis_container< const QList< T > & > | |
| Cis_container< const QList< T > > | |
| Cis_container< const QMap< Key, Value > & > | |
| Cis_container< const QMap< Key, Value > > | |
| Cis_container< const QMultiHash< Key, Value > & > | |
| Cis_container< const QMultiHash< Key, Value > > | |
| Cis_container< const QMultiMap< Key, Value > & > | |
| Cis_container< const QMultiMap< Key, Value > > | |
| Cis_container< const QSet< T > & > | |
| Cis_container< const QSet< T > > | |
| Cis_container< const qx::QxCollection< Key, Value > & > | |
| Cis_container< const qx::QxCollection< Key, Value > > | |
| Cis_container< const std::list< T > & > | |
| Cis_container< const std::list< T > > | |
| Cis_container< const std::map< Key, Value > & > | |
| Cis_container< const std::map< Key, Value > > | |
| Cis_container< const std::set< T > & > | |
| Cis_container< const std::set< T > > | |
| Cis_container< const std::unordered_map< Key, Value > & > | |
| Cis_container< const std::unordered_map< Key, Value > > | |
| Cis_container< const std::unordered_multimap< Key, Value > & > | |
| Cis_container< const std::unordered_multimap< Key, Value > > | |
| Cis_container< const std::unordered_multiset< T > & > | |
| Cis_container< const std::unordered_multiset< T > > | |
| Cis_container< const std::unordered_set< T > & > | |
| Cis_container< const std::unordered_set< T > > | |
| Cis_container< const std::vector< T > & > | |
| Cis_container< const std::vector< T > > | |
| Cis_container< QHash< Key, Value > & > | |
| Cis_container< QHash< Key, Value > > | |
| Cis_container< QList< T > & > | |
| Cis_container< QList< T > > | |
| Cis_container< QMap< Key, Value > & > | |
| Cis_container< QMap< Key, Value > > | |
| Cis_container< QMultiHash< Key, Value > & > | |
| Cis_container< QMultiHash< Key, Value > > | |
| Cis_container< QMultiMap< Key, Value > & > | |
| Cis_container< QMultiMap< Key, Value > > | |
| Cis_container< QSet< T > & > | |
| Cis_container< QSet< T > > | |
| Cis_container< qx::QxCollection< Key, Value > & > | |
| Cis_container< qx::QxCollection< Key, Value > > | |
| Cis_container< std::list< T > & > | |
| Cis_container< std::list< T > > | |
| Cis_container< std::map< Key, Value > & > | |
| Cis_container< std::map< Key, Value > > | |
| Cis_container< std::set< T > & > | |
| Cis_container< std::set< T > > | |
| Cis_container< std::unordered_map< Key, Value > & > | |
| Cis_container< std::unordered_map< Key, Value > > | |
| Cis_container< std::unordered_multimap< Key, Value > & > | |
| Cis_container< std::unordered_multimap< Key, Value > > | |
| Cis_container< std::unordered_multiset< T > & > | |
| Cis_container< std::unordered_multiset< T > > | |
| Cis_container< std::unordered_set< T > & > | |
| Cis_container< std::unordered_set< T > > | |
| Cis_container< std::vector< T > & > | |
| Cis_container< std::vector< T > > | |
| Cis_container_base_of | |
| Cis_container_key_value | Qx::trait::is_container_key_value<T>::value : return true if T is a map or hash-map (with <Key, Value> template format) container from stl, boost, Qt or QxOrm library, otherwise return false |
| Cis_container_key_value< boost::unordered_map< Key, Value > & > | |
| Cis_container_key_value< boost::unordered_map< Key, Value > > | |
| Cis_container_key_value< boost::unordered_multimap< Key, Value > & > | |
| Cis_container_key_value< boost::unordered_multimap< Key, Value > > | |
| Cis_container_key_value< const boost::unordered_map< Key, Value > & > | |
| Cis_container_key_value< const boost::unordered_map< Key, Value > > | |
| Cis_container_key_value< const boost::unordered_multimap< Key, Value > & > | |
| Cis_container_key_value< const boost::unordered_multimap< Key, Value > > | |
| Cis_container_key_value< const QHash< Key, Value > & > | |
| Cis_container_key_value< const QHash< Key, Value > > | |
| Cis_container_key_value< const QMap< Key, Value > & > | |
| Cis_container_key_value< const QMap< Key, Value > > | |
| Cis_container_key_value< const QMultiHash< Key, Value > & > | |
| Cis_container_key_value< const QMultiHash< Key, Value > > | |
| Cis_container_key_value< const QMultiMap< Key, Value > & > | |
| Cis_container_key_value< const QMultiMap< Key, Value > > | |
| Cis_container_key_value< const qx::QxCollection< Key, Value > & > | |
| Cis_container_key_value< const qx::QxCollection< Key, Value > > | |
| Cis_container_key_value< const std::map< Key, Value > & > | |
| Cis_container_key_value< const std::map< Key, Value > > | |
| Cis_container_key_value< const std::unordered_map< Key, Value > & > | |
| Cis_container_key_value< const std::unordered_map< Key, Value > > | |
| Cis_container_key_value< const std::unordered_multimap< Key, Value > & > | |
| Cis_container_key_value< const std::unordered_multimap< Key, Value > > | |
| Cis_container_key_value< QHash< Key, Value > & > | |
| Cis_container_key_value< QHash< Key, Value > > | |
| Cis_container_key_value< QMap< Key, Value > & > | |
| Cis_container_key_value< QMap< Key, Value > > | |
| Cis_container_key_value< QMultiHash< Key, Value > & > | |
| Cis_container_key_value< QMultiHash< Key, Value > > | |
| Cis_container_key_value< QMultiMap< Key, Value > & > | |
| Cis_container_key_value< QMultiMap< Key, Value > > | |
| Cis_container_key_value< qx::QxCollection< Key, Value > & > | |
| Cis_container_key_value< qx::QxCollection< Key, Value > > | |
| Cis_container_key_value< std::map< Key, Value > & > | |
| Cis_container_key_value< std::map< Key, Value > > | |
| Cis_container_key_value< std::unordered_map< Key, Value > & > | |
| Cis_container_key_value< std::unordered_map< Key, Value > > | |
| Cis_container_key_value< std::unordered_multimap< Key, Value > & > | |
| Cis_container_key_value< std::unordered_multimap< Key, Value > > | |
| Cis_container_to_pod | |
| Cis_ix_persistable | Qx::trait::is_ix_persistable<T>::value : return true if T implements qx::IxPersistable interface, otherwise return false |
| Cis_ptr_base_of | Qx::trait::is_ptr_base_of<B, D>::value : return true if B and D are pointer type and (*B) is a base class of (*D) or if B and D are same type, otherwise return false |
| Cis_ptr_to_pod | Qx::trait::is_ptr_to_pod<T>::value : return true if T is a pointer to a POD type (char, int, long, etc.), otherwise return false |
| Cis_qt_hash | Qx::trait::is_qt_hash<T>::value : return true if T is a QHash<> container of Qt library, otherwise return false |
| Cis_qt_hash< const QHash< Key, Value > & > | |
| Cis_qt_hash< const QHash< Key, Value > > | |
| Cis_qt_hash< QHash< Key, Value > & > | |
| Cis_qt_hash< QHash< Key, Value > > | |
| Cis_qt_list | Qx::trait::is_qt_list<T>::value : return true if T is a QList<> container of Qt library, otherwise return false |
| Cis_qt_list< const QList< T > & > | |
| Cis_qt_list< const QList< T > > | |
| Cis_qt_list< QList< T > & > | |
| Cis_qt_list< QList< T > > | |
| Cis_qt_map | Qx::trait::is_qt_map<T>::value : return true if T is a QMap<> container of Qt library, otherwise return false |
| Cis_qt_map< const QMap< Key, Value > & > | |
| Cis_qt_map< const QMap< Key, Value > > | |
| Cis_qt_map< QMap< Key, Value > & > | |
| Cis_qt_map< QMap< Key, Value > > | |
| Cis_qt_multi_hash | Qx::trait::is_qt_multi_hash<T>::value : return true if T is a QMultiHash<> container of Qt library, otherwise return false |
| Cis_qt_multi_hash< const QMultiHash< Key, Value > & > | |
| Cis_qt_multi_hash< const QMultiHash< Key, Value > > | |
| Cis_qt_multi_hash< QMultiHash< Key, Value > & > | |
| Cis_qt_multi_hash< QMultiHash< Key, Value > > | |
| Cis_qt_multi_map | Qx::trait::is_qt_multi_map<T>::value : return true if T is a QMultiMap<> container of Qt library, otherwise return false |
| Cis_qt_multi_map< const QMultiMap< Key, Value > & > | |
| Cis_qt_multi_map< const QMultiMap< Key, Value > > | |
| Cis_qt_multi_map< QMultiMap< Key, Value > & > | |
| Cis_qt_multi_map< QMultiMap< Key, Value > > | |
| Cis_qt_scoped_ptr | Qx::trait::is_qt_scoped_ptr<T>::value : return true if T is a QScopedPointer<> smart-pointer of Qt library, otherwise return false |
| Cis_qt_scoped_ptr< const QScopedPointer< T > & > | |
| Cis_qt_scoped_ptr< const QScopedPointer< T > > | |
| Cis_qt_scoped_ptr< QScopedPointer< T > & > | |
| Cis_qt_scoped_ptr< QScopedPointer< T > > | |
| Cis_qt_set | Qx::trait::is_qt_set<T>::value : return true if T is a QSet<> container of Qt library, otherwise return false |
| Cis_qt_set< const QSet< T > & > | |
| Cis_qt_set< const QSet< T > > | |
| Cis_qt_set< QSet< T > & > | |
| Cis_qt_set< QSet< T > > | |
| Cis_qt_shared_data_ptr | Qx::trait::is_qt_shared_data_ptr<T>::value : return true if T is a QSharedDataPointer<> smart-pointer of Qt library, otherwise return false |
| Cis_qt_shared_data_ptr< const QSharedDataPointer< T > & > | |
| Cis_qt_shared_data_ptr< const QSharedDataPointer< T > > | |
| Cis_qt_shared_data_ptr< QSharedDataPointer< T > & > | |
| Cis_qt_shared_data_ptr< QSharedDataPointer< T > > | |
| Cis_qt_shared_ptr | Qx::trait::is_qt_shared_ptr<T>::value : return true if T is a QSharedPointer<> smart-pointer of Qt library, otherwise return false |
| Cis_qt_shared_ptr< const QSharedPointer< T > & > | |
| Cis_qt_shared_ptr< const QSharedPointer< T > > | |
| Cis_qt_shared_ptr< QSharedPointer< T > & > | |
| Cis_qt_shared_ptr< QSharedPointer< T > > | |
| Cis_qt_variant_compatible | Qx::trait::is_qt_variant_compatible<T>::value : return true if T can be host into a QVariant object of Qt library, otherwise return false |
| Cis_qt_variant_compatible< bool > | |
| Cis_qt_variant_compatible< double > | |
| Cis_qt_variant_compatible< float > | |
| Cis_qt_variant_compatible< int > | |
| Cis_qt_variant_compatible< long > | |
| Cis_qt_variant_compatible< long double > | |
| Cis_qt_variant_compatible< long long > | |
| Cis_qt_variant_compatible< QBitArray > | |
| Cis_qt_variant_compatible< QBrush > | |
| Cis_qt_variant_compatible< QByteArray > | |
| Cis_qt_variant_compatible< QChar > | |
| Cis_qt_variant_compatible< QColor > | |
| Cis_qt_variant_compatible< QDate > | |
| Cis_qt_variant_compatible< QDateTime > | |
| Cis_qt_variant_compatible< QFont > | |
| Cis_qt_variant_compatible< QHash< QString, QVariant > > | |
| Cis_qt_variant_compatible< QImage > | |
| Cis_qt_variant_compatible< QLatin1String > | |
| Cis_qt_variant_compatible< QLine > | |
| Cis_qt_variant_compatible< QLineF > | |
| Cis_qt_variant_compatible< QList< QVariant > > | |
| Cis_qt_variant_compatible< QLocale > | |
| Cis_qt_variant_compatible< QMap< QString, QVariant > > | |
| Cis_qt_variant_compatible< QPixmap > | |
| Cis_qt_variant_compatible< QPoint > | |
| Cis_qt_variant_compatible< QPointF > | |
| Cis_qt_variant_compatible< QRect > | |
| Cis_qt_variant_compatible< QRectF > | |
| Cis_qt_variant_compatible< QRegion > | |
| Cis_qt_variant_compatible< QSize > | |
| Cis_qt_variant_compatible< QSizeF > | |
| Cis_qt_variant_compatible< QString > | |
| Cis_qt_variant_compatible< QStringList > | |
| Cis_qt_variant_compatible< QTime > | |
| Cis_qt_variant_compatible< QUrl > | |
| Cis_qt_variant_compatible< QVariant > | |
| Cis_qt_variant_compatible< short > | |
| Cis_qt_variant_compatible< unsigned int > | |
| Cis_qt_variant_compatible< unsigned long > | |
| Cis_qt_variant_compatible< unsigned long long > | |
| Cis_qt_variant_compatible< unsigned short > | |
| Cis_qt_vector | Qx::trait::is_qt_vector<T>::value : return true if T is a QVector<> container of Qt library, otherwise return false |
| Cis_qt_vector< const QVector< T > & > | |
| Cis_qt_vector< const QVector< T > > | |
| Cis_qt_vector< QVector< T > & > | |
| Cis_qt_vector< QVector< T > > | |
| Cis_qt_weak_ptr | Qx::trait::is_qt_weak_ptr<T>::value : return true if T is a QWeakPointer<> smart-pointer of Qt library, otherwise return false |
| Cis_qt_weak_ptr< const QWeakPointer< T > & > | |
| Cis_qt_weak_ptr< const QWeakPointer< T > > | |
| Cis_qt_weak_ptr< QWeakPointer< T > & > | |
| Cis_qt_weak_ptr< QWeakPointer< T > > | |
| Cis_qx_collection | Qx::trait::is_qx_collection<T>::value : return true if T is a qx::QxCollection<> container of QxOrm library, otherwise return false |
| Cis_qx_dao_ptr | Qx::trait::is_qx_dao_ptr<T>::value : return true if T is a qx::dao::ptr<> smart-pointer of QxOrm library, otherwise return false |
| Cis_qx_dao_ptr< const qx::dao::ptr< T > & > | |
| Cis_qx_dao_ptr< const qx::dao::ptr< T > > | |
| Cis_qx_dao_ptr< qx::dao::ptr< T > & > | |
| Cis_qx_dao_ptr< qx::dao::ptr< T > > | |
| Cis_qx_pod | Qx::trait::is_qx_pod<T>::value : return true if T is a POD type and not a pointer |
| Cis_qx_registered | Qx::trait::is_qx_registered<T>::value : return true if T is registered into QxOrm context to provide persitence (ORM), serialization and introspection features |
| Cis_smart_ptr | Qx::trait::is_smart_ptr<T>::value : return true if T is a smart-pointer of boost, Qt or QxOrm libraries, otherwise return false |
| Cis_smart_ptr< boost::intrusive_ptr< T > & > | |
| Cis_smart_ptr< boost::intrusive_ptr< T > > | |
| Cis_smart_ptr< boost::scoped_ptr< T > & > | |
| Cis_smart_ptr< boost::scoped_ptr< T > > | |
| Cis_smart_ptr< boost::shared_ptr< T > & > | |
| Cis_smart_ptr< boost::shared_ptr< T > > | |
| Cis_smart_ptr< boost::weak_ptr< T > & > | |
| Cis_smart_ptr< boost::weak_ptr< T > > | |
| Cis_smart_ptr< const boost::intrusive_ptr< T > & > | |
| Cis_smart_ptr< const boost::intrusive_ptr< T > > | |
| Cis_smart_ptr< const boost::scoped_ptr< T > & > | |
| Cis_smart_ptr< const boost::scoped_ptr< T > > | |
| Cis_smart_ptr< const boost::shared_ptr< T > & > | |
| Cis_smart_ptr< const boost::shared_ptr< T > > | |
| Cis_smart_ptr< const boost::weak_ptr< T > & > | |
| Cis_smart_ptr< const boost::weak_ptr< T > > | |
| Cis_smart_ptr< const QScopedPointer< T > & > | |
| Cis_smart_ptr< const QScopedPointer< T > > | |
| Cis_smart_ptr< const QSharedDataPointer< T > & > | |
| Cis_smart_ptr< const QSharedDataPointer< T > > | |
| Cis_smart_ptr< const QSharedPointer< T > & > | |
| Cis_smart_ptr< const QSharedPointer< T > > | |
| Cis_smart_ptr< const QWeakPointer< T > & > | |
| Cis_smart_ptr< const QWeakPointer< T > > | |
| Cis_smart_ptr< const qx::dao::ptr< T > & > | |
| Cis_smart_ptr< const qx::dao::ptr< T > > | |
| Cis_smart_ptr< const std::shared_ptr< T > & > | |
| Cis_smart_ptr< const std::shared_ptr< T > > | |
| Cis_smart_ptr< const std::unique_ptr< T > & > | |
| Cis_smart_ptr< const std::unique_ptr< T > > | |
| Cis_smart_ptr< const std::weak_ptr< T > & > | |
| Cis_smart_ptr< const std::weak_ptr< T > > | |
| Cis_smart_ptr< QScopedPointer< T > & > | |
| Cis_smart_ptr< QScopedPointer< T > > | |
| Cis_smart_ptr< QSharedDataPointer< T > & > | |
| Cis_smart_ptr< QSharedDataPointer< T > > | |
| Cis_smart_ptr< QSharedPointer< T > & > | |
| Cis_smart_ptr< QSharedPointer< T > > | |
| Cis_smart_ptr< QWeakPointer< T > & > | |
| Cis_smart_ptr< QWeakPointer< T > > | |
| Cis_smart_ptr< qx::dao::ptr< T > & > | |
| Cis_smart_ptr< qx::dao::ptr< T > > | |
| Cis_smart_ptr< std::shared_ptr< T > & > | |
| Cis_smart_ptr< std::shared_ptr< T > > | |
| Cis_smart_ptr< std::unique_ptr< T > & > | |
| Cis_smart_ptr< std::unique_ptr< T > > | |
| Cis_smart_ptr< std::weak_ptr< T > & > | |
| Cis_smart_ptr< std::weak_ptr< T > > | |
| Cis_smart_ptr_base_of | Qx::trait::is_smart_ptr_base_of<B, D>::value : return true if B and D are smart-pointers of boost, Qt or QxOrm libraries and if (*B) is a base class of (*D), otherwise return false |
| Cis_smart_ptr_to_pod | Qx::trait::is_smart_ptr_to_pod<T>::value : return true if T is a smart-pointer of boost, Qt or QxOrm libraries and (*T) is a POD type (char, int, long, etc.), otherwise return false |
| Cis_std_list | Qx::trait::is_std_list<T>::value : return true if T is a std::list<> container of stl library, otherwise return false |
| Cis_std_list< const std::list< T > & > | |
| Cis_std_list< const std::list< T > > | |
| Cis_std_list< std::list< T > & > | |
| Cis_std_list< std::list< T > > | |
| Cis_std_map | Qx::trait::is_std_map<T>::value : return true if T is a std::map<> container of stl library, otherwise return false |
| Cis_std_map< const std::map< Key, Value > & > | |
| Cis_std_map< const std::map< Key, Value > > | |
| Cis_std_map< std::map< Key, Value > & > | |
| Cis_std_map< std::map< Key, Value > > | |
| Cis_std_set | Qx::trait::is_std_set<T>::value : return true if T is a std::set<> container of stl library, otherwise return false |
| Cis_std_set< const std::set< T > & > | |
| Cis_std_set< const std::set< T > > | |
| Cis_std_set< std::set< T > & > | |
| Cis_std_set< std::set< T > > | |
| Cis_std_shared_ptr | Qx::trait::is_std_shared_ptr<T>::value : return true if T is a std::shared_ptr<> smart-pointer, otherwise return false |
| Cis_std_shared_ptr< const std::shared_ptr< T > & > | |
| Cis_std_shared_ptr< const std::shared_ptr< T > > | |
| Cis_std_shared_ptr< std::shared_ptr< T > & > | |
| Cis_std_shared_ptr< std::shared_ptr< T > > | |
| Cis_std_unique_ptr | Qx::trait::is_std_unique_ptr<T>::value : return true if T is a std::unique_ptr<> smart-pointer, otherwise return false |
| Cis_std_unique_ptr< const std::unique_ptr< T > & > | |
| Cis_std_unique_ptr< const std::unique_ptr< T > > | |
| Cis_std_unique_ptr< std::unique_ptr< T > & > | |
| Cis_std_unique_ptr< std::unique_ptr< T > > | |
| Cis_std_unordered_map | Qx::trait::is_std_unordered_map<T>::value : return true if T is a std::unordered_map<> or std::unordered_multimap<> container, otherwise return false |
| Cis_std_unordered_map< const std::unordered_map< Key, Value > & > | |
| Cis_std_unordered_map< const std::unordered_map< Key, Value > > | |
| Cis_std_unordered_map< const std::unordered_multimap< Key, Value > & > | |
| Cis_std_unordered_map< const std::unordered_multimap< Key, Value > > | |
| Cis_std_unordered_map< std::unordered_map< Key, Value > & > | |
| Cis_std_unordered_map< std::unordered_map< Key, Value > > | |
| Cis_std_unordered_map< std::unordered_multimap< Key, Value > & > | |
| Cis_std_unordered_map< std::unordered_multimap< Key, Value > > | |
| Cis_std_unordered_set | Qx::trait::is_std_unordered_set<T>::value : return true if T is a std::unordered_set<> or std::unordered_multiset<> container, otherwise return false |
| Cis_std_unordered_set< const std::unordered_multiset< T > & > | |
| Cis_std_unordered_set< const std::unordered_multiset< T > > | |
| Cis_std_unordered_set< const std::unordered_set< T > & > | |
| Cis_std_unordered_set< const std::unordered_set< T > > | |
| Cis_std_unordered_set< std::unordered_multiset< T > & > | |
| Cis_std_unordered_set< std::unordered_multiset< T > > | |
| Cis_std_unordered_set< std::unordered_set< T > & > | |
| Cis_std_unordered_set< std::unordered_set< T > > | |
| Cis_std_vector | Qx::trait::is_std_vector<T>::value : return true if T is a std::vector<> container of stl library, otherwise return false |
| Cis_std_vector< const std::vector< T > & > | |
| Cis_std_vector< const std::vector< T > > | |
| Cis_std_vector< std::vector< T > & > | |
| Cis_std_vector< std::vector< T > > | |
| Cis_std_weak_ptr | Qx::trait::is_std_weak_ptr<T>::value : return true if T is a std::weak_ptr<> smart-pointer, otherwise return false |
| Cis_std_weak_ptr< const std::weak_ptr< T > & > | |
| Cis_std_weak_ptr< const std::weak_ptr< T > > | |
| Cis_std_weak_ptr< std::weak_ptr< T > & > | |
| Cis_std_weak_ptr< std::weak_ptr< T > > | |
| Cno_base_class_defined | |
| Cno_type | |
| ►Cqt_meta_object | Qx::trait::qt_meta_object<T>::get() : if T is based on QObject class, then return QMetaObject instance of Qt introspection engine, else return NULL |
| CqtMetaObject | |
| CqtMetaObject< true, dummy > | |
| Cremove_attr | Qx::trait::remove_attr<T>::type : return a type without pointer, const, reference and/or volatile attributes |
| Cremove_smart_ptr | Qx::trait::remove_smart_ptr<T>::type : return a type without smart-pointer attribute from boost, Qt or QxOrm library |
| Cremove_smart_ptr< boost::intrusive_ptr< T > > | |
| Cremove_smart_ptr< boost::scoped_ptr< T > > | |
| Cremove_smart_ptr< boost::shared_ptr< T > > | |
| Cremove_smart_ptr< QScopedPointer< T > > | |
| Cremove_smart_ptr< QSharedPointer< T > > | |
| Cremove_smart_ptr< qx::dao::ptr< T > > | |
| Cremove_smart_ptr< std::shared_ptr< T > > | |
| Cremove_smart_ptr< std::unique_ptr< T > > | |
| ►Nvalidator | |
| ►Ndetail | |
| CQxValidator_Helper | |
| ►CQxValidator_Helper_Container | |
| CvalidateItem_Helper | |
| CvalidateItem_Helper< const std::pair< U1, U2 >, false > | |
| CvalidateItem_Helper< std::pair< U1, U2 >, false > | |
| CvalidateItem_Helper< U, false > | |
| CQxValidator_Helper_Generic | |
| CQxValidator_Helper_Ptr | |
| ►Cany | |
| Cholder | |
| Cplaceholder | |
| Cany_cast_dynamic | |
| Cany_cast_dynamic< boost::shared_ptr< T > > | |
| Cany_cast_dynamic< QSharedPointer< T > > | |
| Cany_cast_dynamic< qx::dao::ptr< T > > | |
| Cany_cast_dynamic< std::shared_ptr< T > > | |
| Cany_cast_dynamic< T * > | |
| Cbad_any_cast | |
| Cexception | Qx::exception : exception with error code and error description |
| CIxBoostSerializeRegisterHelper | |
| CIxClass | Qx::IxClass : common interface for all classes registered into QxOrm context |
| CIxCollection | Qx::IxCollection : common interface for all QxOrm containers qx::QxCollection<Key, Value> |
| ►CIxDataMember | Qx::IxDataMember : common interface for all class properties registered into QxOrm context |
| CqxCannotAccessDataPointer | |
| CqxCannotAccessDataPointer< QString, dummy > | |
| CqxCannotAccessDataPointer< QVariant, dummy > | |
| CIxDataMemberSqlCallbackParams | Qx::IxDataMemberSqlCallbackParams : list of parameters used by custom callback functions to override SQL queries generated by QxOrm library |
| CIxDataMemberX | Qx::IxDataMemberX : common interface for a list of IxDataMember class properties registered into QxOrm context (for example, list of data member of a class) |
| CIxFactory | Qx::IxFactory : common interface for all classes that can be created dynamically using the class name |
| CIxFunction | Qx::IxFunction : common interface for all functions registered into QxOrm context (used by introspection engine) |
| CIxModel | Qx::IxModel : interface to manage Qt model/view architecture with classes registered into QxOrm context (Qt widgets and/or QML views) |
| CIxPersistable | Qx::IxPersistable : common interface (abstract class) for persistents classes using QX_PERSISTABLE_HPP() and QX_PERSISTABLE_CPP() macros |
| CIxPersistableCollection | Qx::IxPersistableCollection : common interface (abstract class) for collection persistent classes based on qx::IxPersistable and qx::IxCollection |
| CIxRepository | Qx::IxRepository : common interface for all repositories to provide access to database by introspection using QObject class or qx::IxCollection class |
| CIxSingleton | Qx::IxSingleton : common interface for all singleton of QxOrm library |
| CIxSqlQueryBuilder | Qx::IxSqlQueryBuilder : common interface to build SQL queries to communicate with database |
| CIxSqlRelation | Qx::IxSqlRelation : common interface for all relationships defined between 2 classes (or between 2 tables in database) |
| CIxTypeInfo | |
| CIxValidator | Qx::IxValidator : common interface for validator engine |
| CIxValidatorX | Qx::IxValidatorX : common interface for a list of validators |
| CQxArchive_FromByteArray | Qx::QxArchive_FromByteArray : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_FromFile | Qx::QxArchive_FromFile : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_FromFileCompressed | Qx::QxArchive_FromFileCompressed : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_FromString | Qx::QxArchive_FromString : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_ToByteArray | Qx::QxArchive_ToByteArray : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_ToFile | Qx::QxArchive_ToFile : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_ToFileCompressed | Qx::QxArchive_ToFileCompressed : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxArchive_ToString | Qx::QxArchive_ToString : provide some tools to serialize a class registered into QxOrm context into/from binary/text/XML archives (file, string, etc.) |
| CQxBool | Qx_bool : boolean type with code and description message when an error occured |
| CQxBoostInitGuid | |
| ►CQxBoostSerializeHelper | |
| CQxBoostVoidCastRegisterHelper | |
| CQxBoostVoidCastRegisterHelper< true, dummy > | |
| CQxBoostSerializeRegisterHelper | |
| CQxBoostSerializeRegisterHelperX | |
| ►CQxClass | Qx::QxClass<T> : concrete class of type T registered into QxOrm context (this class is a singleton and is thread-safe) |
| CimplementIxPersistable_Helper | |
| CimplementIxPersistable_Helper< QObject, dummy > | |
| CimplementIxPersistable_Helper< qx::trait::no_base_class_defined, dummy > | |
| CinvokeHelper | |
| CinvokeHelper< QObject, qx::trait::no_base_class_defined, dummy > | |
| CinvokeHelper< qx::trait::no_base_class_defined, qx::trait::no_base_class_defined, dummy > | |
| CinvokeHelper< U, qx::trait::no_base_class_defined, dummy > | |
| ►CQxClassName | Qx::QxClassName<T> : class helper to retrieve the class name of type T under const char * format |
| CqxGetClassName | |
| CqxGetClassName< true, dummy > | |
| ►CQxClassX | Qx::QxClassX : list of all classes registered into QxOrm context (this container is a singleton) |
| Cinvoke_default | |
| Cinvoke_ptr | |
| ►CQxCollection | Qx::QxCollection<Key, Value> : QxOrm thread-safe container (keep insertion order + quick access by index + quick access by key) |
| CcompareKeyValue | |
| CcompareKeyValue< true, dummy > | |
| CQxCollectionIterator | Qx::QxCollectionIterator : Java-style iterator to iterate over a qx::QxCollection<Key, Value> container |
| CQxDaoAsync | Qx::QxDaoAsync : helper class to execute SQL queries in another thread (asynchronous way) using qx::IxPersistable interface |
| ►CQxDataMember | Qx::QxDataMember<DataType, Owner> : concrete property of type DataType registered into QxOrm context for the class Owner |
| CqxCompareDataMember | |
| CqxCompareDataMember< true, dummy > | |
| CQxDataMember_PImpl | Qx::QxDataMember_PImpl<DataType, Owner> : concrete property of type DataType registered into QxOrm context for the class Owner (using private implementation idiom) |
| CQxDataMember_PImpl< std::shared_ptr< DataType >, Owner > | |
| CQxDataMember_PImpl< std::unique_ptr< DataType >, Owner > | |
| CQxDataMember_QObject | Qx::QxDataMember_QObject : connect Qt introspection engine (based on QObject class, with QMetaObject type) to QxOrm library introspection engine |
| CQxDataMemberX | Qx::QxDataMemberX<T> : concrete list of properties registered into QxOrm context for the class T |
| CQxDateNeutral | Qx::QxDateNeutral : helper class to store a date value into database under neutral format (YYYYMMDD) => cross database compatibility |
| CQxDateTimeNeutral | Qx::QxDateTimeNeutral : helper class to store a date-time value into database under neutral format (YYYYMMDDHHMMSS) => cross database compatibility |
| ►CQxFactory | Qx::QxFactory<T> : concrete factory class to create object of type T dynamically using the class name |
| CqxCreateInstance | |
| CqxCreateInstance< false, false, false, false, true, dummy > | |
| CqxCreateInstance< false, false, false, true, bIsQObject, dummy > | |
| CqxCreateInstance< false, false, true, false, bIsQObject, dummy > | |
| CqxCreateInstance< false, true, false, false, bIsQObject, dummy > | |
| CqxCreateInstance< true, bIsIxPersistable, bIsIxService, bIsIxParameter, bIsQObject, dummy > | |
| CQxFactoryX | Qx::QxFactoryX : list of all classes registered with QxOrm library factory pattern to create object instance dynamically using the class name |
| ►CQxFunction_0 | Qx::QxFunction_0<Owner, R> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and without parameter |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_0< void, R > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_1 | Qx::QxFunction_1<Owner, R, P1> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 1 parameter P1 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_1< void, R, P1 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_2 | Qx::QxFunction_2<Owner, R, P1, P2> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 2 parameters P1, P2 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_2< void, R, P1, P2 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_3 | Qx::QxFunction_3<Owner, R, P1, P2, P3> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 3 parameters P1, P2, P3 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_3< void, R, P1, P2, P3 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_4 | Qx::QxFunction_4<Owner, R, P1, P2, P3, P4> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 4 parameters P1, P2, P3, P4 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_4< void, R, P1, P2, P3, P4 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_5 | Qx::QxFunction_5<Owner, R, P1, P2, P3, P4, P5> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 5 parameters P1, P2, P3, P4, P5 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_5< void, R, P1, P2, P3, P4, P5 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_6 | Qx::QxFunction_6<Owner, R, P1, P2, P3, P4, P5, P6> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 6 parameters P1, P2, P3, P4, P5, P6 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_6< void, R, P1, P2, P3, P4, P5, P6 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_7 | Qx::QxFunction_7<Owner, R, P1, P2, P3, P4, P5, P6, P7> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 7 parameters P1, P2, P3, P4, P5, P6, P7 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_7< void, R, P1, P2, P3, P4, P5, P6, P7 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_8 | Qx::QxFunction_8<Owner, R, P1, P2, P3, P4, P5, P6, P7, P8> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 8 parameters P1, P2, P3, P4, P5, P6, P7, P8 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_8< void, R, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_9 | Qx::QxFunction_9<Owner, R, P1, P2, P3, P4, P5, P6, P7, P8, P9> : concrete function registered into QxOrm context defined into class Owner, returning an object of type R and with 9 parameters P1, P2, P3, P4, P5, P6, P7, P8, P9 |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| ►CQxFunction_9< void, R, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| CQxInvokerFct | |
| CQxInvokerFct< T, true > | |
| CQxHttpCookie | Qx::QxHttpCookie : HTTP cookie (https://www.qxorm.com/qxorm_en/manual.html#manual_999) |
| CQxHttpRequest | Qx::QxHttpRequest : HTTP request (headers + body) |
| CQxHttpResponse | Qx::QxHttpResponse : HTTP response (headers + body) |
| CQxHttpServer | Qx::QxHttpServer : HTTP server which manages connections in a multi-threaded environment (support SSL/TLS, persistent connection, etc...) : https://www.qxorm.com/qxorm_en/manual.html#manual_96 |
| CQxHttpSession | Qx::QxHttpSession : HTTP session (https://www.qxorm.com/qxorm_en/manual.html#manual_998) |
| CQxHttpSessionManager | Qx::QxHttpSessionManager : HTTP session manager (https://www.qxorm.com/qxorm_en/manual.html#manual_998) |
| CQxHttpTransaction | Qx::QxHttpTransaction : HTTP transaction (contains request from client and reply from server) |
| CQxInvalidValue | Qx::QxInvalidValue : invalid value when a property fails to pass a constraint |
| CQxInvalidValueX | Qx::QxInvalidValueX : list of invalid values |
| CQxModel | Qx::QxModel<T, B> : all classes registered into QxOrm context can be used with Qt model/view architecture (Qt widgets and/or QML views) |
| CQxModelService | Qx::QxModelService<T, S> : provides an easy way to connect your model to the QxService module (all queries are executed over network using client/server communication) |
| CQxPersistableCollection | Qx::QxPersistableCollection<Key, Value, T> : concrete class for collection persistent classes based on qx::IxPersistableCollection and qx::QxCollection<Key, Value> |
| CQxPersistableCollectionHelper | Qx::QxPersistableCollectionHelper<T>::type : return the collection type used by qx::IxPersistable interface, qx::QxPersistableCollection<type_primary_key, std::shared_ptr<my_type>> |
| CQxPersistableList | Qx::QxPersistableList<T> : concrete class for list persistent classes based on qx::IxPersistableCollection (as an array instead of key/value hash-map) |
| CQxPropertyBag | Qx::QxPropertyBag : used by introspection engine (IxClass, IxDataMember, IxFunction, etc.) to add meta-data (property bag) |
| ►CQxRepository | Qx::QxRepository<T> : repository to provide a common interface to communicate with database |
| CqxVerifyPointer | |
| CqxVerifyPointer< true, dummy > | |
| CQxRepositoryX | Qx::QxRepositoryX : list of all repositories registered using qx::register_repository<T> function |
| CQxRestApi | Qx::QxRestApi : provide a REST API to send requests in JSON format from external application, from web-site or from QML view (https://www.qxorm.com/qxorm_en/manual.html#manual_97) |
| CQxSerializeRegistered | |
| CQxSerializeRegistered_Helper | |
| CQxSession | Qx::QxSession : define a session to manage automatically database transactions (using C++ RAII) |
| CQxSimpleCrypt | Simple encryption and decryption of strings and byte arrays |
| CQxSingleton | Qx::QxSingleton<T> : concrete class to define a thread-safe singleton of type T |
| CQxSingletonX | Qx::QxSingletonX : list of all singleton defined by QxOrm library (this container is also a singleton) |
| CQxSoftDelete | Qx::QxSoftDelete : soft delete (or logical delete) behavior to update a row into database (flag it as deleted) instead of delete it from database |
| CQxSqlDatabase | Qx::QxSqlDatabase : define all parameters to connect to database and retrieve a valid connection by thread (this class is a singleton and is thread-safe) |
| ►CQxSqlQuery | Qx::QxSqlQuery : define a user SQL query added to default SQL query builded by QxOrm library, and used by qx::dao::xxx functions to filter elements fetched from database |
| CQxSqlResult | |
| CQxSqlQueryBuilder | Qx::QxSqlQueryBuilder<T> : concrete SQL query builder for class T with a cache mechanism to backup and restore queries already built by the program |
| CQxSqlQueryBuilder_Count | Qx::QxSqlQueryBuilder_Count<T> : concrete SQL query builder for class T to build a COUNT SQL query |
| CQxSqlQueryBuilder_Count_WithRelation | Qx::QxSqlQueryBuilder_Count_WithRelation<T> : concrete SQL query builder for class T to build a COUNT WITH RELATION SQL query |
| CQxSqlQueryBuilder_CreateTable | Qx::QxSqlQueryBuilder_CreateTable<T> : concrete SQL query builder for class T to build a CREATE TABLE SQL query |
| CQxSqlQueryBuilder_DeleteAll | Qx::QxSqlQueryBuilder_DeleteAll<T> : concrete SQL query builder for class T to build a DELETE ALL SQL query |
| CQxSqlQueryBuilder_DeleteById | Qx::QxSqlQueryBuilder_DeleteById<T> : concrete SQL query builder for class T to build a DELETE BY ID SQL query |
| CQxSqlQueryBuilder_Exist | Qx::QxSqlQueryBuilder_Exist<T> : concrete SQL query builder for class T to build an EXIST SQL query |
| CQxSqlQueryBuilder_FetchAll | Qx::QxSqlQueryBuilder_FetchAll<T> : concrete SQL query builder for class T to build a FETCH ALL SQL query |
| CQxSqlQueryBuilder_FetchAll_WithRelation | Qx::QxSqlQueryBuilder_FetchAll_WithRelation<T> : concrete SQL query builder for class T to build a FETCH ALL WITH RELATION SQL query |
| CQxSqlQueryBuilder_FetchById | Qx::QxSqlQueryBuilder_FetchById<T> : concrete SQL query builder for class T to build a FETCH BY ID SQL query |
| CQxSqlQueryBuilder_FetchById_WithRelation | Qx::QxSqlQueryBuilder_FetchById_WithRelation<T> : concrete SQL query builder for class T to build a FETCH BY ID WITH RELATION SQL query |
| CQxSqlQueryBuilder_Insert | Qx::QxSqlQueryBuilder_Insert<T> : concrete SQL query builder for class T to build an INSERT SQL query |
| CQxSqlQueryBuilder_SoftDeleteAll | Qx::QxSqlQueryBuilder_SoftDeleteAll<T> : concrete SQL query builder for class T to build a SOFT DELETE ALL SQL query |
| CQxSqlQueryBuilder_SoftDeleteById | Qx::QxSqlQueryBuilder_SoftDeleteById<T> : concrete SQL query builder for class T to build a SOFT DELETE BY ID SQL query |
| CQxSqlQueryBuilder_Update | Qx::QxSqlQueryBuilder_Update<T> : concrete SQL query builder for class T to build an UPDATE SQL query |
| ►CQxSqlRelation | Qx::QxSqlRelation<DataType, Owner> : base class for all relationships defined between 2 classes (or between 2 tables in database) |
| CcreateItem_Helper | |
| CcreateItem_Helper< true, dummy > | |
| CgetContainer_Helper | |
| CgetContainer_Helper< false, true, dummy > | |
| CgetContainer_Helper< true, false, dummy > | |
| CgetContainer_Helper< true, true, dummy > | |
| CgetData_Helper | |
| CgetData_Helper< false, true, dummy > | |
| CgetData_Helper< true, false, dummy > | |
| CgetData_Helper< true, true, dummy > | |
| CisNullData_Helper | |
| CisNullData_Helper< true, dummy > | |
| CQxSqlRelation_ManyToMany | Qx::QxSqlRelation_ManyToMany<DataType, Owner> : manage a relationship many-to-many defined between 2 classes (or between 2 tables in database) |
| CQxSqlRelation_ManyToOne | Qx::QxSqlRelation_ManyToOne<DataType, Owner> : manage a relationship many-to-one defined between 2 classes (or between 2 tables in database) |
| CQxSqlRelation_OneToMany | Qx::QxSqlRelation_OneToMany<DataType, Owner> : manage a relationship one-to-many defined between 2 classes (or between 2 tables in database) |
| CQxSqlRelation_OneToOne | Qx::QxSqlRelation_OneToOne<DataType, Owner> : manage a relationship one-to-one defined between 2 classes (or between 2 tables in database) |
| CQxSqlRelationLinked | Qx::QxSqlRelationLinked : hierarchy of relationships to build SQL query |
| CQxSqlRelationParams | Qx::QxSqlRelationParams : define list of parameters to transfer to relationships to manage SQL queries builded by QxOrm library |
| CQxTimeNeutral | Qx::QxTimeNeutral : helper class to store a time value into database under neutral format (HHMMSS) => cross database compatibility |
| CQxValidator | Qx::QxValidator<Owner> : concrete class for a custom validator |
| CQxValidator_Recursive | Qx::QxValidator_Recursive<DataType, Owner> : concrete class for a recursive validator |
| CQxValidator_WithDataType | Qx::QxValidator_WithDataType<DataType, Owner> : concrete class for a custom validator with data type |
| CQxValidatorX | Qx::QxValidatorX<T> : concrete class for a list of validators associated to a type registered into QxOrm context |
| CQxXml | |
| CQxXmlReader | |
| CQxXmlWriter | |
| Cvalidator_error | Qx::validator_error : define a validator error exception (for example, inserting or updating an element into database) and retrieve list of invalid values |