ColumnPrivate.h

Go to the documentation of this file.

 
 
#ifndef COLUMNPRIVATE_H
#define COLUMNPRIVATE_H
 
#include <QObject>
#include "lib/IntervalAttribute.h"
#include "core/column/Column.h"
class AbstractSimpleFilter;
class QString;
 
 
class Column::Private
{
    public:
        Private(Column * owner, SciDAVis::ColumnMode mode);
        ~Private();
        Private(Column * owner, SciDAVis::ColumnDataType type, SciDAVis::ColumnMode mode, 
                void * data, IntervalAttribute<bool> validity);
 
        SciDAVis::ColumnDataType dataType() const { return d_data_type; };
        bool isReadOnly() const { return false; };
 
        SciDAVis::ColumnMode columnMode() const { return d_column_mode; };
 
        void setColumnMode(SciDAVis::ColumnMode mode, AbstractFilter *conversion_filter);
 
 
        bool copy(const AbstractColumn * other);
 
        bool copy(const AbstractColumn * source, int source_start, int dest_start, int num_rows);
 
        bool copy(const Private * other);
 
        bool copy(const Private * source, int source_start, int dest_start, int num_rows);
 
        int rowCount() const;
 
        void resizeTo(int new_size);
        void insertRows(int before, int count);
        void removeRows(int first, int count);
        QString name() const;
        QString comment() const;
        SciDAVis::PlotDesignation plotDesignation() const { return d_plot_designation; };
        void setPlotDesignation(SciDAVis::PlotDesignation pd);
        void clear();
        void * dataPointer() const { return d_data; }
        AbstractSimpleFilter* inputFilter() const { return d_input_filter; }
        AbstractSimpleFilter* outputFilter() const { return d_output_filter; }
 
        void replaceModeData(SciDAVis::ColumnMode mode, SciDAVis::ColumnDataType type, void * data,
            AbstractSimpleFilter *in_filter, AbstractSimpleFilter *out_filter, IntervalAttribute<bool> validity);
        void replaceData(void * data, IntervalAttribute<bool> validity);
        IntervalAttribute<bool> validityAttribute() { return d_validity; }
        IntervalAttribute<bool> maskingAttribute() { return d_masking; }
        void replaceMasking(IntervalAttribute<bool> masking); 
        IntervalAttribute<QString> formulaAttribute() { return d_formulas; }
        void replaceFormulas(IntervalAttribute<QString> formulas); 
 
 
        bool isInvalid(int row) const { return d_validity.isSet(row); }      
        bool isInvalid(Interval<int> i) const { return d_validity.isSet(i); }    
        QList< Interval<int> > invalidIntervals() const { return d_validity.intervals(); }   
        bool isMasked(int row) const { return d_masking.isSet(row); }    
        bool isMasked(Interval<int> i) const { return d_masking.isSet(i); }
        QList< Interval<int> > maskedIntervals() const { return d_masking.intervals(); }     
        void clearValidity();
        void clearMasks();
 
        void setInvalid(Interval<int> i, bool invalid = true);
        void setInvalid(int row, bool invalid = true);
 
        void setMasked(Interval<int> i, bool mask = true);
        void setMasked(int row, bool mask = true);
 
 
        QString formula(int row) const { return d_formulas.value(row); }
 
        QList< Interval<int> > formulaIntervals() const { return d_formulas.intervals(); }
        void setFormula(Interval<int> i, QString formula);
        void setFormula(int row, QString formula);
        void clearFormulas();
        
 
 
        QString textAt(int row) const;
 
        void setTextAt(int row, const QString& new_value);
 
        void replaceTexts(int first, const QStringList& new_values);
 
        QDate dateAt(int row) const;
 
        void setDateAt(int row, const QDate& new_value);
 
        QTime timeAt(int row) const;
 
        void setTimeAt(int row, const QTime& new_value);
 
        QDateTime dateTimeAt(int row) const;
 
        void setDateTimeAt(int row, const QDateTime& new_value);
 
        void replaceDateTimes(int first, const QList<QDateTime>& new_values);
        double valueAt(int row) const;
 
        void setValueAt(int row, double new_value);
 
        void replaceValues(int first, const QVector<qreal>& new_values);
 
    private:
 
 
        SciDAVis::ColumnDataType d_data_type;
 
        SciDAVis::ColumnMode d_column_mode;
 
        void * d_data;
        AbstractSimpleFilter* d_input_filter;
        AbstractSimpleFilter* d_output_filter;
        IntervalAttribute<bool> d_validity;
        IntervalAttribute<bool> d_masking;
        IntervalAttribute<QString> d_formulas;
        SciDAVis::PlotDesignation d_plot_designation;
        Column * d_owner;
        
};
 
#endif