Arn.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 ARN_HPP
#define ARN_HPP

#include "MQFlags.hpp"
#include "ArnLib_global.hpp"
#include <QString>

#define DATASTREAM_VER  QDataStream::Qt_4_6

#if defined( ARNREAL_FLOAT)
#  define ARNREAL   float
#else
#  define ARNREAL   double
#endif


namespace Arn {

    const quint16  defaultTcpPort = 2022;

    extern const QString  pathLocal;
    extern const QString  pathLocalSys;
    extern const QString  pathDiscover;
    extern const QString  pathDiscoverThis;
    extern const QString  pathDiscoverConnect;
    extern const QString  pathServer;
    extern const QString  pathServerSessions;

struct SameValue {
    enum E {
        Accept = 0,
        Ignore = 1,
        DefaultAction = -1
    };
    MQ_DECLARE_ENUM( SameValue)
};

class DataType {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        Null       = 0,
        Int        = 1,
        Double     = 2,
        Real       = 2,
        ByteArray  = 3,
        String     = 4,
        Variant    = 5
        // 16 and above (max 255) is reserved by ArnItemB::ExportCode
    };
    MQ_DECLARE_ENUMTXT( DataType)
};

class ExportCode {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        ByteArray  = 3,
        String     = 4,
        Variant    = 5,  // Legacy
        VariantTxt = 16,
        VariantBin = 17
    };
    MQ_DECLARE_ENUMTXT( ExportCode)
};

struct InfoType {
    enum  E {
        Custom = 0,
        N  // Max N = 1000
    };
    MQ_DECLARE_ENUM( InfoType)
};

class ObjectMode {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        Normal = 0x00,
        BiDir  = 0x01,
        Pipe   = 0x02,
        Save   = 0x04
    };
    MQ_DECLARE_FLAGSTXT( ObjectMode)
};

class ObjectSyncMode {  // This mode is sent with sync-command
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        Normal      = 0x00,
        Monitor     = 0x01,
        Master      = 0x02,
        AutoDestroy = 0x04
    };
    MQ_DECLARE_FLAGSTXT( ObjectSyncMode)
};

struct ClientSyncMode {
    enum E {
        Invalid,
        StdAutoMaster,
        ImplicitMaster,
        ExplicitMaster
    };
    MQ_DECLARE_ENUM( ClientSyncMode)
};

struct LinkFlags {
    enum E {
        Folder        = 0x01,
        CreateAllowed = 0x02,
        SilentError   = 0x04,
        LastLink      = 0x08,
        Threaded      = 0x80
    };
    MQ_DECLARE_FLAGS( LinkFlags)
};

struct NameF {
    enum E {
        Default      = 0x00,
        NoFolderMark = 0x01,
        EmptyOk      = 0x02,
        Relative     = 0x04
    };
    MQ_DECLARE_FLAGS( NameF)
};

struct Coding {
    enum E {
        Binary  = 0x0000,
        Text    = 0x1000
    };
    MQ_DECLARE_FLAGS( Coding)
};

class Allow {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        None       = 0x00,
        Read       = 0x01,
        Write      = 0x02,
        Create     = 0x04,
        Delete     = 0x08,
        ModeChange = 0x10,
        ReadWrite  = 0x03,
        All        = 0xff
    };
    MQ_DECLARE_FLAGSTXT( Allow)
};


QString  convertName( const QString& name, Arn::NameF nameF = Arn::NameF());


QString  fullPath( const QString& path);


bool  isFolderPath( const QString& path);


bool  isProviderPath( const QString& path);


QString  itemName( const QString& path);


QString  childPath( const QString& parentPath, const QString& posterityPath);


QString  changeBasePath( const QString& oldBasePath, const QString& newBasePath, const QString& path);


QString  makePath( const QString& parentPath, const QString& itemName);


QString  addPath( const QString& parentPath, const QString& childRelPath,
                         Arn::NameF nameF = Arn::NameF::EmptyOk);


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


QString  parentPath( const QString& path);


QString  twinPath( const QString& path);


QString  providerPathIf( const QString& path, bool giveProviderPath = true);


QString  uuidPath( const QString& path);


QString  makeHostWithInfo( const QString& host, const QString& info);


QString  hostFromHostWithInfo( const QString& hostWithInfo);

bool  isNullPtr( const void* ptr);

uint  rand();

#ifndef DOXYGEN_SKIP
QString  convertBaseName( const QString& name, Arn::NameF nameF);
#endif

}  // Arn::

MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::LinkFlags)
MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::ObjectMode)
MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::ObjectSyncMode)
MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::NameF)
MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::Coding)
MQ_DECLARE_OPERATORS_FOR_FLAGS( Arn::Allow)

#endif // ARN_HPP