Home · All Classes · All Namespaces · Modules · Functions · Files

cli-dbus.h

/*
 * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
 *
 * This file can be distributed under the same terms as the specification from
 * which it was generated.
 */

#ifndef IN_TELEPATHY_QT4_HEADER
#error IN_TELEPATHY_QT4_HEADER
#endif

#include <TelepathyQt4/Types>

#include <QtGlobal>

#include <QString>
#include <QObject>
#include <QVariant>

#include <QDBusPendingReply>

#include <TelepathyQt4/AbstractInterface>
#include <TelepathyQt4/DBusProxy>
#include <TelepathyQt4/Global>

// basically the same as GLib's G_GNUC_DEPRECATED
#ifndef TELEPATHY_GNUC_DEPRECATED
#   if defined(Q_CC_GNUC) && __GNUC__ >= 4
#       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
#   else
#       define TELEPATHY_GNUC_DEPRECATED
#   endif
#endif
namespace Tp
{
namespace Client
{
namespace DBus
{

class TELEPATHY_QT4_EXPORT DBusDaemonInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.DBus";
    }

    DBusDaemonInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    DBusDaemonInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    DBusDaemonInterface(Tp::DBusProxy *proxy);

    explicit DBusDaemonInterface(const Tp::AbstractInterface& mainInterface);

    DBusDaemonInterface(const Tp::AbstractInterface& mainInterface, QObject* parent);

public Q_SLOTS:
    inline QDBusPendingReply<QString> Hello()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("Hello"));
    }

    inline QDBusPendingReply<uint> RequestName(const QString& name, uint flags)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(flags);
        return asyncCallWithArgumentList(QLatin1String("RequestName"), argumentList);
    }

    inline QDBusPendingReply<uint> ReleaseName(const QString& name)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(name);
        return asyncCallWithArgumentList(QLatin1String("ReleaseName"), argumentList);
    }

    inline QDBusPendingReply<uint> StartServiceByName(const QString& service, uint flags)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(service) << QVariant::fromValue(flags);
        return asyncCallWithArgumentList(QLatin1String("StartServiceByName"), argumentList);
    }

    inline QDBusPendingReply<bool> NameHasOwner(const QString& nameToCheck)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<bool>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(nameToCheck);
        return asyncCallWithArgumentList(QLatin1String("NameHasOwner"), argumentList);
    }

    inline QDBusPendingReply<QStringList> ListNames()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("ListNames"));
    }

    inline QDBusPendingReply<QStringList> ListActivatableNames()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("ListActivatableNames"));
    }

    inline QDBusPendingReply<> AddMatch(const QString& rule)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(rule);
        return asyncCallWithArgumentList(QLatin1String("AddMatch"), argumentList);
    }

    inline QDBusPendingReply<> RemoveMatch(const QString& rule)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(rule);
        return asyncCallWithArgumentList(QLatin1String("RemoveMatch"), argumentList);
    }

    inline QDBusPendingReply<QString> GetNameOwner(const QString& name)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(name);
        return asyncCallWithArgumentList(QLatin1String("GetNameOwner"), argumentList);
    }

    inline QDBusPendingReply<QStringList> ListQueuedOwners(const QString& name)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(name);
        return asyncCallWithArgumentList(QLatin1String("ListQueuedOwners"), argumentList);
    }

    inline QDBusPendingReply<uint> GetConnectionUnixUser(const QString& connectionName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(connectionName);
        return asyncCallWithArgumentList(QLatin1String("GetConnectionUnixUser"), argumentList);
    }

    inline QDBusPendingReply<uint> GetConnectionUnixProcessID(const QString& connectionName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(connectionName);
        return asyncCallWithArgumentList(QLatin1String("GetConnectionUnixProcessID"), argumentList);
    }

    inline QDBusPendingReply<QByteArray> GetConnectionSELinuxSecurityContext(const QString& connectionName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QByteArray>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(connectionName);
        return asyncCallWithArgumentList(QLatin1String("GetConnectionSELinuxSecurityContext"), argumentList);
    }

    inline QDBusPendingReply<> ReloadConfig()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("ReloadConfig"));
    }

    inline QDBusPendingReply<QString> GetId()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("GetId"));
    }

Q_SIGNALS:
    void NameOwnerChanged(const QString& name, const QString& oldOwner, const QString& newOwner);

    void NameLost(const QString& name);

    void NameAcquired(const QString& name);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT IntrospectableInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.DBus.Introspectable";
    }

    IntrospectableInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    IntrospectableInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    IntrospectableInterface(Tp::DBusProxy *proxy);

    explicit IntrospectableInterface(const Tp::AbstractInterface& mainInterface);

    IntrospectableInterface(const Tp::AbstractInterface& mainInterface, QObject* parent);

public Q_SLOTS:
    inline QDBusPendingReply<QString> Introspect()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("Introspect"));
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT PeerInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.DBus.Peer";
    }

    PeerInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    PeerInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    PeerInterface(Tp::DBusProxy *proxy);

    explicit PeerInterface(const Tp::AbstractInterface& mainInterface);

    PeerInterface(const Tp::AbstractInterface& mainInterface, QObject* parent);

public Q_SLOTS:
    inline QDBusPendingReply<> Ping()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("Ping"));
    }

    inline QDBusPendingReply<QString> GetMachineId()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        return asyncCall(QLatin1String("GetMachineId"));
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT PropertiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.DBus.Properties";
    }

    PropertiesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    PropertiesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    PropertiesInterface(Tp::DBusProxy *proxy);

    explicit PropertiesInterface(const Tp::AbstractInterface& mainInterface);

    PropertiesInterface(const Tp::AbstractInterface& mainInterface, QObject* parent);

public Q_SLOTS:
    inline QDBusPendingReply<QDBusVariant> Get(const QString& interfaceName, const QString& propertyName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(interfaceName) << QVariant::fromValue(propertyName);
        return asyncCallWithArgumentList(QLatin1String("Get"), argumentList);
    }

    inline QDBusPendingReply<> Set(const QString& interfaceName, const QString& propertyName, const QDBusVariant& value)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(interfaceName) << QVariant::fromValue(propertyName) << QVariant::fromValue(value);
        return asyncCallWithArgumentList(QLatin1String("Set"), argumentList);
    }

    inline QDBusPendingReply<QVariantMap> GetAll(const QString& interfaceName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(interfaceName);
        return asyncCallWithArgumentList(QLatin1String("GetAll"), argumentList);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
}