--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailservices/nmutilities/tsrc/unittests/unittest_nmcontacthistorymodel_p/qtcontacts.h Wed Sep 15 12:09:55 2010 +0300
@@ -0,0 +1,784 @@
+#ifndef QTCONTACTS_H
+#define QTCONTACTS_H
+
+#include <QSharedPointer>
+#include <QVariant>
+
+extern bool setDetailDefinitionNameCalled;
+extern bool setMatchFlagsCalled;
+extern bool setValueCalled;
+extern bool ContactIdsCalled;
+extern bool returnZeroEmails;
+
+typedef quint32 QContactLocalId;
+/*
+class UnitTestReporter
+{
+public:
+ inline static void resetFlags()
+ {
+ //mFlagA = false;
+ UnitTestReporter::mFlagB = false;
+ //mFlagC = false;
+ UnitTestReporter::mFlagD = false;
+ //mVariant1.clear();
+ //mVariant2.clear();
+ }
+
+ inline static void setFlagA()
+ {
+ mFlagA = true;
+ }
+ inline static void setFlagB()
+ {
+ mFlagB = true;
+ }
+
+ inline static void setFlagC()
+ {
+ mFlagC = true;
+ }
+
+ inline static void setFlagD()
+ {
+ mFlagD = true;
+ }
+
+ inline static void setVariant1(QVariant &variant)
+ {
+ mVariant1 = variant;
+ }
+
+ inline static void setVariant2(QVariant &variant)
+ {
+ mVariant2 = variant;
+ }
+
+ static bool mFlagA;
+ static bool mFlagB;
+ static bool mFlagC;
+ static bool mFlagD;
+ static QVariant mVariant1;
+ static QVariant mVariant2;
+};
+*/
+
+template <int N> struct QLatin1Constant
+{
+ char chars[N];
+
+ bool operator ==(const QLatin1Constant& other) const {return (chars == other.chars) || (qstrcmp(chars, other.chars) == 0);}
+ bool operator !=(const QLatin1Constant& other) const {return !operator==(other);}
+
+ inline const char * latin1() const {return chars;}
+
+ operator QLatin1String() const {return QLatin1String(chars);}
+ operator QString() const {return QString::fromLatin1(chars, N-1);}
+ operator QVariant() const {return QVariant(operator QString());}
+};
+
+#define QTM_USE_NAMESPACE
+#endif
+
+// Stub for ContactManager
+#ifndef QCONTACTMANAGER_H
+#define QCONTACTMANAGER_H
+
+#include <QObject>
+#include <QMap>
+#include <QString>
+#include <QStringList>
+#include <QList>
+#include <QDateTime>
+#include <QGlobal.h>
+
+class QContactSortOrder
+{
+public:
+ inline QContactSortOrder()
+ {
+ }
+
+ inline ~QContactSortOrder()
+ {
+ }
+
+ inline QContactSortOrder(const QContactSortOrder& other)
+ {
+ Q_UNUSED(other);
+ }
+
+ inline QContactSortOrder& operator=(const QContactSortOrder& other)
+ {
+ Q_UNUSED(other);
+ return (const_cast<QContactSortOrder &>(other));
+ }
+
+ enum BlankPolicy {
+ BlanksFirst,
+ BlanksLast,
+ };
+
+ /* Mutators */
+// void setDetailDefinitionName(const QString& definitionName, const QString& fieldName);
+// void setBlankPolicy(BlankPolicy blankPolicy);
+// void setDirection(Qt::SortOrder direction);
+// void setCaseSensitivity(Qt::CaseSensitivity sensitivity);
+
+ /* Accessors */
+// QString detailDefinitionName() const;
+// QString detailFieldName() const;
+// BlankPolicy blankPolicy() const;
+// Qt::SortOrder direction() const;
+// Qt::CaseSensitivity caseSensitivity() const;
+
+// bool isValid() const;
+
+ inline bool operator==(const QContactSortOrder& other) const
+ {
+ Q_UNUSED(other);
+ return true;
+ }
+
+ inline bool operator!=(const QContactSortOrder& other) const {Q_UNUSED(other); return !operator==(other);}
+};
+
+#define Q_DECLARE_LATIN1_CONSTANT(varname, str) static const QLatin1Constant<sizeof(str)> varname
+#define Q_DEFINE_LATIN1_CONSTANT(varname, str) const QLatin1Constant<sizeof(str)> varname = {str}
+
+#define Q_DECLARE_CUSTOM_CONTACT_DETAIL(className, definitionNameString) \
+ className() : QContactDetail(DefinitionName.latin1()) {} \
+ className(const QContactDetail& field) : QContactDetail(field, DefinitionName.latin1()) {} \
+ className& operator=(const QContactDetail& other) {assign(other, DefinitionName.latin1()); return *this;} \
+ \
+ Q_DECLARE_LATIN1_CONSTANT(DefinitionName, definitionNameString);
+
+class QContactDetail
+{
+public:
+
+ inline QContactDetail()
+ {
+ }
+
+ inline explicit QContactDetail(const char* definitionName)
+ {
+ Q_UNUSED(definitionName);
+ }
+
+ inline explicit QContactDetail(const QString& definitionName)
+ {
+ Q_UNUSED(definitionName);
+ }
+
+ inline ~QContactDetail()
+ {
+ }
+
+ inline QContactDetail(const QContactDetail& other)
+ {
+ Q_UNUSED(other);
+ }
+
+ inline QContactDetail& operator=(const QContactDetail& other)
+ {
+ Q_UNUSED(other);
+ return (const_cast<QContactDetail &>(other));
+ }
+
+ enum AccessConstraint {
+ NoConstraint = 0,
+ ReadOnly = 0x01,
+ Irremovable = 0x02
+ };
+
+ Q_DECLARE_FLAGS(AccessConstraints, AccessConstraint)
+
+ inline AccessConstraints accessConstraints() const
+ {
+ return AccessConstraints();
+ }
+
+ // Predefined attribute names and values
+#ifdef Q_QDOC
+ static const QLatin1Constant FieldContext;
+ static const QLatin1Constant ContextHome;
+ static const QLatin1Constant ContextWork;
+ static const QLatin1Constant ContextOther;
+ static const QLatin1Constant FieldDetailUri;
+ static const QLatin1Constant FieldLinkedDetailUris;
+#else
+ Q_DECLARE_LATIN1_CONSTANT(FieldContext, "Context");
+ Q_DECLARE_LATIN1_CONSTANT(ContextHome, "Home");
+ Q_DECLARE_LATIN1_CONSTANT(ContextWork, "Work");
+ Q_DECLARE_LATIN1_CONSTANT(ContextOther, "Other");
+ Q_DECLARE_LATIN1_CONSTANT(FieldDetailUri, "DetailUri");
+ Q_DECLARE_LATIN1_CONSTANT(FieldLinkedDetailUris, "LinkedDetailUris");
+#endif
+
+ bool operator==(const QContactDetail& other) const;
+ bool operator!=(const QContactDetail& other) const {return !(other == *this);}
+
+ inline QString definitionName() const
+ {
+ return QString();
+ }
+
+ inline bool isEmpty() const
+ {
+ return false;
+ }
+
+ int key() const;
+ void resetKey();
+
+ inline QString value(const QString& key) const
+ {
+ Q_UNUSED(key);
+ return QString();
+ }
+
+ inline bool setValue(const QString& key, const QVariant& value)
+ {
+ Q_UNUSED(key);
+ Q_UNUSED(value);
+ return true;
+ }
+
+ bool removeValue(const QString& key);
+ bool hasValue(const QString& key) const;
+
+ QVariantMap variantValues() const;
+ QVariant variantValue(const QString& key) const;
+ template <typename T> T value(const QString& key) const
+ {
+ return variantValue(key).value<T>();
+ }
+
+ /* These are probably internal */
+ inline QString value(const char* key) const
+ {
+ return key;
+ }
+
+ inline bool setValue(const char* key, const QVariant& value)
+ {
+ Q_UNUSED(key);
+ Q_UNUSED(value);
+ return true;
+ }
+
+ inline bool removeValue(const char* key)
+ {
+ Q_UNUSED(key);
+ return true;
+ }
+
+ inline bool hasValue(const char* key) const
+ {
+ Q_UNUSED(key);
+ return true;
+ }
+
+ QVariant variantValue(const char *key) const;
+
+ template<typename T> T value(const char *key) const
+ {
+ return variantValue(key).value<T>();
+ }
+
+#ifdef Q_QDOC
+ QString value(const QLatin1Constant& key) const;
+ bool setValue(const QLatin1Constant& key, const QVariant& value);
+ bool removeValue(const QLatin1Constant& key);
+ bool hasValue(const QLatin1Constant& key) const;
+ QVariant variantValue(const QLatin1Constant& key) const;
+ T value(const QLatin1Constant& key) const;
+#else
+
+ template<int N> QString value(const QLatin1Constant<N>& key) const
+ {
+ return value(key.latin1());
+ }
+ template<int N> bool setValue(const QLatin1Constant<N>& key, const QVariant& value)
+ {
+ return setValue(key.latin1(), value);
+ }
+ template<int N> bool removeValue(const QLatin1Constant<N>& key)
+ {
+ return removeValue(key.latin1());
+ }
+ template<int N> bool hasValue(const QLatin1Constant<N>& key) const
+ {
+ return hasValue(key.latin1());
+ }
+ template<int N> QVariant variantValue(const QLatin1Constant<N>& key) const
+ {
+ return variantValue(key.latin1());
+ }
+ template<typename T, int N> T value(const QLatin1Constant<N>& key) const
+ {
+ return value<T>(key.latin1());
+ }
+#endif
+
+ inline void setContexts(const QStringList& contexts)
+ {
+ setValue(FieldContext, contexts);
+ }
+
+ inline void setContexts(const QString& context)
+ {
+ setValue(FieldContext, QStringList(context));
+ }
+
+ inline QStringList contexts() const
+ {
+ return value<QStringList>(FieldContext);
+ }
+
+ inline void setDetailUri(const QString& detailUri)
+ {
+ setValue(FieldDetailUri, detailUri);
+ }
+
+ inline QString detailUri() const
+ {
+ return value(FieldDetailUri);
+ }
+
+ inline void setLinkedDetailUris(const QStringList& linkedDetailUris)
+ {
+ setValue(FieldLinkedDetailUris, linkedDetailUris);
+ }
+
+ inline void setLinkedDetailUris(const QString& linkedDetailUri)
+ {
+ setValue(FieldLinkedDetailUris, QStringList(linkedDetailUri));
+ }
+
+ inline QStringList linkedDetailUris() const
+ {
+ return value<QStringList>(FieldLinkedDetailUris);
+ }
+
+// Protected..
+
+ inline QContactDetail(const QContactDetail &other, const QString& expectedDefinitionId)
+ {
+ Q_UNUSED(other);
+ Q_UNUSED(expectedDefinitionId);
+ }
+
+ inline QContactDetail& assign(const QContactDetail &other, const QString& expectedDefinitionId)
+ {
+ Q_UNUSED(other);
+ Q_UNUSED(expectedDefinitionId);
+ return (const_cast<QContactDetail &>(other));
+ }
+
+ inline QContactDetail(const QContactDetail &other, const char* expectedDefinitionId)
+ {
+ Q_UNUSED(other);
+ Q_UNUSED(expectedDefinitionId);
+ }
+
+ inline QContactDetail& assign(const QContactDetail &other, const char* expectedDefinitionId)
+ {
+ Q_UNUSED(other);
+ Q_UNUSED(expectedDefinitionId);
+ return (const_cast<QContactDetail &>(other));
+ }
+};
+
+// Stub for QContactFilter
+class QContactFilter
+{
+public:
+ inline QContactFilter()
+ {
+ }
+
+ inline ~QContactFilter()
+ {
+ }
+
+ inline QContactFilter(const QContactFilter& other)
+ {
+ Q_UNUSED(other);
+ }
+
+ inline QContactFilter& operator=(const QContactFilter& other)
+ {
+ Q_UNUSED(other);
+ return (const_cast<QContactFilter &>(other));
+ }
+
+ enum FilterType {
+ InvalidFilter,
+ ContactDetailFilter,
+ ContactDetailRangeFilter,
+ ChangeLogFilter,
+ ActionFilter,
+ RelationshipFilter,
+ IntersectionFilter,
+ UnionFilter,
+ LocalIdFilter,
+ DefaultFilter
+ };
+
+ inline FilterType type() const
+ {
+ return FilterType();
+ }
+
+ // Qt::MatchFlags don't quite match here
+ enum MatchFlag {
+ MatchExactly = Qt::MatchExactly, // 0
+ MatchContains = Qt::MatchContains, // 1
+ MatchStartsWith = Qt::MatchStartsWith, // 2
+ MatchEndsWith = Qt::MatchEndsWith, // 3
+ MatchFixedString = Qt::MatchFixedString, // 8
+ MatchCaseSensitive = Qt::MatchCaseSensitive, // 16
+ MatchPhoneNumber = 1024,
+ MatchKeypadCollation = 2048
+ };
+ Q_DECLARE_FLAGS(MatchFlags, MatchFlag)
+};
+
+class QContactEmailAddress : public QContactDetail
+{
+public:
+
+#ifdef Q_QDOC
+ static const QLatin1Constant DefinitionName;
+ static const QLatin1Constant FieldEmailAddress;
+#else
+ Q_DECLARE_CUSTOM_CONTACT_DETAIL(QContactEmailAddress, "EmailAddress")
+ Q_DECLARE_LATIN1_CONSTANT(FieldEmailAddress, "EmailAddress");
+#endif
+
+ void setEmailAddress(const QString& emailAddress) {Q_UNUSED(emailAddress);}
+ QString emailAddress() const {return value(FieldEmailAddress);}
+
+ static QContactFilter match(const QString& emailAddress)
+ {
+ Q_UNUSED(emailAddress);
+ return QContactFilter();
+ }
+};
+
+class QContactName : public QContactDetail
+{
+public:
+
+#ifdef Q_QDOC
+ //static const QLatin1Constant DefinitionName;
+ static const QLatin1Constant FieldPrefix;
+ static const QLatin1Constant FieldFirstName;
+ static const QLatin1Constant FieldMiddleName;
+ static const QLatin1Constant FieldLastName;
+ static const QLatin1Constant FieldSuffix;
+ static const QLatin1Constant FieldCustomLabel;
+#else
+ Q_DECLARE_CUSTOM_CONTACT_DETAIL(QContactName, "Name")
+ Q_DECLARE_LATIN1_CONSTANT(FieldPrefix, "Prefix");
+ Q_DECLARE_LATIN1_CONSTANT(FieldFirstName, "FirstName");
+ Q_DECLARE_LATIN1_CONSTANT(FieldMiddleName, "MiddleName");
+ Q_DECLARE_LATIN1_CONSTANT(FieldLastName, "LastName");
+ Q_DECLARE_LATIN1_CONSTANT(FieldSuffix, "Suffix");
+ Q_DECLARE_LATIN1_CONSTANT(FieldCustomLabel, "CustomLabel");
+#endif
+ //static const QString DefinitionName;
+
+ QString prefix() const {return value(FieldPrefix);}
+ QString firstName() const {return value(FieldFirstName);}
+ QString middleName() const {return value(FieldMiddleName);}
+ QString lastName() const {return value(FieldLastName);}
+ QString suffix() const {return value(FieldSuffix);}
+ QString customLabel() const{return value(FieldCustomLabel);}
+
+ void setPrefix(const QString& prefix) {setValue(FieldPrefix, prefix);}
+ void setFirstName(const QString& firstName) {setValue(FieldFirstName, firstName);}
+ void setMiddleName(const QString& middleName) {setValue(FieldMiddleName, middleName);}
+ void setLastName(const QString& lastName) {setValue(FieldLastName, lastName);}
+ void setSuffix(const QString& suffix) {setValue(FieldSuffix, suffix);}
+ void setCustomLabel(const QString& customLabel) {setValue(FieldCustomLabel, customLabel);}
+
+ // Convenience filter
+ static QContactFilter match(const QString& name);
+ static QContactFilter match(const QString& firstName, const QString& lastName);
+};
+
+// Stub for QContactDetailFilter
+class QContactDetailFilter : public QContactFilter
+{
+public:
+ inline QContactDetailFilter()
+ {
+ }
+
+ inline QContactDetailFilter(const QContactFilter& other)
+ {
+ Q_UNUSED(other);
+ }
+
+ inline void setDetailDefinitionName(const QString& definition, const QString& fieldName = QString())
+ {
+ Q_UNUSED(definition);
+ Q_UNUSED(fieldName);
+ setDetailDefinitionNameCalled = true;
+ }
+
+ inline void setMatchFlags(QContactFilter::MatchFlags flags)
+ {
+ Q_UNUSED(flags);
+ setMatchFlagsCalled = true;
+ }
+
+ inline void setValue(const QVariant& value)
+ {
+ Q_UNUSED(value);
+ setValueCalled = true;
+ }
+};
+
+// Stub for QContactFetchHint
+class QContactFetchHint {
+public:
+
+ inline QContactFetchHint()
+ {
+ }
+
+ inline QContactFetchHint(const QContactFetchHint& other)
+ {
+ Q_UNUSED(other);
+ }
+
+ inline ~QContactFetchHint()
+ {
+ }
+
+};
+
+class QContact
+{
+public:
+ inline QContact()
+ {
+ }
+
+ inline ~QContact()
+ {
+ }
+
+ QContact(const QContact& other);
+ QContact& operator=(const QContact& other);
+
+ bool operator==(const QContact &other) const;
+ bool operator!=(const QContact &other) const {return !(other == *this);}
+
+ /* Access details of particular type or which support a particular action */
+ QContactDetail detail(const QString& definitionId) const;
+ QList<QContactDetail> details(const QString& definitionId = QString()) const;
+
+ QList<QContactDetail> details(const QString& definitionName, const QString& fieldName, const QString& value) const;
+
+ inline QContactDetail detail(const char* definitionId) const
+ {
+ Q_UNUSED(definitionId);
+ QContactDetail detail;
+
+ detail.setValue(definitionId, definitionId);
+
+ return detail;
+ }
+
+ inline QList<QContactDetail> details(const char* definitionId) const
+ {
+ QList<QContactDetail> tmpList;
+ QContactDetail detail;
+
+ if(!returnZeroEmails)
+ {
+ detail.setValue(definitionId, definitionId);
+ tmpList.append(detail);
+ }
+
+ return tmpList;
+ }
+
+ QList<QContactDetail> details(const char* definitionId, const char* fieldName, const QString& value) const;
+
+ /* Templated retrieval for definition names */
+#ifdef Q_QDOC
+ QContactDetail detail(const QLatin1Constant& definitionName) const;
+ QList<QContactDetail> details(const QLatin1Constant& definitionName) const;
+ QList<QContactDetail> details(const QLatin1Constant& definitionName, const QLatin1Constant& fieldName, const QString& value);
+#else
+ template <int N> QContactDetail detail(const QLatin1Constant<N>& definitionName) const
+ {
+ return detail(definitionName.latin1());
+ }
+ template <int N> QList<QContactDetail> details(const QLatin1Constant<N>& definitionName) const
+ {
+ return details(definitionName.latin1());
+ }
+ template <int N, int M> QList<QContactDetail> details(const QLatin1Constant<N>& definitionName, const QLatin1Constant<M>& fieldName, const QString& value)
+ {
+ return details(definitionName.latin1(), fieldName.latin1(), value);
+ }
+#endif
+
+ /* Templated (type-specific) detail retrieval */
+ template<typename T> QList<T> details() const
+ {
+ QList<QContactDetail> props = details(T::DefinitionName.latin1());
+ QList<T> ret;
+ foreach(QContactDetail prop, props)
+ ret.append(T(prop));
+ return ret;
+ }
+
+ /* Templated (type-specific) detail retrieval base on given detail field name and field value */
+ template<typename T> QList<T> details(const QString& fieldName, const QString& value) const
+ {
+ QList<QContactDetail> props = details(T::DefinitionName, fieldName, value);
+ QList<T> ret;
+ foreach(QContactDetail prop, props)
+ ret.append(T(prop));
+ return ret;
+ }
+
+ template<typename T> QList<T> details(const char* fieldName, const QString& value) const
+ {
+ QList<QContactDetail> props = details(T::DefinitionName.latin1(), fieldName, value);
+ QList<T> ret;
+ foreach(QContactDetail prop, props)
+ ret.append(T(prop));
+ return ret;
+ }
+
+ template<typename T> T detail() const
+ {
+ return T(detail(T::DefinitionName.latin1()));
+ }
+
+};
+
+// Stub for QContactManager
+//class QContactManager : public QObject
+class QContactManager
+{
+// Q_OBJECT
+
+public:
+
+#if Q_QDOC // qdoc's parser fails to recognise the default map argument
+
+ inline explicit QContactManager(const QString& managerName = QString(), const QMap<QString, QString>& parameters = 0, QObject* parent = 0)
+ {
+ Q_UNUSED(managerName);
+ Q_UNUSED(parameters;
+ Q_UNUSED(parent);
+ }
+
+ inline QContactManager(const QString& managerName, int implementationVersion, const QMap<QString, QString>& parameters = 0, QObject* parent = 0)
+ {
+ Q_UNUSED(managerName);
+ Q_UNUSED(implementationVersion);
+ Q_UNUSED(parameters);
+ Q_UNUSED(parent);
+ }
+
+#else
+
+ inline explicit QContactManager(const QString& managerName = QString(), const QMap<QString, QString>& parameters = (QMap<QString, QString>()), QObject* parent = 0)
+ {
+ Q_UNUSED(managerName);
+ Q_UNUSED(parameters);
+ Q_UNUSED(parent);
+ }
+
+ inline QContactManager(const QString& managerName, int implementationVersion, const QMap<QString, QString>& parameters = (QMap<QString, QString>()), QObject* parent = 0)
+ {
+ Q_UNUSED(managerName);
+ Q_UNUSED(implementationVersion);
+ Q_UNUSED(parameters);
+ Q_UNUSED(parent);
+ }
+
+#endif
+// explicit QContactManager(QObject* parent);
+
+// static QContactManager* fromUri(const QString& uri, QObject* parent = 0);
+ inline ~QContactManager()
+ {
+
+ }
+
+ /* Contacts - Accessors and Mutators */
+// QList<QContactLocalId> contactIds(const QList<QContactSortOrder>& sortOrders = QList<QContactSortOrder>()) const;
+
+ // QContactLocalId - Check
+ // QContactFilter - Check
+ // QContactSortOrder - Check
+ // QContactFetchHint - Check
+
+
+ inline QList<QContactLocalId> contactIds(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders = QList<QContactSortOrder>()) const
+ {
+ Q_UNUSED(filter);
+ Q_UNUSED(sortOrders);
+
+ QList<QContactLocalId> list;
+ list.append(12);
+ list.append(24);
+ list.append(48);
+
+ ContactIdsCalled = true;
+
+ return list;
+ }
+
+// QList<QContact> contacts(const QList<QContactSortOrder>& sortOrders = QList<QContactSortOrder>(), const QContactFetchHint& fetchHint = QContactFetchHint()) const;
+// QList<QContact> contacts(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders = QList<QContactSortOrder>(), const QContactFetchHint& fetchHint = QContactFetchHint()) const;
+ inline QContact contact(const QContactLocalId& contactId, const QContactFetchHint& fetchHint = QContactFetchHint()) const // retrieve a contact
+ {
+ Q_UNUSED(fetchHint);
+
+ QContact cnt;
+
+ int keu = contactId;
+
+ switch (keu)
+ {
+ case 12:
+
+ break;
+
+ case 24:
+
+ break;
+
+ case 48:
+
+ break;
+
+ default:
+ break;
+ }
+
+
+
+ return cnt;
+ }
+
+
+
+};
+
+//QTM_END_NAMESPACE
+
+#endif