AbstractColumn.h

Go to the documentation of this file.

/***************************************************************************
    File                 : AbstractColumn.h
    Project              : SciDAVis
    Description          : Interface definition for data with column logic
    --------------------------------------------------------------------
    Copyright            : (C) 2007-2009 Tilman Benkert (thzs*gmx.net)
                           (replace * with @ in the email addresses) 

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *  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.                                    *
 *                                                                         *
 *  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 General Public License for more details.                           *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
 *   Boston, MA  02110-1301  USA                                           *
 *                                                                         *
 ***************************************************************************/

#ifndef ABSTRACTCOLUMN_H
#define ABSTRACTCOLUMN_H

#include <QList>
#include <QString>
#include <QDateTime>
#include <QDate>
#include <QTime>
#include "lib/Interval.h"
#include "globals.h"
#include "core/AbstractAspect.h"

class Column;
class AbstractSimpleFilter;
class QStringList;


class AbstractColumn : public AbstractAspect
{
    Q_OBJECT

    public:
        AbstractColumn(const QString& name) : AbstractAspect(name) {}
        virtual ~AbstractColumn() { aboutToBeDestroyed(this);}

        virtual SciDAVis::ColumnDataType dataType() const = 0;
        virtual bool isReadOnly() const { return true; };
        /*
         * This function is most used by tables but can also be used
         * by plots. The column mode specifies how to interpret 
         * the values in the column additional to the data type.
         */ 
        virtual SciDAVis::ColumnMode columnMode() const = 0;

        virtual void setColumnMode(SciDAVis::ColumnMode mode) { Q_UNUSED(mode) };

        virtual bool copy(const AbstractColumn * other) { Q_UNUSED(other) return false; };

        virtual bool copy(const AbstractColumn * source, int source_start, int dest_start, int num_rows) 
        {
            Q_UNUSED(source)
            Q_UNUSED(source_start)
            Q_UNUSED(dest_start)
            Q_UNUSED(num_rows)
            return false; 
        };

        virtual int rowCount() const = 0;
        virtual void insertRows(int before, int count) { Q_UNUSED(before) Q_UNUSED(count) };
        virtual void removeRows(int first, int count) { Q_UNUSED(first) Q_UNUSED(count) };
        virtual SciDAVis::PlotDesignation plotDesignation() const = 0;
        //virtual void setPlotDesignation(SciDAVis::PlotDesignation pd) { Q_UNUSED(pd) };
        virtual void clear() {};
        virtual void notifyReplacement(const AbstractColumn *replacement) { aboutToBeReplaced(this, replacement); }



        virtual bool isInvalid(int row) const { return !Interval<int>(0, rowCount()-1).contains(row); }      
        virtual bool isInvalid(Interval<int> i) const { return !Interval<int>(0, rowCount()-1).contains(i); }    
        virtual QList< Interval<int> > invalidIntervals() const { return QList< Interval<int> >(); }     
        virtual bool isMasked(int row) const { Q_UNUSED(row); return false; }    
        virtual bool isMasked(Interval<int> i) const { Q_UNUSED(i); return false; }
        virtual QList< Interval<int> > maskedIntervals() const { return QList< Interval<int> >(); }      
        virtual void clearValidity() {};
        virtual void clearMasks() {};

        //virtual void setInvalid(Interval<int> i, bool invalid = true) { Q_UNUSED(i) Q_UNUSED(invalid) };
        //virtual void setInvalid(int row, bool invalid = true) { Q_UNUSED(row) Q_UNUSED(invalid) };

        //virtual void setMasked(Interval<int> i, bool mask = true) { Q_UNUSED(i) Q_UNUSED(mask) };
        //virtual void setMasked(int row, bool mask = true) { Q_UNUSED(row) Q_UNUSED(mask) };



        virtual QString formula(int row) const { Q_UNUSED(row); return QString(); }

        virtual QList< Interval<int> > formulaIntervals() const { return QList< Interval<int> >(); }
        //virtual void setFormula(Interval<int> i, QString formula) { Q_UNUSED(i) Q_UNUSED(formula) };
        //virtual void setFormula(int row, QString formula) { Q_UNUSED(row) Q_UNUSED(formula) };
        virtual void clearFormulas() {};
        



        virtual QString textAt(int row) const { Q_UNUSED(row); return ""; }

        //virtual void setTextAt(int row, const QString& new_value) { Q_UNUSED(row) Q_UNUSED(new_value) };

        virtual void replaceTexts(int first, const QStringList& new_values) { Q_UNUSED(first) Q_UNUSED(new_values) };

        virtual QDate dateAt(int row) const { Q_UNUSED(row); return QDate(); };

        //virtual void setDateAt(int row, const QDate& new_value) { Q_UNUSED(row) Q_UNUSED(new_value) };

        virtual QTime timeAt(int row) const { Q_UNUSED(row); return QTime(); };

        //virtual void setTimeAt(int row, const QTime& new_value) { Q_UNUSED(row) Q_UNUSED(new_value) };

        virtual QDateTime dateTimeAt(int row) const { Q_UNUSED(row); return QDateTime(); };

        //virtual void setDateTimeAt(int row, const QDateTime& new_value) { Q_UNUSED(row) Q_UNUSED(new_value) };

        virtual void replaceDateTimes(int first, const QList<QDateTime>& new_values) { Q_UNUSED(first) Q_UNUSED(new_values) };

        virtual double valueAt(int row) const { Q_UNUSED(row); return 0; };

        //virtual void setValueAt(int row, double new_value) { Q_UNUSED(row) Q_UNUSED(new_value) };

        virtual void replaceValues(int first, const QVector<double>& new_values) { Q_UNUSED(first) Q_UNUSED(new_values) };

    signals: 

        void plotDesignationAboutToChange(const AbstractColumn * source); 

        void plotDesignationChanged(const AbstractColumn * source); 

        void modeAboutToChange(const AbstractColumn * source); 

        void modeChanged(const AbstractColumn * source); 

        void dataAboutToChange(const AbstractColumn * source); 

        void dataChanged(const AbstractColumn * source); 

        void aboutToBeReplaced(const AbstractColumn * source, const AbstractColumn* new_col); 

        void rowsAboutToBeInserted(const AbstractColumn * source, int before, int count); 

        void rowsInserted(const AbstractColumn * source, int before, int count); 

        void rowsAboutToBeRemoved(const AbstractColumn * source, int first, int count); 

        void rowsRemoved(const AbstractColumn * source, int first, int count); 
        void maskingAboutToChange(const AbstractColumn * source); 
        void maskingChanged(const AbstractColumn * source); 
        // TODO: Check whether aboutToBeDestroyed is needed 

        void aboutToBeDestroyed(const AbstractColumn * source);

    friend class ColumnPrivate;
    friend class AbstractSimpleFilter;
    friend class SimpleMappingFilter;
    friend class SimpleCopyThroughFilter;
};

#endif