mirror of
https://github.com/GothenburgBitFactory/taskwarrior.git
synced 2025-06-26 10:54:26 +02:00
- Integrated new Grid object into build - not yet integrated into Table.
This commit is contained in:
Paul Beckingham
parent
ce52f88f4b
commit
62e6b31a17
15 changed files with 530 additions and 54 deletions
386
src/Grid.cpp
Normal file
386
src/Grid.cpp
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright 2007 - 2008, Paul Beckingham. All rights reserved.
|
||||
//
|
||||
// Grid implements a sparse 2D array of Cell objects. Grid makes every effort
|
||||
// to perform well on cell insertion and retrieval. A Cell is a variant type,
|
||||
// capable of storing char, bool, int, float, double and std::string types.
|
||||
//
|
||||
// Every cell is accessible from both mColumns and mRows. This allows the
|
||||
// client code to specify which method is used, because there will be a
|
||||
// performance penalty with one of the methods, depending on the layout of
|
||||
// cells within the grid.
|
||||
//
|
||||
// mColumns, like mRows, is a vector of a vector of Cell*.
|
||||
//
|
||||
// mColumns
|
||||
// [0..n]
|
||||
// +---+---+-----------+---+
|
||||
// | 0 | 1 | | n |
|
||||
// +---+---+-----------+---+
|
||||
// | |
|
||||
// v |
|
||||
// +---+ . +---+ . | .
|
||||
// mRows | 0 | -------> | x | v
|
||||
// [0..1] +---+ . +---+ +---+
|
||||
// | 1 | -------> | y | --------> | z |
|
||||
// +---+ . +---+ +---+
|
||||
// | |
|
||||
// | |
|
||||
// | |
|
||||
// +---+ . . . . .
|
||||
// | n |
|
||||
// +---+ . . . . .
|
||||
//
|
||||
//
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <iostream>
|
||||
#include <Grid.h>
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
Grid::Grid ()
|
||||
{
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// The cells are deleted via their mRows reference, not by their mColumns
|
||||
// reference. This is because the cells are doubly-linked, and so the
|
||||
// convention is that rows own cells, columns merely own pointers.
|
||||
Grid::~Grid ()
|
||||
{
|
||||
std::vector < std::vector <Cell*>* >::iterator row;
|
||||
std::vector <Cell*>::iterator col;
|
||||
for (row = mRows.begin (); row != mRows.end (); ++row)
|
||||
if (*row)
|
||||
for (col = (*row)->begin (); col != (*row)->end (); ++col)
|
||||
if (*col)
|
||||
delete *col;
|
||||
|
||||
std::vector < std::vector <Cell*>* >::iterator it;
|
||||
for (it = mRows.begin (); it != mRows.end (); ++it)
|
||||
if (*it)
|
||||
delete *it;
|
||||
|
||||
for (it = mColumns.begin (); it != mColumns.end (); ++it)
|
||||
if (*it)
|
||||
delete *it;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const bool value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const char value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const int value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const float value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const double value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
void Grid::add (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
const std::string& value)
|
||||
{
|
||||
expandGrid (row, col);
|
||||
insertCell (row, col, new Cell (value));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
unsigned int Grid::width () const
|
||||
{
|
||||
return mColumns.size ();
|
||||
}
|
||||
|
||||
unsigned int Grid::height () const
|
||||
{
|
||||
return mRows.size ();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
Grid::Cell* Grid::byRow (const unsigned int row, const unsigned int col) const
|
||||
{
|
||||
if (row <= mRows.size () &&
|
||||
mRows[row] != NULL &&
|
||||
col <= mRows[row]->size ())
|
||||
return (*mRows[row])[col];
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Grid::Cell* Grid::byColumn (const unsigned int row, const unsigned int col) const
|
||||
{
|
||||
if (col <= mColumns.size () &&
|
||||
mColumns[col] != NULL &&
|
||||
row <= mColumns[col]->size ())
|
||||
return (*mColumns[col])[row];
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void Grid::expandGrid (const unsigned int row, const unsigned int col)
|
||||
{
|
||||
// If the new row is outside the bounds of the current grid, add blank rows to
|
||||
// pad, then a new row vector.
|
||||
if (row >= mRows.size ())
|
||||
{
|
||||
for (unsigned int r = mRows.size (); r <= row; ++r)
|
||||
if (r < row)
|
||||
// {
|
||||
// std::cout << "additional mRows[" << r << "] = NULL" << std::endl;
|
||||
mRows.push_back (NULL);
|
||||
// }
|
||||
else
|
||||
// {
|
||||
// std::cout << "additional mRows[" << r << "] = new std::vector <Cell*>" << std::endl;
|
||||
mRows.push_back (new std::vector <Cell*>);
|
||||
// }
|
||||
}
|
||||
// If the new row is within the bounds of the current grid, ensure that the
|
||||
// row points to a vector of cells.
|
||||
else if (mRows[row] == NULL)
|
||||
// {
|
||||
// std::cout << "existing mRows[" << row << "] = new std::vector <Cell*>" << std::endl;
|
||||
mRows[row] = new std::vector <Cell*>;
|
||||
// }
|
||||
|
||||
if (col >= mRows[row]->size ())
|
||||
for (unsigned int c = mRows[row]->size (); c <= col; ++c)
|
||||
// {
|
||||
// std::cout << "additional mRows[" << row << "][" << c << "] = NULL" << std::endl;
|
||||
mRows[row]->push_back (NULL);
|
||||
// }
|
||||
|
||||
// If the new col is outside the bounds of the current grid, add blank cols to
|
||||
// pad, then a new col vector.
|
||||
if (col >= mColumns.size ())
|
||||
{
|
||||
for (unsigned int c = mColumns.size (); c <= col; ++c)
|
||||
if (c < col)
|
||||
// {
|
||||
// std::cout << "additional mColumns[" << c << "] = NULL" << std::endl;
|
||||
mColumns.push_back (NULL);
|
||||
// }
|
||||
else
|
||||
// {
|
||||
// std::cout << "additional mColumns[" << c << "] = new std::vector <Cell*>" << std::endl;
|
||||
mColumns.push_back (new std::vector <Cell*>);
|
||||
// }
|
||||
}
|
||||
// If the new col is within the bounds of the current grid, ensure that the
|
||||
// col points to a vector of cells.
|
||||
else if (mColumns[col] == NULL)
|
||||
// {
|
||||
// std::cout << "existing mColumns[" << col << "] = new std::vector <Cell*>" << std::endl;
|
||||
mColumns[col] = new std::vector <Cell*>;
|
||||
// }
|
||||
|
||||
if (row >= mColumns[col]->size ())
|
||||
for (unsigned int r = mColumns[col]->size (); r <= row; ++r)
|
||||
// {
|
||||
// std::cout << "additional mColumns[" << col << "][" << r << "] = NULL" << std::endl;
|
||||
mColumns[col]->push_back (NULL);
|
||||
// }
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void Grid::insertCell (
|
||||
const unsigned int row,
|
||||
const unsigned int col,
|
||||
Cell* cell)
|
||||
{
|
||||
// Delete any existing cell, because cells are owned by rows, not columns.
|
||||
if ((*mRows[row])[col] != NULL)
|
||||
// {
|
||||
// std::cout << "deleted old cell mRows[" << row << "][" << col << "]" << std::endl;
|
||||
delete (*mRows[row])[col];
|
||||
// }
|
||||
|
||||
(*mRows[row])[col] = cell;
|
||||
(*mColumns[col])[row] = cell;
|
||||
// std::cout << "assigned new cell mRows[" << row << "][" << col << "]" << std::endl;
|
||||
// std::cout << "assigned new cell mColumns[" << col << "][" << row << "]" << std::endl;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
Grid::Cell::Cell (const bool value)
|
||||
: mType (CELL_BOOL)
|
||||
, mBool (value)
|
||||
{
|
||||
}
|
||||
|
||||
Grid::Cell::Cell (const char value)
|
||||
: mType (CELL_CHAR)
|
||||
, mChar (value)
|
||||
{
|
||||
}
|
||||
|
||||
Grid::Cell::Cell (const int value)
|
||||
: mType (CELL_INT)
|
||||
, mInt (value)
|
||||
{
|
||||
}
|
||||
|
||||
Grid::Cell::Cell (const float value)
|
||||
: mType (CELL_FLOAT)
|
||||
, mFloat (value)
|
||||
{
|
||||
}
|
||||
|
||||
Grid::Cell::Cell (const double value)
|
||||
: mType (CELL_DOUBLE)
|
||||
, mDouble (value)
|
||||
{
|
||||
}
|
||||
|
||||
Grid::Cell::Cell (const std::string& value)
|
||||
: mType (CELL_STRING)
|
||||
, mString (value)
|
||||
{
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// These cast operators make a best approximation to an appropriate rendering,
|
||||
// given the format change.
|
||||
Grid::Cell::operator bool () const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool;
|
||||
case CELL_CHAR: return mChar != '\0' &&
|
||||
mChar != ' ' &&
|
||||
mChar != '0';
|
||||
case CELL_INT: return mInt != 0;
|
||||
case CELL_FLOAT: return mFloat != 0.0;
|
||||
case CELL_DOUBLE: return mDouble != 0.0;
|
||||
case CELL_STRING: return mString.length () > 0;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
Grid::Cell::operator char () const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool ? 'Y' : 'N';
|
||||
case CELL_CHAR: return mChar;
|
||||
case CELL_INT: return (char) mInt;
|
||||
case CELL_FLOAT: return (char) (int) mFloat;
|
||||
case CELL_DOUBLE: return (char) (int) mDouble;
|
||||
case CELL_STRING: return mString[0];
|
||||
}
|
||||
|
||||
return '\0';
|
||||
}
|
||||
|
||||
Grid::Cell::operator int () const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool ? 1 : 0;
|
||||
case CELL_CHAR: return (int) mChar;
|
||||
case CELL_INT: return mInt;
|
||||
case CELL_FLOAT: return (int) mFloat;
|
||||
case CELL_DOUBLE: return (int) mDouble;
|
||||
case CELL_STRING: return mString.length ();
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Grid::Cell::operator float () const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool ? 1.0 : 0.0;
|
||||
case CELL_CHAR: return (float) (int) mChar;
|
||||
case CELL_INT: return (float) mInt;
|
||||
case CELL_FLOAT: return mFloat;
|
||||
case CELL_DOUBLE: return (float) mDouble;
|
||||
case CELL_STRING: return (float) mString.length ();
|
||||
}
|
||||
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
Grid::Cell::operator double () const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool ? 1.0 : 0.0;
|
||||
case CELL_CHAR: return (double) (int) mChar;
|
||||
case CELL_INT: return (double) mInt;
|
||||
case CELL_FLOAT: return (double) mFloat;
|
||||
case CELL_DOUBLE: return mDouble;
|
||||
case CELL_STRING: return (double) mString.length ();
|
||||
}
|
||||
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
Grid::Cell::operator std::string () const
|
||||
{
|
||||
char s[64] = {0};
|
||||
|
||||
switch (mType)
|
||||
{
|
||||
case CELL_BOOL: return mBool ? "true" : "false";
|
||||
case CELL_CHAR: sprintf (s, "%c", mChar);
|
||||
return std::string (s);
|
||||
case CELL_INT: sprintf (s, "%d", mInt);
|
||||
return std::string (s);
|
||||
case CELL_FLOAT: sprintf (s, "%f", mFloat);
|
||||
return std::string (s);
|
||||
case CELL_DOUBLE: sprintf (s, "%f", mDouble);
|
||||
return std::string (s);
|
||||
case CELL_STRING: return mString;
|
||||
}
|
||||
|
||||
return std::string ("");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
Grid::Cell::cellType Grid::Cell::type () const
|
||||
{
|
||||
return mType;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
Loading…
Add table
Add a link
Reference in a new issue