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>

typedef QList<int> QgsAttributeList;

class QgsExpression;

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;

    bool convertCompatible( QVariant& v ) const;

  private:

    QString mName;

    QVariant::Type mType;

    QString mTypeName;

    int mLength;

    int mPrecision;

    QString mComment;

}; // class QgsField


class CORE_EXPORT QgsFields
{
  public:

    enum FieldOrigin
    {
      OriginUnknown,   
      OriginProvider,  
      OriginJoin,      
      OriginEdit,      
      OriginExpression 
    };

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

      bool operator==( const Field& other ) const { return field == other.field && origin == other.origin && originIndex == other.originIndex; }
      bool operator!=( const Field& other ) const { return !( *this == other ); }

      QgsField field;      
      FieldOrigin origin;  
      int originIndex;     
    } Field;

    void clear();
    bool append( const QgsField& field, FieldOrigin origin = OriginProvider, int originIndex = -1 );
    bool appendExpressionField( const QgsField& field, int originIndex );
    void remove( int fieldIdx );
    void extend( const QgsFields& other );

    inline bool isEmpty() const { return mFields.isEmpty(); }
    inline int count() const { return mFields.count(); }
    inline int size() const { return mFields.count(); }
    inline bool exists( int i ) const { return i >= 0 && i < mFields.count(); }

    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; }
    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 ); }

    int fieldNameIndex( const QString& fieldName ) const;

    QgsAttributeList allAttributesList() const;

    QList<QgsField> toList() const;

    bool operator==( const QgsFields& other ) const { return mFields == other.mFields; }
    bool operator!=( const QgsFields& other ) const { return !( *this == other ); }

  protected:
    QVector<Field> mFields;

    QHash<QString, int> mNameToIndex;
};




#endif