optional-interface-factory.h

#ifndef _TelepathyQt4_optional_interface_factory_h_HEADER_GUARD_
#define _TelepathyQt4_optional_interface_factory_h_HEADER_GUARD_

#ifndef IN_TELEPATHY_QT4_HEADER
#error IN_TELEPATHY_QT4_HEADER
#endif

#include <TelepathyQt4/Global>

#include <QObject>
#include <QStringList>
#include <QtGlobal>

namespace Tp
{

class AbstractInterface;

#ifndef DOXYGEN_SHOULD_SKIP_THIS

class TELEPATHY_QT4_EXPORT OptionalInterfaceCache
{
    Q_DISABLE_COPY(OptionalInterfaceCache)

public:
    explicit OptionalInterfaceCache(QObject *proxy);

    ~OptionalInterfaceCache();

protected:
    AbstractInterface *getCached(const QString &name) const;
    void cache(AbstractInterface *interface) const;
    QObject *proxy() const;

private:
    struct Private;
    friend struct Private;
    Private *mPriv;
};

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

template <typename DBusProxySubclass> class OptionalInterfaceFactory
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    : private OptionalInterfaceCache
#endif
{
    Q_DISABLE_COPY(OptionalInterfaceFactory)

public:
    enum InterfaceSupportedChecking
    {
        CheckInterfaceSupported,
        BypassInterfaceCheck
    };

    inline OptionalInterfaceFactory(DBusProxySubclass *this_)
        : OptionalInterfaceCache(this_)
    {
    }

    inline ~OptionalInterfaceFactory()
    {
    }

    inline QStringList interfaces() const { return mInterfaces; }

    inline bool hasInterface(const QString &name) const
    {
        return mInterfaces.contains(name);
    }

    template <class Interface>
    inline Interface *optionalInterface(
            InterfaceSupportedChecking check = CheckInterfaceSupported) const
    {
        // Check for the remote object supporting the interface
        QString name(QLatin1String(Interface::staticInterfaceName()));
        if (check == CheckInterfaceSupported && !mInterfaces.contains(name)) {
            return 0;
        }

        // If present or forced, delegate to OptionalInterfaceFactory
        return interface<Interface>();
    }

    template <typename Interface>
    inline Interface *interface() const
    {
        AbstractInterface* interfaceMustBeASubclassOfAbstractInterface = static_cast<Interface *>(NULL);
        Q_UNUSED(interfaceMustBeASubclassOfAbstractInterface);

        // If there is a interface cached already, return it
        QString name(QLatin1String(Interface::staticInterfaceName()));
        AbstractInterface *cached = getCached(name);
        if (cached)
            return static_cast<Interface *>(cached);

        // Otherwise, cache and return a newly constructed proxy
        Interface *interface = new Interface(
                static_cast<DBusProxySubclass *>(proxy()));
        cache(interface);
        return interface;
    }

protected:
    inline void setInterfaces(const QStringList &interfaces)
    {
        mInterfaces = interfaces;
    }

private:
    QStringList mInterfaces;
};

} // Tp

#endif