#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);