ArnBasicItem.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 ARNBASICITEM_HPP
#define ARNBASICITEM_HPP

#include "ArnLib_global.hpp"
#include "ArnCoreItem.hpp"
#include "ArnLinkHandle.hpp"
#include "ArnError.hpp"
#include "Arn.hpp"
#include "MQFlags.hpp"
#include <QString>
#include <QByteArray>
#include <QVariant>
#include <QAtomicInt>
#include <QObject>

class ArnBasicItemPrivate;
class ArnLink;
class ArnEvent;


class ArnBasicItemEventHandler : public QObject
{
    Q_OBJECT

public:
    explicit ArnBasicItemEventHandler( QObject* parent = 0);
    virtual ~ArnBasicItemEventHandler();

    static void  defaultEvent( QEvent* ev);

protected:
    virtual void  customEvent( QEvent* ev);
};



class ARNLIBSHARED_EXPORT ArnBasicItem : public ArnCoreItem
{
    Q_DECLARE_PRIVATE(ArnBasicItem)
    friend class ArnBasicItemEventHandler;

public:

    ArnBasicItem();

    virtual  ~ArnBasicItem();


    bool  open( const QString& path);

    void  close();


    void  destroyLink( bool isGlobal = true);


    void  destroyLinkLocal()
    { destroyLink( false);}


    bool  isOpen()  const;


    QString  path( Arn::NameF nameF = Arn::NameF::EmptyOk)  const;


    QString  name( Arn::NameF nameF)  const;


    void  setReference( void* reference);


    void*  reference()  const;


    uint  itemId()  const;


    uint  linkId()  const;


    int  refCount()  const;

    bool  isFolder()  const;

    bool  isProvider()  const;


    Arn::DataType  type()  const;


    void  setIgnoreSameValue( bool isIgnore = true);

    bool  isIgnoreSameValue()  const;


    void  addMode( Arn::ObjectMode mode);

    Arn::ObjectMode  getMode()  const;

    Arn::ObjectSyncMode  syncMode()  const;


    ArnBasicItem&  setBiDirMode();

    bool  isBiDirMode()  const;


    ArnBasicItem&  setPipeMode();

    bool  isPipeMode()  const;


    ArnBasicItem&  setSaveMode();

    bool  isSaveMode()  const;


    void  setAtomicOpProvider();

    bool  isAtomicOpProvider()  const;


    ArnBasicItem&  setMaster();

    bool  isMaster()  const;


    ArnBasicItem&  setAutoDestroy();

    bool  isAutoDestroy()  const;


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

    QByteArray  arnExport()  const;

    int  toInt( bool* isOk = arnNullptr)  const;

    double  toDouble( bool* isOk = arnNullptr)  const;

    ARNREAL  toReal( bool* isOk = arnNullptr)  const;

    QString  toString( bool* isOk = arnNullptr)  const;

    QByteArray  toByteArray( bool* isOk = arnNullptr)  const;

    QVariant  toVariant( bool* isOk = arnNullptr)  const;

    bool  toBool( bool* isOk = arnNullptr)  const;

    uint  toUInt( bool* isOk = arnNullptr)  const;

    qint64  toInt64( bool* isOk = arnNullptr)  const;

    quint64  toUInt64( bool* isOk = arnNullptr)  const;

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

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

    void  setValue( const ArnBasicItem& other, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( int value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( ARNREAL value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( bool value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( const QString& value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( const QByteArray& value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( const QVariant& value, int ignoreSame = Arn::SameValue::DefaultAction);


    void  setValue( const char* value, int ignoreSame = Arn::SameValue::DefaultAction);


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


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


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


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


    void  addValue( int value);


    void  addValue( ARNREAL value);


    QThread*  thread()  const;


    void  setEventHandler( QObject* eventHandler);


    QObject*  eventHandler()  const;


    void  setUncrossed( bool isUncrossed = true);


    bool  isUncrossed()  const;


    bool  isAssigning()  const;

    bool  sendArnEventLink( ArnEvent* ev);
    void  sendArnEventItem( ArnEvent* ev, bool isAlienThread, bool isLocked = false);
    quint32  localUpdateCount()  const;

protected:
    virtual void  arnEvent( QEvent* ev, bool isAlienThread);

    bool  openWithFlags( const QString& path, Arn::LinkFlags linkFlags);
    void  setForceKeep( bool fk = true);
    bool  isForceKeep()  const;
    Arn::ObjectMode  getMode( ArnLink* link)  const;
    void  addSyncMode( Arn::ObjectSyncMode syncMode, bool linkShare);
    void  resetOnlyEcho();
    void  addIsOnlyEcho( quint32 sendId);
    bool  isOnlyEcho()  const;
    uint  retireType();
    void  setValue( const QByteArray& value, int ignoreSame, ArnLinkHandle& handleData);
    void  setValue( const QVariant& value, int ignoreSame, ArnLinkHandle& handleData);
    void  arnImport( const QByteArray& data, int ignoreSame, ArnLinkHandle& handleData);
    QStringList  childItemsMain()  const;
    void  errorLog( const QString& errText, ArnError err = ArnError::Undef, void* reference = arnNullptr)  const;

    ArnBasicItem( ArnBasicItemPrivate& dd);

private:
    void  init();
    void  setupOpenItem( bool isFolder);
    ArnBasicItemEventHandler*  getThreadEventHandler();

    ArnLink*  _link;
};

#endif // ARNBASICITEM_HPP