ArnInterface.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 ARNINTERFACE_HPP
#define ARNINTERFACE_HPP

#include "ArnLib_global.hpp"
#include "ArnM.hpp"


class ARNLIBSHARED_EXPORT ArnInterface : public QObject
{
    Q_OBJECT
    Q_PROPERTY( QString info  READ info  NOTIFY dummyNotifier)
public:
    enum SameValue {
        SameValue_Accept = Arn::SameValue::Accept,
        SameValue_Ignore = Arn::SameValue::Ignore,
        SameValue_DefaultAction = Arn::SameValue::DefaultAction
    };
    Q_ENUMS( SameValue)

    
    enum DataType {
        DataType_Null      = Arn::DataType::Null,
        DataType_Int       = Arn::DataType::Int,
        DataType_Double    = Arn::DataType::Double,
        DataType_Real      = Arn::DataType::Real,
        DataType_ByteArray = Arn::DataType::ByteArray,
        DataType_String    = Arn::DataType::String,
        DataType_Variant   = Arn::DataType::Variant
    };
    Q_ENUMS( DataType)

    
    enum ObjectMode {
        ObjectMode_BiDir = Arn::ObjectMode::BiDir,
        ObjectMode_Pipe  = Arn::ObjectMode::Pipe,
        ObjectMode_Save  = Arn::ObjectMode::Save
    };
    Q_ENUMS( ObjectMode)

    
    enum NameF {
        NameF_Default      = Arn::NameF::Default,
        NameF_NoFolderMark = Arn::NameF::NoFolderMark,
        NameF_EmptyOk      = Arn::NameF::EmptyOk,
        NameF_Relative     = Arn::NameF::Relative
    };
    Q_ENUMS( NameF)

    explicit  ArnInterface( QObject* parent = arnNullptr) : QObject( parent) {}

    QString  info()                             {return QString::fromUtf8( ArnM::instance().info().constData());}

public slots:

    QVariant  value( const QString& path)       {return ArnM::instance().valueVariant( path);}

    QVariant  variant( const QString& path)     {return ArnM::instance().valueVariant( path);}

    QString  string( const QString& path)       {return ArnM::instance().valueString( path);}

    QByteArray  bytes( const QString& path)     {return ArnM::instance().valueByteArray( path);}

#ifdef ARNREAL_FLOAT
    float  num( const QString& path)            {return ArnM::instance().valueDouble( path);}
#else
    double  num( const QString& path)           {return ArnM::instance().valueDouble( path);}
#endif

    int  intNum( const QString& path)           {return ArnM::instance().valueInt( path);}

    QStringList  items( const QString& path)    {return ArnM::instance().items( path);}

    bool  exist(const QString& path)            {return ArnM::instance().exist( path);}

    bool  isFolder( const QString& path)        {return ArnM::instance().isFolder( path);}

    bool  isLeaf( const QString& path)          {return ArnM::instance().isLeaf( path);}

    void  setValue( const QString& path, const QVariant& value)
    {ArnM::instance().setValue( path, value);}

    void  setVariant( const QString& path, const QVariant& value, const QString& typeName = QString())
    {ArnM::instance().setValue( path, value, typeName.toLatin1().constData());}

    void  setString( const QString& path, const QString& value)
    {ArnM::instance().setValue( path, value);}

    void  setBytes( const QString& path, const QByteArray& value)
    {ArnM::instance().setValue( path, value);}

#ifdef ARNREAL_FLOAT
    void  setNum( const QString& path, float value)
#else
    void  setNum( const QString& path, double value)
#endif
    {ArnM::instance().setValue( path, value);}

    void  setIntNum( const QString& path, int value)
    {ArnM::instance().setValue( path, value);}


    bool  isFolderPath( const QString& path)    {return Arn::isFolderPath( path);}

    bool  isProviderPath( const QString& path)  {return Arn::isProviderPath( path);}

    QString  itemName( const QString& path)     {return Arn::itemName( path);}

    QString  twinPath( const QString& path)     {return Arn::twinPath( path);}

    QString  changeBasePath( const QString& oldBasePath, const QString& newBasePath, const QString& path)
    {return Arn::changeBasePath( oldBasePath, newBasePath, path);}

    QString  childPath( const QString& parentPath, const QString& posterityPath)
    {return Arn::childPath( parentPath, posterityPath);}

    QString  makePath( const QString& parentPath, const QString& itemName)
    {return Arn::makePath( parentPath, itemName);}

    QString  providerPath( const QString& path, bool giveProviderPath = true)
    {return  Arn::providerPathIf( path, giveProviderPath);}

signals:
    void  dummyNotifier();
};

#endif // ARNINTERFACE_HPP