VuoTable.cc

Go to the documentation of this file.

 
#include <sstream>
#include <vector>
using namespace std;
 
#include "type.h"
 
extern "C"
{
#include "VuoTable.h"
#include "VuoTime.h"
 
#include <csv.h>
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                      "title" : "Table",
                      "description" : "Information structured in rows and columns.",
                      "keywords" : [ ],
                      "version" : "1.0.0",
                      "dependencies" : [
                          "VuoList_VuoTable",
                          "VuoTableFormat",
                          "VuoTextSort",
                          "VuoSortOrder",
                          "VuoText",
                          "VuoList_VuoText",
                          "VuoTime",
                          "csv"
                      ]
                  });
#endif
}
 
static void deleteData(void *data)
{
    delete (vector< vector<VuoText> > *)data;
}
 
 
VuoTable VuoTable_makeFromJson(struct json_object *js)
{
    json_object *o;
    if (json_object_object_get_ex(js, "pointer", &o))
    {
        VuoTable table = { NULL, 0, 0 };
 
        table.data = (void *)json_object_get_int64(o);
        if (! table.data)
        {
            table.data = new vector< vector<VuoText> >;
            VuoRegister(table.data, deleteData);
        }
 
        if (json_object_object_get_ex(js, "rowCount", &o))
            table.rowCount = (size_t)json_object_get_int64(o);
 
        if (json_object_object_get_ex(js, "columnCount", &o))
            table.columnCount = (size_t)json_object_get_int64(o);
 
        return table;
    }
    else if (json_object_object_get_ex(js, "csv", &o))
    {
        const char *tableAsCsv = json_object_get_string(o);
 
        return VuoTable_makeFromText(tableAsCsv, VuoTableFormat_Csv);
    }
 
    return VuoTable_makeEmpty();
}
 
struct json_object * VuoTable_getJson(const VuoTable value)
{
    json_object *js = json_object_new_object();
 
    json_object_object_add(js, "pointer", json_object_new_int64((int64_t)value.data));
    json_object_object_add(js, "rowCount", json_object_new_int64((int64_t)value.rowCount));
    json_object_object_add(js, "columnCount", json_object_new_int64((int64_t)value.columnCount));
 
    return js;
}
 
struct json_object * VuoTable_getInterprocessJson(const VuoTable value)
{
    json_object *js = json_object_new_object();
 
    VuoText tableAsCsv = VuoTable_serialize(value, VuoTableFormat_Csv);
    json_object_object_add(js, "csv", json_object_new_string(tableAsCsv));
    VuoRetain(tableAsCsv);
    VuoRelease(tableAsCsv);
 
    return js;
}
 
char * VuoTable_getSummary(const VuoTable value)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)value.data;
 
    const size_t maxTableRows = 4;     // not counting ellipsis
    const size_t maxTableColumns = 4;  //
 
    ostringstream oss;
    oss << "<table>";
 
    for (size_t i = 0; i < value.rowCount && i < maxTableRows; ++i)
    {
        oss << "<tr>";
 
        for (size_t j = 0; j < value.columnCount && j < maxTableColumns; ++j)
        {
            const char *dataValue = "";
            if (i < (*data).size() && j < (*data)[i].size() && (*data)[i][j])
                dataValue = (*data)[i][j];
            oss << "<td>" << dataValue << "</td>";
        }
 
        if (value.columnCount > maxTableColumns)
            oss << "<td>…</td>";
 
        oss << "</tr>";
    }
 
    if (value.rowCount > maxTableRows)
    {
        size_t ellipsisColumn = (value.columnCount > maxTableColumns ? 1 : 0);
        oss << "<tr><td colspan=\"" << MIN(value.columnCount, maxTableColumns + ellipsisColumn) << "\">…</td></tr>";
    }
 
    oss << "</table>";
 
    return VuoText_format("%lu row%s, %lu column%s<br>%s",
                          value.rowCount, value.rowCount == 1 ? "" : "s",
                          value.columnCount, value.columnCount == 1 ? "" : "s",
                          oss.str().c_str());
}
 
 
VuoTable VuoTable_makeEmpty(void)
{
    VuoTable table = { new vector< vector<VuoText> >, 0, 0 };
    VuoRegister(table.data, deleteData);
    return table;
}
 
 
class ParserContext
{
public:
 
    vector< vector<VuoText> > *tableData;
    bool atFirstColumn;
 
    bool taken;  
 
    ParserContext(void)
    {
        tableData = new vector< vector<VuoText> >;
        atFirstColumn = true;
        taken = false;
    }
 
    ~ParserContext(void)
    {
        if (! taken)
            delete tableData;
    }
};
 
static void parserGotItem(void *item, size_t numBytes, void *userData)
{
    VuoText itemText = VuoText_makeFromData((unsigned char *)item, numBytes);
    ParserContext *ctx = (ParserContext *)userData;
 
    if (ctx->atFirstColumn)
    {
        ctx->tableData->push_back( vector<VuoText>() );
        ctx->atFirstColumn = false;
    }
 
    ctx->tableData->back().push_back(itemText);
}
 
static void parserGotLine(int lineEnd, void *userData)
{
    ParserContext *ctx = (ParserContext *)userData;
 
    ctx->atFirstColumn = true;
}
 
VuoTable VuoTable_makeFromText(VuoText text, VuoTableFormat format)
{
    struct csv_parser parser;
    unsigned char options = CSV_APPEND_NULL;
 
    int ret = csv_init(&parser, options);
    if (ret)
    {
        VUserLog("Error: Couldn't initialize CSV/TSV parser.");
        return VuoTable_makeEmpty();
    }
 
    if (format == VuoTableFormat_Tsv)
        csv_set_delim(&parser, CSV_TAB);
 
    ParserContext ctx;
 
    size_t numBytes = VuoText_byteCount(text);
    size_t numBytesParsed = csv_parse(&parser, text, numBytes, parserGotItem, parserGotLine, &ctx);
    if (numBytesParsed != numBytes)
    {
        VUserLog("Error: Couldn't parse CSV/TSV text: %s", csv_strerror(csv_error(&parser)));
        csv_free(&parser);
        return VuoTable_makeEmpty();
    }
 
    ret = csv_fini(&parser, parserGotItem, parserGotLine, &ctx);
    if (ret)
    {
        VUserLog("Error: Couldn't parse CSV/TSV text (or finalize parser): %s", csv_strerror(csv_error(&parser)));
        csv_free(&parser);
        return VuoTable_makeEmpty();
    }
 
    csv_free(&parser);
    ctx.taken = true;
 
    size_t rowCount = ctx.tableData->size();
    size_t columnCount = 0;
    for (vector< vector<VuoText> >::iterator i = ctx.tableData->begin(); i != ctx.tableData->end(); ++i)
        columnCount = MAX((*i).size(), columnCount);
 
    VuoTable table = { (void *)ctx.tableData, rowCount, columnCount };
    VuoRegister(table.data, deleteData);
    return table;
}
 
 
VuoText VuoTable_serialize(VuoTable table, VuoTableFormat format)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    // Calculate the sizes of the strings to be written.
 
    vector< vector<size_t> > srcBytesForData( (*data).size() );
    vector< vector<size_t> > dstBytesForData( (*data).size() );
    size_t dstBytesTotal = 0;
 
    for (size_t i = 0; i < table.rowCount; ++i)
    {
        if (i < (*data).size())
        {
            srcBytesForData[i].resize( (*data)[i].size() );
            dstBytesForData[i].resize( (*data)[i].size() );
        }
 
        for (size_t j = 0; j < table.columnCount; ++j)
        {
            if (i < (*data).size() && j < (*data)[i].size())
            {
                srcBytesForData[i][j] = VuoText_byteCount( (*data)[i][j] );
                dstBytesForData[i][j] = csv_write(NULL, 0, (*data)[i][j], srcBytesForData[i][j]);
                dstBytesTotal += dstBytesForData[i][j];
            }
 
            ++dstBytesTotal;  // delimiter or newline
        }
    }
 
    // Write the strings.
 
    char delimiter = (format == VuoTableFormat_Tsv ? CSV_TAB : CSV_COMMA);
    char newline = '\n';
 
    char *dst = (char *)malloc(dstBytesTotal);
    char *dstPtr = dst;
 
    for (size_t i = 0; i < table.rowCount; ++i)
    {
        for (size_t j = 0; j < table.columnCount; ++j)
        {
            if (i < (*data).size() && j < (*data)[i].size())
            {
                size_t numBytesWritten = csv_write(dstPtr, dstBytesForData[i][j], (*data)[i][j], srcBytesForData[i][j]);
                dstPtr += numBytesWritten;
            }
 
            *dstPtr = (j+1 < table.columnCount ? delimiter : newline);
            ++dstPtr;
        }
    }
 
    if (dstPtr > dst)
        --dstPtr;
    *dstPtr = 0;
 
    VuoText text = VuoText_make(dst);
    free(dst);
    return text;
}
 
 
static VuoInteger getIndexForHeader(VuoTable table, VuoText header, bool isColumnHeader)
{
    if (VuoText_isEmpty(header))
        return 0;
 
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    VuoTextComparison containsCaseInsensitive = {VuoTextComparison_Contains, false};
 
    if (isColumnHeader)
    {
        for (size_t i = 0; i < table.columnCount; ++i)
            if (! (*data).empty() && i < (*data)[0].size() && VuoText_compare((*data)[0][i], containsCaseInsensitive, header))
                return i+1;
    }
    else
    {
        for (size_t i = 0; i < table.rowCount; ++i)
            if (i < (*data).size() && ! (*data)[i].empty() && VuoText_compare((*data)[i][0], containsCaseInsensitive, header))
                return i+1;
    }
 
    return 0;
}
 
static VuoInteger getClampedIndex(VuoTable table, VuoInteger index, bool isColumnIndex)
{
    VuoInteger maxIndex = (isColumnIndex ? table.columnCount : table.rowCount);  // converts from size_t to VuoInteger
    return MAX(1, MIN(maxIndex, index));
}
 
 
struct ColumnSort
{
 
    VuoTextSort sortType;
    VuoSortOrder sortOrder;
 
    bool operator() (pair<size_t, VuoText> first, pair<size_t, VuoText> second)
    {
        if (sortOrder == VuoSortOrder_Descending)
            swap(first, second);
 
        if (sortType == VuoTextSort_TextCaseSensitive)
            return VuoText_isLessThan(first.second, second.second);
        else if (sortType == VuoTextSort_Number)
            return VuoText_isLessThanNumeric(first.second, second.second);
        else if (sortType == VuoTextSort_Date)
        {
            VuoTime firstTime = VuoTime_makeFromUnknownFormat(first.second);
            VuoTime secondTime = VuoTime_makeFromUnknownFormat(second.second);
            return VuoTime_isLessThan(firstTime, secondTime);
        }
        else
            return VuoText_isLessThanCaseInsensitive(first.second, second.second);
    }
};
 
VuoTable VuoTable_sort_VuoInteger(VuoTable table, VuoInteger columnIndex, VuoTextSort sortType, VuoSortOrder sortOrder, bool firstRowIsHeader)
{
    columnIndex = getClampedIndex(table, columnIndex, true);  // indexed from 1
    size_t firstDataRow = (firstRowIsHeader ? 1 : 0);  // indexed from 0
 
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    vector< pair<size_t, VuoText> > keyColumn;
    for (size_t i = firstDataRow; i < table.rowCount; ++i)
    {
        if (i < (*data).size() && columnIndex-1 < (*data)[i].size())
            keyColumn.push_back( make_pair(i, (*data)[i][columnIndex-1]) );
        else
            keyColumn.push_back( make_pair(i, "") );
    }
 
    ColumnSort columnSort;
    columnSort.sortType = sortType;
    columnSort.sortOrder = sortOrder;
    stable_sort(keyColumn.begin(), keyColumn.end(), columnSort);
 
    if (firstRowIsHeader)
        keyColumn.insert(keyColumn.begin(), make_pair(0, "") );
 
    vector< vector<VuoText> > *sortedData = new vector< vector<VuoText> >(table.rowCount);
    for (size_t i = 0; i < table.rowCount; ++i)
        (*sortedData)[i].resize(table.columnCount);
 
    for (size_t i = 0; i < table.rowCount; ++i)
        for (size_t j = 0; j < table.columnCount; ++j)
            if (i < (*data).size() && j < (*data)[i].size())
                (*sortedData)[i][j] = (*data)[ keyColumn[i].first ][j];
 
    VuoTable sortedTable = { sortedData, table.rowCount, table.columnCount };
    VuoRegister(sortedData, deleteData);
    return sortedTable;
}
 
VuoTable VuoTable_sort_VuoText(VuoTable table, VuoText columnHeader, VuoTextSort sortType, VuoSortOrder sortOrder, bool firstRowIsHeader)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return table;
 
    return VuoTable_sort_VuoInteger(table, columnIndex, sortType, sortOrder, firstRowIsHeader);
}
 
 
VuoTable VuoTable_transpose(VuoTable table)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    vector< vector<VuoText> > *transposedData = new vector< vector<VuoText> >(table.columnCount);
    for (size_t i = 0; i < table.columnCount; ++i)
        (*transposedData)[i].resize(table.rowCount);
 
    for (size_t i = 0; i < table.rowCount; ++i)
        for (size_t j = 0; j < table.columnCount; ++j)
            if (i < (*data).size() && j < (*data)[i].size())
                (*transposedData)[j][i] = (*data)[i][j];
 
    VuoTable transposedTable = { transposedData, table.columnCount, table.rowCount };
    VuoRegister(transposedData, deleteData);
    return transposedTable;
}
 
 
VuoList_VuoText VuoTable_getRow_VuoInteger(VuoTable table, VuoInteger rowIndex, bool includeHeader)
{
    if (table.rowCount == 0)
        return VuoListCreate_VuoText();
 
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    rowIndex = getClampedIndex(table, rowIndex, false);
 
    size_t startIndex = (includeHeader ? 0 : 1);
    size_t count = table.columnCount - startIndex;
 
    VuoList_VuoText row = VuoListCreateWithCount_VuoText(count, NULL);
    for (size_t i = startIndex; i < table.columnCount; ++i)
        if (rowIndex-1 < (*data).size() && i < (*data)[rowIndex-1].size())
            VuoListSetValue_VuoText(row, (*data)[rowIndex-1][i], i+1-startIndex, false);
 
    return row;
}
 
VuoList_VuoText VuoTable_getRow_VuoText(VuoTable table, VuoText rowHeader, bool includeHeader)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    if (rowIndex == 0)
        return VuoListCreate_VuoText();
 
    return VuoTable_getRow_VuoInteger(table, rowIndex, includeHeader);
}
 
VuoList_VuoText VuoTable_getColumn_VuoInteger(VuoTable table, VuoInteger columnIndex, bool includeHeader)
{
    if (table.rowCount == 0)
        return VuoListCreate_VuoText();
 
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
 
    columnIndex = getClampedIndex(table, columnIndex, true);
 
    size_t startIndex = (includeHeader ? 0 : 1);
    size_t count = table.rowCount - startIndex;
 
    VuoList_VuoText column = VuoListCreateWithCount_VuoText(count, NULL);
    for (size_t i = startIndex; i < table.rowCount; ++i)
        if (i < (*data).size() && columnIndex-1 < (*data)[i].size())
            VuoListSetValue_VuoText(column, (*data)[i][columnIndex-1], i+1-startIndex, false);
 
    return column;
}
 
VuoList_VuoText VuoTable_getColumn_VuoText(VuoTable table, VuoText columnHeader, bool includeHeader)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return VuoListCreate_VuoText();
 
    return VuoTable_getColumn_VuoInteger(table, columnIndex, includeHeader);
}
 
VuoText VuoTable_getItem_VuoInteger_VuoInteger(VuoTable table, VuoInteger rowIndex, VuoInteger columnIndex)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
    if ((*data).empty())
        return NULL;
 
    rowIndex = getClampedIndex(table, rowIndex, false);
    columnIndex = getClampedIndex(table, columnIndex, true);
 
    return (*data)[rowIndex-1][columnIndex-1];
}
 
VuoText VuoTable_getItem_VuoInteger_VuoText(VuoTable table, VuoInteger rowIndex, VuoText columnHeader)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return NULL;
 
    return VuoTable_getItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex);
}
 
VuoText VuoTable_getItem_VuoText_VuoInteger(VuoTable table, VuoText rowHeader, VuoInteger columnIndex)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    if (rowIndex == 0)
        return NULL;
 
    return VuoTable_getItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex);
}
 
VuoText VuoTable_getItem_VuoText_VuoText(VuoTable table, VuoText rowHeader, VuoText columnHeader)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (rowIndex == 0 || columnIndex == 0)
        return NULL;
 
    return VuoTable_getItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex);
}
 
VuoTable VuoTable_addRow(VuoTable table, VuoListPosition position, VuoList_VuoText values)
{
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    vector< vector<VuoText> >::iterator rowIter;
    size_t rowIndex;
    if (position == VuoListPosition_Beginning)
    {
        rowIter = (*data).begin();
        rowIndex = 0;
    }
    else
    {
        rowIter = (*data).end();
        rowIndex = table.rowCount;
    }
 
    unsigned long count = VuoListGetCount_VuoText(values);
    VuoText *rowArray = VuoListGetData_VuoText(values);
 
    (*data).insert(rowIter, vector<VuoText>(count));
    for (unsigned long i = 0; i < count; ++i)
        (*data)[rowIndex][i] = rowArray[i];
 
    VuoTable newTable = { data, table.rowCount + 1, MAX(table.columnCount, count) };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoTable VuoTable_addColumn(VuoTable table, VuoListPosition position, VuoList_VuoText values)
{
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    unsigned long count = VuoListGetCount_VuoText(values);
    VuoText *columnArray = VuoListGetData_VuoText(values);
 
    if ((*data).size() < count)
        (*data).resize(count);
 
    for (size_t i = 0; i < count; ++i)
    {
        if (position == VuoListPosition_End && (*data)[i].size() < table.columnCount)
            (*data)[i].resize(table.columnCount);
 
        vector<VuoText>::iterator columnIter = (position == VuoListPosition_Beginning ? (*data)[i].begin() : (*data)[i].end());
        (*data)[i].insert(columnIter, columnArray[i]);
    }
 
    VuoTable newTable = { data, MAX(table.rowCount, count), table.columnCount + 1 };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoTable VuoTable_changeRow_VuoInteger(VuoTable table, VuoInteger rowIndex, VuoList_VuoText newValues, bool preserveHeader)
{
    if (table.rowCount == 0)
        return table;
 
    rowIndex = getClampedIndex(table, rowIndex, false);
 
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    unsigned long newValuesCount = VuoListGetCount_VuoText(newValues);
    VuoText *rowArray = VuoListGetData_VuoText(newValues);
 
    size_t firstDataIndex = (preserveHeader ? 1 : 0);
 
    (*data)[rowIndex-1].resize(newValuesCount+firstDataIndex);
 
    if (preserveHeader && ! (*origData)[rowIndex-1].empty())
        (*data)[rowIndex-1][0] = (*origData)[rowIndex-1][0];
 
    for (size_t i = 0; i < newValuesCount; ++i)
        (*data)[rowIndex-1][i+firstDataIndex] = rowArray[i];
 
    VuoTable newTable = { data, table.rowCount, MAX(table.columnCount, newValuesCount+firstDataIndex) };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoTable VuoTable_changeRow_VuoText(VuoTable table, VuoText rowHeader, VuoList_VuoText newValues, bool preserveHeader)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    if (rowIndex == 0)
        return table;
 
    return VuoTable_changeRow_VuoInteger(table, rowIndex, newValues, preserveHeader);
}
 
VuoTable VuoTable_changeColumn_VuoInteger(VuoTable table, VuoInteger columnIndex, VuoList_VuoText newValues, bool preserveHeader)
{
    if (table.columnCount == 0)
        return table;
 
    columnIndex = getClampedIndex(table, columnIndex, true);
 
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    unsigned long newValuesCount = VuoListGetCount_VuoText(newValues);
    VuoText *columnArray = VuoListGetData_VuoText(newValues);
 
    size_t firstDataIndex = (preserveHeader ? 1 : 0);
 
    if ((*data).size() < newValuesCount+firstDataIndex)
        (*data).resize(newValuesCount+firstDataIndex);
 
    for (size_t i = 0; i < newValuesCount+firstDataIndex; ++i)
        if ((*data)[i].size() < columnIndex)
            (*data)[i].resize(columnIndex);
 
    if (preserveHeader && (*origData)[0].size() > columnIndex-1)
        (*data)[0][columnIndex-1] = (*origData)[0][columnIndex-1];
 
    for (size_t i = 0; i < MAX(table.rowCount-firstDataIndex, newValuesCount); ++i)
        (*data)[i+firstDataIndex][columnIndex-1] = (i < newValuesCount ? columnArray[i] : NULL);
 
    VuoTable newTable = { data, MAX(table.rowCount, newValuesCount+firstDataIndex), table.columnCount };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoTable VuoTable_changeColumn_VuoText(VuoTable table, VuoText columnHeader, VuoList_VuoText newValues, bool preserveHeader)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return table;
 
    return VuoTable_changeColumn_VuoInteger(table, columnIndex, newValues, preserveHeader);
}
 
VuoTable VuoTable_changeItem_VuoInteger_VuoInteger(VuoTable table, VuoInteger rowIndex, VuoInteger columnIndex, VuoText newValue)
{
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    if ((*origData).empty())
        return table;
 
    rowIndex = getClampedIndex(table, rowIndex, false);
    columnIndex = getClampedIndex(table, columnIndex, true);
 
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
    (*data)[rowIndex-1][columnIndex-1] = newValue;
 
    VuoTable newTable = { data, table.rowCount, table.columnCount };
    VuoRegister(newTable.data, deleteData);
    return newTable;
 
}
 
VuoTable VuoTable_changeItem_VuoInteger_VuoText(VuoTable table, VuoInteger rowIndex, VuoText columnHeader, VuoText newValue)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return table;
 
    return VuoTable_changeItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex, newValue);
}
 
VuoTable VuoTable_changeItem_VuoText_VuoInteger(VuoTable table, VuoText rowHeader, VuoInteger columnIndex, VuoText newValue)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    if (rowIndex == 0)
        return table;
 
    return VuoTable_changeItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex, newValue);
}
 
VuoTable VuoTable_changeItem_VuoText_VuoText(VuoTable table, VuoText rowHeader, VuoText columnHeader, VuoText newValue)
{
    VuoInteger rowIndex = getIndexForHeader(table, rowHeader, false);
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (rowIndex == 0 || columnIndex == 0)
        return table;
 
    return VuoTable_changeItem_VuoInteger_VuoInteger(table, rowIndex, columnIndex, newValue);
}
 
VuoTable VuoTable_removeRow(VuoTable table, VuoListPosition position)
{
    if (table.rowCount == 0)
        return table;
 
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    vector< vector<VuoText> >::iterator rowIter = (position == VuoListPosition_Beginning ? (*data).begin() : (*data).end() - 1);
    (*data).erase(rowIter);
 
    VuoTable newTable = { data, table.rowCount - 1, table.columnCount };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoTable VuoTable_removeColumn(VuoTable table, VuoListPosition position)
{
    if (table.columnCount == 0)
        return table;
 
    vector< vector<VuoText> > *origData = (vector< vector<VuoText> > *)table.data;
    vector< vector<VuoText> > *data = new vector< vector<VuoText> >(*origData);
 
    for (size_t i = 0; i < table.rowCount; ++i)
    {
        if (position == VuoListPosition_End && (*data)[i].size() < table.columnCount)
            continue;
 
        vector<VuoText>::iterator columnIter = (position == VuoListPosition_Beginning ? (*data)[i].begin() : (*data)[i].end() - 1);
        (*data)[i].erase(columnIter);
    }
 
    VuoTable newTable = { data, table.rowCount, table.columnCount - 1 };
    VuoRegister(newTable.data, deleteData);
    return newTable;
}
 
VuoList_VuoText VuoTable_findFirstMatchingRow_VuoInteger(VuoTable table, VuoInteger columnIndex, VuoText valueToFind, VuoTextComparison valueComparison, bool includeHeader)
{
    if (table.rowCount == 0)
        return nullptr;
 
    auto rows = static_cast<vector<vector<VuoText>>*>(table.data);
 
    columnIndex = getClampedIndex(table, columnIndex, true);
 
    auto foundRow = find_if(rows->begin(), rows->end(), [columnIndex, valueComparison, valueToFind](vector<VuoText> row) {
        return VuoText_compare(row[columnIndex - 1], valueComparison, valueToFind);
    });
 
    if (foundRow == rows->end())
        return nullptr;
 
    size_t startIndex = (includeHeader ? 0 : 1);
    size_t count = foundRow->size() - startIndex;
 
    VuoList_VuoText outputRow = VuoListCreateWithCount_VuoText(count, NULL);
    for (size_t i = startIndex; i < table.columnCount; ++i)
        VuoListSetValue_VuoText(outputRow, (*foundRow)[i], i + 1 - startIndex, false);
 
    return outputRow;
}
 
VuoList_VuoText VuoTable_findFirstMatchingRow_VuoText(VuoTable table, VuoText columnHeader, VuoText valueToFind, VuoTextComparison valueComparison, bool includeHeader)
{
    VuoInteger columnIndex = getIndexForHeader(table, columnHeader, true);
    if (columnIndex == 0)
        return nullptr;
 
    return VuoTable_findFirstMatchingRow_VuoInteger(table, columnIndex, valueToFind, valueComparison, includeHeader);
}
 
void VuoTable_retain(VuoTable table)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
    for (vector< vector<VuoText> >::iterator i = data->begin(); i != data->end(); ++i)
        for (vector<VuoText>::iterator j = i->begin(); j != i->end(); ++j)
            VuoRetain(*j);
 
    VuoRetain(table.data);
}
 
void VuoTable_release(VuoTable table)
{
    vector< vector<VuoText> > *data = (vector< vector<VuoText> > *)table.data;
    for (vector< vector<VuoText> >::iterator i = data->begin(); i != data->end(); ++i)
        for (vector<VuoText>::iterator j = i->begin(); j != i->end(); ++j)
            VuoRelease(*j);
 
    VuoRelease(table.data);
}