MQFlags.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.
//
// The MIT License (MIT) Usage
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this file to deal in its contained Software without restriction,
// including without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software in this file.
//
// 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 MQFLAGS_HPP
#define MQFLAGS_HPP

#include "ArnLib_global.hpp"
#include "MQFlagsBase.hpp"
#include <QMap>
#include <QStringList>
#include <QObject>
#include <QDebug>

#define MQ_NSTXT_FILL_MISSING   0, 0
#define MQ_NSTXT_FILL_MISSING_FROM( FromNs)   FromNs, 0


#define MQ_DECLARE_FLAGSTXT( FEStruct) \
    MQ_DECLARE_FLAGS( FEStruct) \
    static Arn::EnumTxt&  txt()  {static Arn::EnumTxt in( &staticMetaObject, true, _setNs(0), _setSe(0), \
                                                          #FEStruct); return in;} \
    inline static const Arn::_InitEnumTxt* _setNs( const Arn::_InitEnumTxt* ieTxt)  {return ieTxt;} \
    inline static const Arn::_InitSubEnum* _setSe( const Arn::_InitSubEnum* isEnum) {return isEnum;} \
    inline static const char*  name()  {return txt().name();} \
    inline QString  toString( quint16 nameSpace = 0)  const {return txt().flagsToString( f, nameSpace);} \
    inline static FEStruct  fromString( const QString& text, quint16 nameSpace = 0) \
      {return FEStruct( F( txt().flagsFromString( text, nameSpace)));}


#define MQ_DECLARE_FLAGS_NSTXT(...) \
    static const Arn::_InitEnumTxt* _setNs(int dummy) { \
        Q_UNUSED(dummy) \
        static Arn::_InitEnumTxt  initTxt[] = { __VA_ARGS__ , { 0, 0, arnNullptr }}; \
        return initTxt; \
    };

#define MQ_DECLARE_SUBETXT(...) \
    static const Arn::_InitSubEnum* _setSe( int dummy) { \
        Q_UNUSED(dummy) \
        static Arn::_InitSubEnum  initSubEnum[] = { __VA_ARGS__ , { arnNullptr, 0, 0 }}; \
        return initSubEnum; \
    };

#define MQ_SUBETXT_ADD_RELDEF( EStruct, Mask, Factor) \
    { &EStruct::txt(), Mask, Factor}

#define MQ_SUBETXT_ADD_ABSDEF( EStruct, Mask) \
    MQ_SUBETXT_ADD_RELDEF( EStruct, Mask, 1)

#define MQ_SUBETXT_ADD_RELOP( EStruct, Mask, Factor) \
    inline void  setSubEnum( EStruct::E v_) { \
        setBits( Mask, v_ * Factor); \
    } \
    inline EStruct::E  getSubEnum_##EStruct() { \
        return EStruct::E( (f & Mask) / Factor); \
    }

#define MQ_SUBETXT_ADD_ABSOP( EStruct, Mask) \
    MQ_SUBETXT_ADD_RELOP( EStruct, Mask, 1) \


#define MQ_DECLARE_ENUMTXT( EStruct) \
    MQ_DECLARE_ENUM( EStruct) \
    static Arn::EnumTxt&  txt()  {static Arn::EnumTxt in( &staticMetaObject, false, _setNs(0), arnNullptr, \
                                                          #EStruct); return in;} \
    inline static const Arn::_InitEnumTxt* _setNs( const Arn::_InitEnumTxt* ieTxt) {return ieTxt;} \
    inline static const char*  name()  {return txt().name();} \
    inline QString  toString( quint16 nameSpace = 0)  const {return txt().getTxtString( e, nameSpace);} \
    inline static EStruct  fromString( const QString& text, quint16 nameSpace = 0) \
      {return EStruct( E( txt().getEnumVal( text, 0, nameSpace)));}


#define MQ_DECLARE_ENUM_NSTXT(...) \
    static const Arn::_InitEnumTxt* _setNs(int dummy) { \
        Q_UNUSED(dummy) \
        static Arn::_InitEnumTxt  initTxt[] = { __VA_ARGS__ , { 0, 0, 0 }}; \
        return initTxt; \
    };


namespace Arn {
class XStringMap;
class EnumTxt;
}

struct QMetaObject;


namespace Arn {

typedef struct {
    int  ns;
    int  enumVal;
    const char*  enumTxt;
} _InitEnumTxt;

typedef struct {
    EnumTxt*  enumTxtClass;
    uint  mask;
    uint  factor;
} _InitSubEnum;




class EnumTxt
{
public:
    struct IncludeMode {
        enum E {
            OnlySingle1Bits,
            OnlyMulti1Bits,  // Also include number 0 (no 1 bits at all)
            OnlySubEnumBits,
            AnyButSubEnumBits,
            Any
        };
        MQ_DECLARE_ENUM( IncludeMode)
    };

    EnumTxt( const QMetaObject* metaObj, bool isFlag, const _InitEnumTxt* initTxt, const _InitSubEnum* initSubEnum,
             const char* name);


    explicit EnumTxt( bool isFlag = false, const QString& name = QString());

    ~EnumTxt();

    void  setTxtRef( const char* txt, int enumVal, quint16 nameSpace);


    void  setTxt( const char* txt, int enumVal, quint16 nameSpace);


    const char*  getTxt( int enumVal, quint16 nameSpace = 0, bool* isFound = arnNullptr)  const;


    void  setTxtString( const QString& txt, int enumVal, quint16 nameSpace);


    QString  getTxtString( int enumVal, quint16 nameSpace = 0, bool* isFound = arnNullptr)  const;


    int  getEnumVal( const char* txt, int defaultVal = 0, quint16 nameSpace = 0, bool* isFound = arnNullptr)  const;


    int  getEnumVal( const QString& txt, int defaultVal = 0, quint16 nameSpace = 0, bool* isFound = arnNullptr)  const;


    bool  getSubEnumVal( const char* txt, int& subEnumVal, uint& bitMask, quint16 nameSpace = 0)  const;


    bool  getSubEnumVal( const QString& txt, int& subEnumVal, uint& bitMask, quint16 nameSpace = 0)  const;


    void  addFlagsTo( Arn::XStringMap& xsm, const IncludeMode& incMode, quint16 nameSpace = 0, bool neverHumanize = false)  const;


    void  addSubEnumTo( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const;


    void  addBitSetTo( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const;

    void  addBitSet( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const  // Legacy
          {addBitSetTo( xsm, nameSpace, neverHumanize);}


    QString  getBitSet( quint16 nameSpace = 0, bool neverHumanize = false)  const;


    void  addSubEnumPlainTo( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const;


    QString  flagsToString( int val, quint16 nameSpace = 0)  const;


    QStringList  flagsToStringList( int val, quint16 nameSpace = 0)  const;


    int  flagsFromString( const QString& flagString, quint16 nameSpace = 0);


    int  flagsFromStringList( const QStringList& flagStrings, quint16 nameSpace = 0);


    void  addEnumSetTo( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const;

    void  addEnumSet( Arn::XStringMap& xsm, quint16 nameSpace = 0, bool neverHumanize = false)  const  // Legacy
          {addEnumSetTo( xsm, nameSpace, neverHumanize);}


    QString  getEnumSet( quint16 nameSpace = 0, bool neverHumanize = false)  const;


    QStringList  getBasicTextList( quint16 nameSpace = 0, bool neverHumanize = false)  const;


    void  addSubEnum( const EnumTxt& subEnum, uint bitMask, uint factor);


    const char*  name()  const;


    int  enumCount()  const;


    void  setMissingTxt( quint16 toNameSpace, quint16 fromNameSpace = 0, bool neverHumanize = false);


    static QString  humanize( const QString& txt);


    bool  isFlag()  const;


    void  clear();


    bool  loadEnumSet( const Arn::XStringMap& xsm, const QString& name = QString());


    bool  loadEnumSet( const QString& xstr, const QString& name = QString());


    bool  loadBitSet( const Arn::XStringMap& xsm, const QString& name = QString());


    bool  loadBitSet( const QString& xstr, const QString& name = QString());


    int  subEnumCount()  const;


    QString  subEnumNameAt( int idx, quint16 nameSpace = 0)  const;


    bool  subEnumPropAt( int idx, uint& bitMask, uchar& bitPos)  const;


    const EnumTxt*  subEnumAt( int idx)  const;

    static QByteArray  numToStr( uint num);
    static uint  strToNum( const QByteArray& str, bool* isOk = arnNullptr);
    static uchar strToBitpos( const QByteArray& str, bool* isOk = arnNullptr);

private:
    struct EnumTxtKey {
        uint  _enumVal;
        quint16  _nameSpace;
        bool  _isFlag;
        bool  _isSingleBit;  // Only for flags

        EnumTxtKey( uint enumVal, quint16 nameSpace, bool isFlag);
        bool  operator <( const EnumTxtKey& other)  const;
    };
    struct SubEnumEntry {
        const EnumTxt* _subEnum;
        uint  _bitMask;
        uchar  _bitPos;
        bool  _isLocalOwn;
        SubEnumEntry( const EnumTxt& subEnum, uint bitMask, uint factor, bool isLocalOwn);
    };

    void  setTxtRefAny( const char* txt, int enumVal, quint16 nameSpace);
    void  addSubEnumAny( const EnumTxt& subEnum, uint bitMask, uint factor, bool isLocalOwn);
    void  setupFromMetaObject();
    void  setupTxt( const _InitEnumTxt* initTxt);
    void  setupSubEnum( const _InitSubEnum* initSubEnum);

    const QMetaObject*  _metaObj;
    QMap<EnumTxtKey,const char*>  _enumTxtTab;
    QList<QByteArray>*  _txtStore;
    QList<SubEnumEntry>*  _subEnumTab;
    QByteArray  _name;
    uint _subEnumMask;
    bool  _isFlag;
};

}

#endif // MQFLAGS_HPP