ArnDiscover.hpp

Go to the documentation of this file.

// Copyright (C) 2010-2022 Michael Wiklund.
// All rights reserved.
// Contact: arnlib@wiklunden.se
//
// This file is part of the ArnLib - Active Registry Network.
// Parts of ArnLib depend on Qt and/or other libraries that have their own
// licenses. Usage of these other libraries is subject to their respective
// license agreements.
//
// GNU Lesser General Public License Usage
// This file may be used under the terms of the GNU Lesser General Public
// License version 2.1 as published by the Free Software Foundation and
// appearing in the file LICENSE_LGPL.txt included in the packaging of this
// file. In addition, as a special exception, you may use the rights described
// in the Nokia Qt LGPL Exception version 1.1, included in the file
// LGPL_EXCEPTION.txt in this package.
//
// GNU General Public License Usage
// Alternatively, this file may be used under the terms of the GNU General Public
// License version 3.0 as published by the Free Software Foundation and appearing
// in the file LICENSE_GPL.txt included in the packaging of this file.
//
// Other Usage
// Alternatively, this file may be used in accordance with the terms and conditions
// contained in a signed written agreement between you and Michael Wiklund.
//
// This program 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 Lesser General Public License for more details.
//

#ifndef ARNDISCOVER_HPP
#define ARNDISCOVER_HPP

#include "XStringMap.hpp"
#include "MQFlags.hpp"
#include <QHostAddress>
#include <QVariantMap>

class ArnDiscoverInfoPrivate;
class ArnDiscoverBrowserBPrivate;
class ArnDiscoverResolverPrivate;
class ArnDiscoverAdvertisePrivate;
class ArnZeroConfRegister;
class ArnZeroConfBrowser;
class QHostInfo;


namespace ArnDiscover
{
struct Type {
    enum E {
        None,
        Server,
        Client
    };
    MQ_DECLARE_ENUM( Type)
};
}



class ArnDiscoverInfo
{
    Q_DECLARE_PRIVATE(ArnDiscoverInfo)
    friend class ArnDiscoverBrowserB;

public:
    struct State {
        enum E {
            Init,
            ServiceName,
            HostInfoErr,
            HostInfo,
            HostIpErr,
            HostIp
        };
        MQ_DECLARE_ENUM( State)
    };

    ArnDiscoverInfo();
    ArnDiscoverInfo( const ArnDiscoverInfo& other);
    ArnDiscoverInfo&  operator=( const ArnDiscoverInfo& other);
    ~ArnDiscoverInfo();


    bool  inProgress()  const;


    bool  isError()  const;


    State  state()  const;


    State  stopState()  const;


    ArnDiscover::Type type()  const;


    QStringList  groups()  const;


    QString  serviceName()  const;


    QString  domain()  const;


    QString  hostName()  const;


    quint16  hostPort()  const;


    QHostAddress  hostIp()  const;


    Arn::XStringMap  properties()  const;


    QString  typeString()  const;


    QString  hostPortString()  const;


    QString  hostIpString()  const;


    QString  hostWithInfo()  const;


    int  resolvCode()  const;

protected:
    ArnDiscoverInfo( ArnDiscoverInfoPrivate& dd);
    ArnDiscoverInfoPrivate* const  d_ptr;

private:
};


class ArnDiscoverBrowserB : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnDiscoverBrowserB)

public:
    explicit ArnDiscoverBrowserB( QObject *parent = arnNullptr);
    ~ArnDiscoverBrowserB();


    int serviceCount()  const;


    const ArnDiscoverInfo&  infoByIndex( int index);


    const ArnDiscoverInfo&  infoById( int id);


    const ArnDiscoverInfo&  infoByName( const QString& serviceName);


    int  indexToId( int index);


    int  IdToIndex( int id);


    int  serviceNameToId( const QString& name);


    ArnDiscoverInfo::State  defaultStopState()  const;


    void  setDefaultStopState( ArnDiscoverInfo::State defaultStopState);


    bool  goTowardState( int index, ArnDiscoverInfo::State state);

signals:

    void  serviceAdded( int index, const QString& name);


    void  serviceRemoved( int index);


    void  infoUpdated( int index, ArnDiscoverInfo::State state);

protected:

    bool  isBrowsing()  const;


    void  setFilter( ArnDiscover::Type typeFilter);


    void  setFilter( const QString& group);


    void  browse( bool enable = true);


    void  stopBrowse();


    int  resolve( const QString& serviceName, bool forceUpdate = true);

    ArnDiscoverBrowserB( ArnDiscoverBrowserBPrivate& dd, QObject* parent);
    ArnDiscoverBrowserBPrivate* const  d_ptr;

private slots:
    void  onBrowseError( int code);
    void  onServiceAdded( int id, const QString& name, const QString& domain);
    void  onServiceRemoved( int id, const QString& name, const QString& domain);

    void  onResolveError( int id, int code);
    void  onResolved( int id, const QByteArray& escFullDomain);

    void  onLookupError( int id, int code);
    void  onLookuped( int id);

private:
    void  init();
    int  newServiceInfo( int id, const QString& name, const QString& domain);
    void  removeServiceInfo( int index);
    void  doNextState( ArnDiscoverInfo& info);
    void  doHostIpLogic( ArnDiscoverInfo& info);
};



class ArnDiscoverBrowser : public ArnDiscoverBrowserB
{
    Q_OBJECT
public:
    explicit ArnDiscoverBrowser( QObject *parent = arnNullptr);


    bool  isBrowsing()  const
    {return ArnDiscoverBrowserB::isBrowsing();}


    void  setFilter( ArnDiscover::Type typeFilter)
    {ArnDiscoverBrowserB::setFilter( typeFilter);}


    void  setFilter( const QString& group)
    {ArnDiscoverBrowserB::setFilter( group);}

public slots:

    void  browse( bool enable = true)
    {ArnDiscoverBrowserB::browse( enable);}


    void  stopBrowse()
    {ArnDiscoverBrowserB::stopBrowse();}
};



class ArnDiscoverResolver : public ArnDiscoverBrowserB
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnDiscoverResolver)

public:
    explicit ArnDiscoverResolver( QObject *parent = arnNullptr);


    QString  defaultService()  const;


    void  setDefaultService( const QString& defaultService);

public slots:

    int  resolve( const QString& serviceName, bool forceUpdate = true);

protected:
    ArnDiscoverResolver( ArnDiscoverResolverPrivate& dd, QObject* parent);

private:
};



class ArnDiscoverAdvertise : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnDiscoverAdvertise)

public:
    struct State {
        enum E {
            None             = 0x0000,
            StartupAdvertise = 0x0100,
            Advertising      = 0x0001,
            Advertise        = 0x0101
        };
        MQ_DECLARE_FLAGS( State)
    };

    explicit ArnDiscoverAdvertise( QObject *parent = arnNullptr);
    ~ArnDiscoverAdvertise();


    QStringList groups() const;


    void setGroups( const QStringList& groups);


    void  addGroup( const QString& group);


    QString  service() const;


    QString  currentService() const;


    State  state()  const;


    void  advertiseService( ArnDiscover::Type discoverType, const QString& serviceName,
                            int port = -1, const QString& hostName = QString());


    Arn::XStringMap  customProperties()  const;


    void  setCustomProperties( const Arn::XStringMap& customProperties);


    void  addCustomProperty( const QString& key, const QString& val);

signals:

    void  serviceChanged( const QString& serviceName);


    void  serviceChangeError( int code);

public slots:

    virtual void  setService( const QString& service);

protected:
    bool  hasSetupAdvertise()  const;
    void  setHostIpList( const QStringList& hostIpList);

    ArnDiscoverAdvertise( ArnDiscoverAdvertisePrivate& dd, QObject* parent);
    ArnDiscoverAdvertisePrivate* const  d_ptr;

protected slots:

    virtual void  postSetupThis();


    virtual void  serviceRegistered( const QString& serviceName);


    virtual void  serviceRegistrationError( int code);

private:
    void  init();
};

MQ_DECLARE_OPERATORS_FOR_FLAGS( ArnDiscoverAdvertise::State)

#endif // ARNDISCOVER_HPP