qgsfielddomain.h

Go to the documentation of this file.

/***************************************************************************
    qgsfielddomain.h
    ------------------
    Date                 : January 2022
    Copyright            : (C) 2022 Nyall Dawson
    Email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSFIELDDOMAIN_H
#define QGSFIELDDOMAIN_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
 
class CORE_EXPORT QgsFieldDomain
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == Qgis::FieldDomainType::Coded )
    {
      sipType = sipType_QgsCodedFieldDomain;
    }
    else if ( sipCpp->type() == Qgis::FieldDomainType::Range )
    {
      sipType = sipType_QgsRangeFieldDomain;
    }
    else if ( sipCpp->type() == Qgis::FieldDomainType::Glob )
    {
      sipType = sipType_QgsGlobFieldDomain;
    }
    else
    {
      sipType = 0;
    }
    SIP_END
#endif
 
  public:
 
    QgsFieldDomain( const QString &name,
                    const QString &description,
                    QVariant::Type fieldType );
 
    virtual ~QgsFieldDomain();
 
    virtual QgsFieldDomain *clone() const = 0 SIP_FACTORY;
 
    virtual Qgis::FieldDomainType type() const = 0;
 
    virtual QString typeName() const = 0;
 
    QString name() const { return mName; }
 
    void setName( const QString &name ) { mName = name; }
 
    QString description() const { return mDescription; }
 
    void setDescription( const QString &description ) { mDescription = description; }
 
    QVariant::Type fieldType() const { return mFieldType; }
 
    void setFieldType( QVariant::Type type ) { mFieldType = type; }
 
    Qgis::FieldDomainSplitPolicy splitPolicy() const { return mSplitPolicy; }
 
    void setSplitPolicy( Qgis::FieldDomainSplitPolicy policy ) { mSplitPolicy = policy; }
 
    Qgis::FieldDomainMergePolicy mergePolicy() const { return mMergePolicy; }
 
    void setMergePolicy( Qgis::FieldDomainMergePolicy policy ) { mMergePolicy = policy; }
 
  protected:
 
    QString mName;
    QString mDescription;
 
    QVariant::Type mFieldType = QVariant::Type::String;
    Qgis::FieldDomainSplitPolicy mSplitPolicy = Qgis::FieldDomainSplitPolicy::DefaultValue;
    Qgis::FieldDomainMergePolicy mMergePolicy = Qgis::FieldDomainMergePolicy::DefaultValue;
 
};
 
class CORE_EXPORT QgsCodedValue
{
  public:
 
    QgsCodedValue( const QVariant &code, const QString &value )
      : mCode( code )
      , mValue( value )
    {}
 
    QVariant code() const { return mCode; }
 
    QString value() const { return mValue; }
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsCodedValue: %1 (%2)>" ).arg( sipCpp->code().toString(), sipCpp->value() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
    bool operator==( const QgsCodedValue &other ) const;
    bool operator!=( const QgsCodedValue &other ) const;
 
  private:
 
    QVariant mCode;
    QString mValue;
};
 
 
class CORE_EXPORT QgsCodedFieldDomain : public QgsFieldDomain
{
 
  public:
 
    QgsCodedFieldDomain( const QString &name,
                         const QString &description,
                         QVariant::Type fieldType,
                         const QList<QgsCodedValue> &values );
 
#ifndef SIP_RUN
    QgsCodedFieldDomain( const QgsCodedFieldDomain & ) = delete;
    QgsCodedFieldDomain &operator= ( const QgsCodedFieldDomain & ) = delete;
#endif
 
    Qgis::FieldDomainType type() const override;
    QString typeName() const override;
    QgsCodedFieldDomain *clone() const override SIP_FACTORY;
 
    QList< QgsCodedValue> values() const { return mValues; }
 
    void setValues( const QList< QgsCodedValue> &values ) { mValues = values; }
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsCodedFieldDomain: %1>" ).arg( sipCpp->name() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private:
    QList< QgsCodedValue> mValues;
 
#ifdef SIP_RUN
    QgsCodedFieldDomain( const QgsCodedFieldDomain & );
#endif
};
 
 
class CORE_EXPORT QgsRangeFieldDomain : public QgsFieldDomain
{
 
  public:
 
    QgsRangeFieldDomain( const QString &name,
                         const QString &description,
                         QVariant::Type fieldType,
                         const QVariant &minimum,
                         bool minimumIsInclusive,
                         const QVariant &maximum,
                         bool maximumIsInclusive );
 
#ifndef SIP_RUN
    QgsRangeFieldDomain( const QgsRangeFieldDomain & ) = delete;
    QgsRangeFieldDomain &operator= ( const QgsRangeFieldDomain & ) = delete;
#endif
 
    Qgis::FieldDomainType type() const override;
    QString typeName() const override;
    QgsRangeFieldDomain *clone() const override SIP_FACTORY;
 
    QVariant minimum() const { return mMin; }
 
    void setMinimum( const QVariant &minimum ) { mMin = minimum; }
 
    bool minimumIsInclusive() const { return mMinIsInclusive; }
 
    void setMinimumIsInclusive( bool inclusive ) { mMinIsInclusive = inclusive; }
 
    QVariant maximum() const { return mMax; }
 
    void setMaximum( const QVariant &maximum ) { mMax = maximum; }
 
    bool maximumIsInclusive() const { return mMaxIsInclusive; }
 
    void setMaximumIsInclusive( bool inclusive ) { mMaxIsInclusive = inclusive; }
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsRangeFieldDomain: %1 %2%3, %4%5>" ).arg( sipCpp->name(),
                  sipCpp->minimumIsInclusive() ? QStringLiteral( "[" ) : QStringLiteral( "(" ),
                  sipCpp->minimum().toString(),
                  sipCpp->maximum().toString(),
                  sipCpp->maximumIsInclusive() ? QStringLiteral( "]" ) : QStringLiteral( ")" ) );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private:
    QVariant mMin;
    QVariant mMax;
    bool mMinIsInclusive = false;
    bool mMaxIsInclusive = false;
 
#ifdef SIP_RUN
    QgsRangeFieldDomain( const QgsRangeFieldDomain & );
#endif
};
 
 
class CORE_EXPORT QgsGlobFieldDomain : public QgsFieldDomain
{
 
  public:
 
    QgsGlobFieldDomain( const QString &name,
                        const QString &description,
                        QVariant::Type fieldType,
                        const QString &glob );
 
#ifndef SIP_RUN
    QgsGlobFieldDomain( const QgsGlobFieldDomain & ) = delete;
    QgsGlobFieldDomain &operator= ( const QgsGlobFieldDomain & ) = delete;
#endif
 
    Qgis::FieldDomainType type() const override;
    QString typeName() const override;
    QgsGlobFieldDomain *clone() const override SIP_FACTORY;
 
    QString glob() const { return mGlob; }
 
    void setGlob( const QString &glob ) { mGlob = glob; }
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsGlobFieldDomain: %1 '%2'>" ).arg( sipCpp->name(), sipCpp->glob() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private:
    QString mGlob;
 
#ifdef SIP_RUN
    QgsGlobFieldDomain( const QgsGlobFieldDomain & );
#endif
 
};
 
#endif // QGSFIELDDOMAIN_H