ArnM.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 ARNM_HPP
#define ARNM_HPP

#include "ArnLib_global.hpp"
#include "Arn.hpp"
#include "MQFlags.hpp"
#include "ArnError.hpp"
#include "ArnItem.hpp"
#include <QIODevice>
#include <QStringList>
#include <QVector>
#include <QMetaType>
#include <QObject>
#include <QMutex>
#include <QWaitCondition>

class ArnThreadComStorage;
class QDir;
class QTimer;


class ArnThreadCom
{
    friend class ArnThreadComCaller;
    friend class ArnThreadComProxyLock;

public:
    ArnThreadCom() {
        _retObj = 0;
    }

    void*  _retObj;
    QStringList  _retStringList;

private:
    static ArnThreadComStorage*  getThreadComStorage();
    static ArnThreadCom*  getThreadCom();

    QWaitCondition  _commandEnd;
    QMutex  _mutex;
};

Q_DECLARE_METATYPE(ArnThreadCom*)


class ArnThreadComCaller
{
    ArnThreadCom*  _p;
public:
    ArnThreadComCaller();
    ~ArnThreadComCaller();
    void  waitCommandEnd();
    ArnThreadCom*  p();
};


class ArnThreadComProxyLock
{
    ArnThreadCom*  _p;
public:
    ArnThreadComProxyLock( ArnThreadCom* threadCom);
    ~ArnThreadComProxyLock();
};



class ARNLIBSHARED_EXPORT ArnM : public QObject
{
    Q_OBJECT
    friend class ArnBasicItem;

public:
    static ArnM&  instance();

    static void  setConsoleError( bool isConsoleError);


    static void  setDefaultIgnoreSameValue( bool isIgnore = true);

    static bool  defaultIgnoreSameValue();

    static bool  isMainThread();

    static bool  isThreadedApp();


    static int  valueInt( const QString& path);


    static double  valueDouble( const QString& path);


    static ARNREAL  valueReal( const QString& path);


    static QString  valueString( const QString& path);


    static QByteArray  valueByteArray( const QString& path);


    static QVariant  valueVariant( const QString& path);


    static QStringList  items( const QString& path);

    static bool  exist(const QString& path);

    static bool  isFolder( const QString& path);

    static bool  isLeaf( const QString& path);


    static void  setAtomicOpProvider( const QString& path);

    static bool  isAtomicOpProvider( const QString& path);


    static void  setValue( const QString& path, int value);


    static void  setValue( const QString& path, ARNREAL value);


    static void  setValue( const QString& path, const QString& value);


    static void  setValue( const QString& path, const QByteArray& value);


    static void  setValue( const QString& path, const QVariant& value, const char* typeName = arnNullptr);


    static void  setValue( const QString& path, const char* value);


    static bool  loadFromFile( const QString& path, const QString& fileName, Arn::Coding coding);


    static bool  loadFromDirRoot( const QString& path, const QDir& dirRoot, Arn::Coding coding);


    static bool  saveToFile( const QString& path, const QString& fileName, Arn::Coding coding);

    static void  errorLog( QString errText, ArnError err = ArnError::Undef, void* reference = arnNullptr);
    static QString  errorSysName();


    static QByteArray  info();


    bool  skipLocalSysLoading()  const;


    void  setSkipLocalSysLoading( bool skipLocalSysLoading);


    static void  destroyLinkLocal( const QString& path)
    { destroyLink( path, false); }

public slots:

    static void  destroyLink( const QString& path, bool isGlobal = true);

    static void  setupErrorlog( QObject* errLog);

signals:
    void  errorLogSig( const QString& errText, uint errCode, void* reference);

protected:
#ifndef DOXYGEN_SKIP
    virtual void  customEvent( QEvent* ev);

    static ArnLink*  root();
    static ArnLink*  link( const QString& path, Arn::LinkFlags flags,
                           Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode());
    static ArnLink*  addTwin( const QString& path, ArnLink* child,
                              Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode(),
                              Arn::LinkFlags flags = Arn::LinkFlags());
    static void  destroyLink( ArnLink* link, bool isGlobal);
    static void  destroyLinkMain( ArnLink* link, ArnLink* startLink, bool isGlobal);
    static void  changeRefCounter( int step);
#endif

private slots:
    void  postSetup();
    void  onTimerMetrics();
    static void  linkProxy( ArnThreadCom* threadCom, const QString& path,
                            int flagValue, int syncMode = 0);
    static void  itemsProxy( ArnThreadCom* threadCom, const QString& path);

private:
    ArnM();
    ArnM( const ArnM&);
    ~ArnM();
    ArnM&  operator=( const ArnM&);

    static ArnLink*  linkMain( const QString& path, Arn::LinkFlags flags,
                               Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode());
    static ArnLink*  linkThread( const QString& path, Arn::LinkFlags flags,
                                 Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode());
    static ArnLink*  linkMain( const QString& path, ArnLink *parent, const QString& name,
                               Arn::LinkFlags flags, Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode());
    static ArnLink*  addTwinMain( const QString& path, ArnLink* child,
                                  Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode(),
                                  Arn::LinkFlags flags = Arn::LinkFlags::fromInt(0));
    static ArnLink*  getRawLink( ArnLink *parent, const QString& name, Arn::LinkFlags flags);
    static QStringList  itemsMain( const ArnLink *parent);
    static QStringList  itemsMain( const QString& path);

    static void  doZeroRefLink( ArnLink* link);

    // The root object of all other arn data
    ArnLink*  _root;

    QVector<QString>  _errTextTab;
    bool  _consoleError;
    bool  _defaultIgnoreSameValue;
    bool  _skipLocalSysLoading;
    QObject*  _errorLogger;

    volatile bool  _isThreadedApp;
    QThread*  _mainThread;

    static int  _countFolder;
    static int  _countLeaf;
    static QAtomicInt  _countRef;
    ArnLink*  _countFolderLink;
    ArnLink*  _countLeafLink;
    ArnLink*  _countRefLink;
    QTimer*  _timerMetrics;
};

#endif // ARNM_HPP