---

registry.h

/*
 *  Interface to register SLP services
 *  Copyright (C) 2002-2003 Tim Jansen <tim@tjansen.de>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *  Boston, MA 02111-1307, USA.
 */

#ifndef KDE_SLP_REGISTRY_H
#define KDE_SLP_REGISTRY_H

#include <kde/slp/service.h>
#include <kde/slp/filters.h>
#include <kde/util/smartptr.h>
#include <qstringlist.h>
#include <qobject.h>

namespace KDE {
namespace SLP {

class RegistryImpl;

class Registry : public QObject {
        Q_OBJECT
private:
        static int m_nextRegId;

        QString m_language;
        bool m_anyLanguage;
        KDE::Util::SmartPtr<RegistryImpl> m_impl;
        int m_regId;
        void *reserved;

        QString regIdToken(const QString &token);
        QString unregIdToken(const QString &token);
        bool isMyToken(const QString &token);

        KDE::Util::SmartPtr<RegistryImpl> createRegistryImpl(const QString &lang,
                                                             bool anyLang);
public:

        static const unsigned short UnlimitedLifetime = 65535;

        static const unsigned short RecommendedLifetime = 900;

        static const QStringList DefaultScopes;

        static const QString DefaultAuthority;

        static const QString AllAuthorities;


        Registry(const QString &language = QString::null,
                 bool allowAnyLanguage = true);

        virtual ~Registry();

        Registry(const Registry &other);


        Registry &operator=(const Registry &other);


        bool available() const;

        bool supportsAutoAddress() const;

        bool registerService(const Service &service,
                      bool autoAddress,
                      bool autoDeregister = true,
                      const QStringList &scopes = DefaultScopes,
                      unsigned short lifetime = RecommendedLifetime,
                      bool autoLifetimeExtension = true);

        bool deregister(const QString &serviceURL);

        bool deregister(const Service &service);

        bool findServiceTypes(const QString &token = QString::null,
                              const QString &namingAuthority = AllAuthorities,
                              const QStringList &scopeList = DefaultScopes);

        bool findServiceTypesAsync(const QString &token = QString::null,
                                   const QString &namingAuthority = AllAuthorities,
                                   const QStringList &scopeList = DefaultScopes);

        bool findServices(const QString &token,
                          const QString &srvtype,
                          bool fetchAttributes = true,
                          const Filter::List &filters = Filter::List(),
                          const QString &scopeList = QString::null);

        bool findServicesAsync(const QString &token,
                               const QString &srvtype,
                               bool fetchAttributes = true,
                               const Filter::List &filters = Filter::List(),
                               const QString &scopeList = QString::null);


        bool findAttributes(const QString &token,
                            const QString &serviceUrl,
                            const QStringList &attributeIds = QStringList());

        bool findAttributesAsync(const QString &token,
                                 const QString &serviceUrl,
                                 const QStringList &attributeIds = QStringList());

        bool findScopes(const QString &token);

        bool findScopesAsync(const QString &token);

 signals:
        void foundServiceTypes(QString token, QStringList serviceTypes);

        void foundService(QString token,
                          Service service,
                          int lifetime);

        void foundAttributes(QString token,
                             Service service);

        void foundScopes(QString token,
                         QStringList scopeList);


        void operationFinished(QString token, bool success, QString msg);


private slots:
        void slotFoundServiceTypes(QString token, QStringList serviceTypes);
        void slotFoundService(QString token,
                              Service service,
                              int lifetime);
        void slotFoundAttributes(QString token,
                                 Service service);
        void slotFoundScopes(QString token,
                             QStringList scopeList);
        void slotOperationFinished(QString token, bool success, QString msg);
};

}
}

#endif

---