ArnItem.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 ARNITEM_HPP
#define ARNITEM_HPP

#include "ArnLib_global.hpp"
#include "ArnItemB.hpp"
#include "ArnError.hpp"
#include <QTextStream>
#include <QObject>
#include <QMetaMethod>
#include <QString>
#include <QByteArray>
#include <QVariant>
#include <QAtomicInt>

class ArnItemPrivate;



class ARNLIBSHARED_EXPORT ArnItem : public ArnItemB
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnItem)

public:

    ArnItem( QObject* parent = arnNullptr);


    ArnItem( const QString& path, QObject* parent = arnNullptr);


    ArnItem( const ArnItem& itemTemplate, const QString& path, QObject* parent = arnNullptr);

    virtual  ~ArnItem();


    bool  openUuid( const QString& path)
    {return ArnItemB::openUuid( path);}


    bool  openUuidPipe( const QString& path)
    {return ArnItemB::openUuidPipe( path);}


    bool  openFolder( const QString& path)
    {return ArnItemB::openFolder( path);}

    bool  isFolder()  const
    {return ArnItemB::isFolder();}

    bool  isProvider()  const
    {return ArnItemB::isProvider();}


    Arn::DataType  type()  const
    {return ArnItemB::type();}


    void  setIgnoreSameValue( bool isIgnore = true)
    {ArnItemB::setIgnoreSameValue( isIgnore);}

    bool  isIgnoreSameValue()
    {return ArnItemB::isIgnoreSameValue();}


    void  addMode( Arn::ObjectMode mode)
    {return ArnItemB::addMode( mode);}

    Arn::ObjectMode  getMode()  const
    {return ArnItemB::getMode();}

    Arn::ObjectSyncMode  syncMode()  const
    {return ArnItemB::syncMode();}


    ArnItem&  setTemplate( bool isTemplate = true);

    bool  isTemplate()  const;


    ArnItem&  setBiDirMode()
    {ArnItemB::setBiDirMode(); return *this;}

    bool  isBiDirMode()  const
    {return ArnItemB::isBiDirMode();}


    ArnItem&  setPipeMode()
    {ArnItemB::setPipeMode(); return *this;}

    bool  isPipeMode()  const
    {return ArnItemB::isPipeMode();}


    ArnItem&  setSaveMode()
    {ArnItemB::setSaveMode(); return *this;}

    bool  isSaveMode()  const
    {return ArnItemB::isSaveMode();}


    ArnItem&  setMaster()
    {ArnItemB::setMaster(); return *this;}

    bool  isMaster()  const
    {return ArnItemB::isMaster();}


    ArnItem&  setAutoDestroy()
    {ArnItemB::setAutoDestroy(); return *this;}

    bool  isAutoDestroy()  const
    {return ArnItemB::isAutoDestroy();}


    void  setUncrossed( bool isUncrossed = true)
    {return ArnItemB::setUncrossed( isUncrossed);}


    bool  isUncrossed()  const
    {return ArnItemB::isUncrossed();}


    void  setBlockEcho( bool blockEcho = true)
    {return ArnItemB::setBlockEcho( blockEcho);}


    void  setDelay( int delay);


    int  delay()  const;

    bool  isDelayPending()  const;

    void  bypassDelayPending();


    void  arnImport( const QByteArray& data, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::arnImport( data, ignoreSame);}

    QByteArray  arnExport()  const
    {return ArnItemB::arnExport();}

    int  toInt( bool* isOk = arnNullptr)  const
    {return ArnItemB::toInt( isOk);}

    double  toDouble( bool* isOk = arnNullptr)  const
    {return ArnItemB::toDouble( isOk);}

    ARNREAL  toReal( bool* isOk = arnNullptr)  const
    {return ArnItemB::toReal( isOk);}

    bool  toBool( bool* isOk = arnNullptr)  const
    {return ArnItemB::toBool( isOk);}

    QString  toString( bool* isOk = arnNullptr)  const
    {return ArnItemB::toString( isOk);}

    QByteArray  toByteArray( bool* isOk = arnNullptr)  const
    {return ArnItemB::toByteArray( isOk);}

    QVariant  toVariant( bool* isOk = arnNullptr)  const
    {return ArnItemB::toVariant( isOk);}

    uint  toUInt( bool* isOk = arnNullptr)  const
    {return ArnItemB::toUInt( isOk);}

    qint64  toInt64( bool* isOk = arnNullptr)  const
    {return ArnItemB::toInt64( isOk);}

    quint64  toUInt64( bool* isOk = arnNullptr)  const
    {return ArnItemB::toUInt64( isOk);}

    ArnItem&  operator=( const ArnItem& other);
    ArnItem&  operator=( int val);
    ArnItem&  operator=( ARNREAL other);
    ArnItem&  operator=( const QString& val);
    ArnItem&  operator=( const QByteArray& val);
    ArnItem&  operator=( const QVariant& val);
    ArnItem&  operator=( const char* val);
    ArnItem&  operator=( uint val);
    ArnItem&  operator=( qint64 val);
    ArnItem&  operator=( quint64 val);

    ArnItem&  operator+=( int val);
    ArnItem&  operator+=( ARNREAL val);


    void  setValue( const ArnItem& other, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::setValue( other, ignoreSame);}


    void  setValue( uint value, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( qint64 value, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( quint64 value, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( int value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


#ifdef ARNREAL_FLOAT
    void  setValue( float value, int ignoreSame)
#else
    void  setValue( double value, int ignoreSame)
#endif
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( bool value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( const QString& value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( const QByteArray& value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( const QVariant& value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setValue( const char* value, int ignoreSame)
    {ArnItemB::setValue( value, ignoreSame);}


    void  setBits( int mask, int value, int ignoreSame = Arn::SameValue::DefaultAction)
    {ArnItemB::setBits( mask, value, ignoreSame);}


    void  addValue( int value)
    {ArnItemB::addValue( value);}


    void  addValue( ARNREAL value)
    {ArnItemB::addValue( value);}

public slots:

    void  setValue( int value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


#ifdef ARNREAL_FLOAT
    void  setValue( float value)
#else
    void  setValue( double value)
#endif
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  setValue( bool value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  setValue( const QString& value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  setValue( const QByteArray& value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  setValue( const QVariant& value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  setValue( const char* value)
    {ArnItemB::setValue( value, Arn::SameValue::DefaultAction);}


    void  toggleBool();

signals:

    void  changed();

    void  changed( int value);

#ifdef ARNREAL_FLOAT
    void  changed( float value);
#else
    void  changed( double value);
#endif

    void  changed( bool value);

    void  changed( const QString& value);

    void  changed( const QByteArray& value);

    void  changed( const QVariant& value);


    void  modeChanged( Arn::ObjectMode mode);


    void  arnItemCreated( const QString& path);


    void  arnModeChanged( const QString& path, uint linkId, Arn::ObjectMode mode);

protected:
    virtual void  itemUpdated( const ArnLinkHandle& handleData, const QByteArray* value = arnNullptr);
    virtual void  modeUpdate( Arn::ObjectMode mode, bool isSetup = false);
    virtual void  itemCreatedBelow( const QString& path);
    virtual void  itemModeChangedBelow( const QString& path, uint linkId, Arn::ObjectMode mode);
    virtual void  timerEvent( QTimerEvent* ev);

    int  delayTimerId()  const;

    ArnItem( ArnItemPrivate& dd, QObject* parent);

private slots:

private:
    void  init();
    void  doItemUpdate( const ArnLinkHandle& handleData);

#if QT_VERSION >= 0x050000
    void  connectNotify( const QMetaMethod & signal);
    void  disconnectNotify( const QMetaMethod & signal);
    static QMetaMethod  _metaSignalChanged;
    static QMetaMethod  _metaSignalChangedInt;
    static QMetaMethod  _metaSignalChangedReal;
    static QMetaMethod  _metaSignalChangedBool;
    static QMetaMethod  _metaSignalChangedString;
    static QMetaMethod  _metaSignalChangedByteArray;
    static QMetaMethod  _metaSignalChangedVariant;
#else
    void  connectNotify( const char* signal);
    void  disconnectNotify( const char* signal);
#endif
};

QTextStream&  operator<<(QTextStream& out, const ArnItem& item);

#endif // ARNITEM_HPP