ArnPersist.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 ARNPERSIST_HPP
#define ARNPERSIST_HPP

#include "ArnLib_global.hpp"
#include "ArnM.hpp"
#include <QMap>
#include <QList>
#include <QStringList>
#include <QObject>

class ArnPersist;
class ArnPersistPrivate;
class ArnPersistSapi;
class ArnDependOffer;
class QSqlDatabase;
class QSqlQuery;
class QDir;

namespace Arn {
class XStringMap;
}


class ArnItemPersist : protected ArnItem
{
    Q_OBJECT

public:
    struct StoreType {
        enum E {
            DataBase = 0,
            File
        };
        MQ_DECLARE_ENUM( StoreType)
    };
    explicit ArnItemPersist( ArnPersist* arnPersist);
    virtual  ~ArnItemPersist();
    void  setStoreId( int id)  {_storeId = id;}
    int  storeId()  const {return _storeId;}
    void  setStoreType( StoreType type)  {_storeType = type;}
    StoreType  storeType()  const {return _storeType;}
    void  setMandatory( bool v)  {_isMandatory = v;}
    bool  isMandatory()  const {return _isMandatory;}

    ArnItem*  toArnItem() {return this;}
    static ArnItemPersist*  fromArnItem( ArnItem* item) {return static_cast<ArnItemPersist*>( item);}

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

    using ArnItem::open;
    using ArnItem::linkId;
    using ArnItem::setIgnoreSameValue;
    using ArnItem::setDelay;
    using ArnItem::addMode;
    using ArnItem::getMode;
    using ArnItem::path;
    using ArnItem::deleteLater;
    using ArnItem::arnExport;
    using ArnItem::toByteArray;
    using ArnItem::bypassDelayPending;

private:
    StoreType  _storeType;
    int  _storeId;
    bool  _isMandatory;
    ArnPersist*  _arnPersist;
};


class ARNLIBSHARED_EXPORT ArnVcs : public QObject
{
    Q_OBJECT

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

signals:
    void  notify( const QString msg);
    void  progress( int, QString msg=QString());

    void  userSettingsR( QString name, QString email);
    void  filesR( QStringList files);
    void  tagR();
    void  commitR();
    void  checkoutR();
    void  branchesR( QStringList branches);
    void  tagsR( QStringList tags);
    void  statusR( QString statusLines);
    void  diffR( QString diffLines);
    void  logRecordR( QString lines);
    void  logR( QStringList refs, QStringList msgs);

public slots:
    virtual void  log( int numLog);
    virtual void  files( QString ref);
    virtual void  commit( QString commitMsg, QStringList files, QString name, QString email);
    virtual void  tag( QString name, QString ref);
    virtual void  diff( QString ref, QStringList files);
    virtual void  logRecord( QString ref);
    virtual void  tags();
    virtual void  branches();
    virtual void  status();
    virtual void  userSettings();
    virtual void  setUserSettings( QString userName, QString userEmail);
    virtual void  checkout( QString ref, QStringList files);

private slots:

private:
};



class ARNLIBSHARED_EXPORT ArnPersist : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnPersist)

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


    bool  setMountPoint( const QString& path);


    void  setPersistDir( const QString& path);


    void  setArchiveDir( const QString& path);


    void  setVcs( ArnVcs* vcs);


    bool  setupDataBase( const QString& dbName = "persist.db");


    bool  flush( const QString& path = QString());

    QString  metaDbValue( const QString& attr, const QString& def = QString());
    bool  setMetaDbValue( const QString& attr, const QString& value);
    bool  getDbId( const QString& path, int& storeId);
    bool  getDbValue( int storeId, QString& path, QByteArray& value);
    bool  getDbValue( const QString& path, QByteArray& value, int& storeId);
    bool  getDbMandatoryList( QList<int>& storeIdList);
    bool  getDbList( bool isUsed, QList<int>& storeIdList);
    bool  insertDbValue( const QString& path, const QByteArray& value);
    bool  updateDbValue( int storeId, const QByteArray& value);
    bool  updateDbUsed( int storeId, int isUsed);
    bool  updateDbMandatory( int storeId, int isMandatory);

public slots:

    bool  doArchive( const QString& name = QString());

protected:
    ArnPersist( ArnPersistPrivate& dd, QObject* parent);
    ArnPersistPrivate* const  d_ptr;

private slots:
    void  sapiFlush( const QString& path);
    void  sapiTest( const QString& str, int i=0);
    void  sapiLs( const QString& path);
    void  sapiLoad();
    void  sapiRm( const QString& path);
    void  sapiTouch( const QString& path);
    void  sapiDbMandatory( const QString& path, bool isMandatory);
    void  sapiDbMandatoryLs( const QString& path);
    void  sapiDbLs( const QString& path, bool isUsed = true);
    void  sapiDbMarkUnused( const QString& path);
    void  sapiInfo();

    void  vcsCheckoutR();

    void  doArnModeChanged( const QString& path, uint linkId, Arn::ObjectMode mode);
    void  doArnUpdate();
    void  doArnDestroy();
    void  destroyRpc();

private:
    void  init();
    ArnItemPersist*  getPersistItem( const QString& path);
    ArnItemPersist*  setupMandatory( const QString& path, bool isMandatory);
    void  removeFilePersistItem( const QString& path);
    void  getFileList( QStringList& flist, const QDir& dir, const QDir* baseDir = arnNullptr);
    void  loadFile( const QString& relPath);
    void  doLoadMandatory();
    void  doLoadFiles();
    void  setupSapi( ArnPersistSapi* sapi);
    void  convertFileList( QStringList& files, Arn::NameF nameF);
    void  dbSetupReadValue( const QString& meta, const QString& valueTxt,
                            QByteArray& value);
    void  dbSetupWriteValue(QString& meta, QString& valueTxt, QByteArray& value);
};

#endif // ARNPERSIST_HPP