src/core/qgsfield.h

Go to the documentation of this file.

/***************************************************************************
               qgsfield.h - Describes a field in a layer or table
                     --------------------------------------
               Date                 : 01-Jan-2004
               Copyright            : (C) 2004 by Gary E.Sherman
               email                : sherman at mrcc.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 QGSFIELD_H
#define QGSFIELD_H

#include <QString>
#include <QVariant>
#include <QVector>

class CORE_EXPORT QgsField
{
  public:
    QgsField( QString name = QString(),
              QVariant::Type type = QVariant::Invalid,
              QString typeName = QString(),
              int len = 0,
              int prec = 0,
              QString comment = QString() );

    ~QgsField();

    bool operator==( const QgsField& other ) const;
    bool operator!=( const QgsField& other ) const;

    const QString & name() const;

    QVariant::Type type() const;

    const QString & typeName() const;


    int length() const;


    int precision() const;

    const QString & comment() const;

    void setName( const QString & nam );

    void setType( QVariant::Type type );

    void setTypeName( const QString & typ );

    void setLength( int len );

    void setPrecision( int prec );


    void setComment( const QString & comment );

    QString displayString( const QVariant& v ) const;

  private:

    QString mName;

    QVariant::Type mType;

    QString mTypeName;

    int mLength;

    int mPrecision;

    QString mComment;

}; // class QgsField

// key = field index, value=field data
typedef QMap<int, QgsField> QgsFieldMap;



class CORE_EXPORT QgsFields
{
  public:

    enum FieldOrigin { OriginUnknown, OriginProvider, OriginJoin, OriginEdit };
    typedef struct Field
    {
      Field(): origin( OriginUnknown ), originIndex( -1 ) {}
      Field( const QgsField& f, FieldOrigin o, int oi ): field( f ), origin( o ), originIndex( oi ) {}

      QgsField field;
      FieldOrigin origin; // TODO[MD]: originIndex or QVariant originID?
      int originIndex;
    } Field;

    void clear() { mFields.clear(); mNameToIndex.clear(); }
    bool append( const QgsField& field, FieldOrigin origin = OriginProvider, int originIndex = -1 )
    {
      if ( mNameToIndex.contains( field.name() ) )
        return false;

      if ( originIndex == -1 && origin == OriginProvider )
        originIndex = mFields.count();
      mFields.append( Field( field, origin, originIndex ) );

      mNameToIndex.insert( field.name(), mFields.count() - 1 );
      return true;
    }
    void remove( int fieldIdx ) { mNameToIndex.remove( mFields[fieldIdx].field.name() ); mFields.remove( fieldIdx ); }

    inline bool isEmpty() const { return mFields.isEmpty(); }
    inline int count() const { return mFields.count(); }
    inline int size() const { return mFields.count(); } // TODO[MD]: delete?
    void extend( const QgsFields& other )
    {
      for ( int i = 0; i < other.count(); ++i )
      {
        append( other.at( i ), other.fieldOrigin( i ), other.fieldOriginIndex( i ) );
      }
    }
    inline const QgsField& operator[]( int i ) const { return mFields[i].field; }
    inline QgsField& operator[]( int i ) { return mFields[i].field; }
    const QgsField& at( int i ) const { return mFields[i].field; }
    QList<QgsField> toList() const { QList<QgsField> lst; for ( int i = 0; i < mFields.count(); ++i ) lst.append( mFields[i].field ); return lst; } // TODO[MD]: delete?

    const QgsField& field( int fieldIdx ) const { return mFields[fieldIdx].field; }
    const QgsField& field( const QString& name ) const { return mFields[ indexFromName( name )].field; }
    FieldOrigin fieldOrigin( int fieldIdx ) const { return mFields[fieldIdx].origin; }
    int fieldOriginIndex( int fieldIdx ) const { return mFields[fieldIdx].originIndex; }

    int indexFromName( const QString& name ) const { return mNameToIndex.value( name, -1 ); }

  protected:
    QVector<Field> mFields;

    QHash<QString, int> mNameToIndex;
};


#endif