matrix.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_MATRIX_H
#define WT_MATRIX_H

#include <vector>

#include <sigc++/signal.h>

namespace Wt {
template<typename T>
class Matrix : public std::vector< std::vector<T> > {
public:
    typedef std::vector<T> Edge;
    typedef std::vector<Edge> MatrixBase;

    typedef T value_type;

    class iterator {
    public:
        iterator(Matrix* matrix_p = 0, int row = 0, int column = 0) :
                m_(matrix_p),
                row_(row),
        column_(column) {
            if (matrix_p) {
                if (row_ >= m_->numRows())
                    row_ = -1;
                if (column_ >= m_->numCols())
                    column_ = -1;
            }
        }
        bool operator==(const iterator& other) const {
            return (other.column_ == column_) && (other.row_ == row_);
        }
        bool operator!=(const iterator& other) const {
            return !(*this == other);
        }
        iterator& operator++() {
            const Matrix& matrix = *m_;
            if (column_ < matrix.numCols() - 1) {
                ++column_;
            } else {
                // end of column
                if (row_ < matrix.numRows() - 1) {
                    // advance row
                    ++row_;
                    column_ = 0;
                } else {
                    // end()
                    row_ = -1;
                    column_ = -1;
                }
            }
            return *this;
        }

        T& operator*() const {
            Matrix& matrix = *m_;
            T& t = matrix[row_][column_];
            return t;
        }
        T *operator->() const {
            Matrix& matrix = *m_;
            T* t = &matrix[row_][column_];
            return t;
        }

        int row() const {
            return row_;
        }

        int column() const {
            return column_;
        }

    private:
        Matrix *m_;
        int row_;
        int column_;
    };

class const_iterator : public iterator {
    public:
        const_iterator(const Matrix* matrix_p = 0,
                       int row = 0, int column = 0) :
        iterator(const_cast<Matrix*>(matrix_p), row, column) {}

        const_iterator(const iterator& other) :
        iterator(other) {}
    };

    Matrix() :
            rows_(0),
    columns_(0) {}

    int numRows() const {
        return rows_;
    }

    int numCols() const {
        return columns_;
    }

    bool empty() const {
        return !rows_ && !columns_;
    }

    iterator begin() {
        return iterator(this);
    }

    iterator end() {
        return iterator(this, -1, -1);
    }

    const_iterator begin() const {
        return const_iterator(this);
    }

    const_iterator end() const {
        return const_iterator(this, -1, -1);
    }

    T& operator()(int r, int c) {
        const int old_rows = rows_;
        const int old_cols = columns_;
        int i;

        if (r >= old_rows) {
            MatrixBase& m = *this;
            m.resize(r + 1);
            rows_ = r + 1;
        }

        const int new_columns = std::max(c + 1, columns_);
        for (i = 0; i < rows_; i++) {
            (*this)[i].resize(new_columns);
        }

        if (c >= columns_) {
            columns_ = c + 1;
        }

        if (rows_ != old_rows || columns_ != old_cols) {
            gridSizeChanged.emit(old_rows, old_cols, rows_, columns_);
        }
        Matrix& self = *this;
        return self[r][c];
    }

    void push_back(const T& t) {
        Matrix& self = *this;
        int r, c;
        if (!rows_) {
            // start the matrix
            r = 0;
            c = 0;
        } else if (rows_ == 1) {
            // in the first line we keep adding columns
            r = 0;
            c = columns_;
        } else {
            int j;
            // we try to find the first empty item after the last non empty
            // if we can't find it before the end of the row we open a new row
            for (j = 0; j < columns_ &&
                self[rows_ - 1][columns_ - 1 - j] == T(); j++) {}
            if (j == 0) {
                // this row is full, open new row
                r = rows_;
                c = 0;
            } else if (j == columns_) {
                // this row is empty, go at at start;
                r = rows_ - 1;
                c = 0;
            } else {
                r = rows_ - 1;
                c = columns_ - j;
            }
        }

        self(r, c) = t;
    }

    iterator erase(iterator it) {
        *it = T();
        adjust();
        return ++it;
    }

    iterator find(iterator start, iterator finish, const T& t) const {
        iterator it = start;
        for (; it != finish; ++it) {
            if (t == *it)
                break;
        }
        return (it != finish) ? it : end();
    }

    void remove
        (const T& t) {
        iterator it = begin();
        iterator e = end();
        while (it != e) {
            if (t == *it)
                it = erase(it);
            else
                ++it;
        }
    }

    sigc::signal4<void, int, int, int, int> gridSizeChanged;

protected:
    bool isRowEmpty(int row) {
        bool empty = true;

        for (int c = 0; c < columns_; c++) {
            Matrix& self = *this;
            T empty_item;
            if (empty_item != self[row][c]) {
                empty = false;
                break;
            }
        }
        return empty;
    }

    bool isColumnEmpty(int column) {
        bool empty = true;

        for (int r = 0; r < rows_; r++) {
            Matrix& self = *this;
            T empty_item;
            if (empty_item != self[r][column]) {
                empty = false;
                break;
            }
        }
        return empty;
    }

    void adjust() {
        const int old_rows = rows_;
        const int old_cols = columns_;
        int row_max, col_max;

        //first find non empty row starting from end
        for (row_max = rows_ - 1; row_max >= 0 &&
            isRowEmpty(row_max); row_max--) {}

        //now the max column starting from end
        for (col_max = columns_ - 1; col_max >= 0 &&
            isColumnEmpty(col_max); col_max--) {}

        if (row_max < rows_ - 1 || col_max < columns_ - 1) {
            MatrixBase& m = *this;
            m.resize(row_max + 1);
            rows_ = row_max + 1;

            if (col_max < columns_ - 1) {
                for (int r = 0; r < rows_; r++) {
                    (*this)[r].resize(col_max + 1);
                }
            }
            columns_ = col_max + 1;
        }
        if (rows_ != old_rows || columns_ != old_cols) {
            gridSizeChanged.emit(old_rows, old_cols, rows_, columns_);
        }
    }

private:
    int rows_;
    int columns_;
};

} // namespace

#endif // WT_MATRIX_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.