VuoList_VuoTable.cc

Go to the documentation of this file.

 
// This module is generated by vuo/type/list/generateVariants.sh.
 
extern "C" {
#include "VuoHeap.h"
#include "VuoInteger.h"
#include "VuoText.h"
#include "VuoTable.h"
#include "VuoList_VuoTable.h"
}
#include "type.h"
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
 
 
#if 2 == 0
#define RETAIN(element)
#define RELEASE(element)
#elif 2 == 1
#define RETAIN(element) VuoRetain((void *)element)
#define RELEASE(element) VuoRelease((void *)element)
#elif 2 == 2
#define RETAIN(element) VuoTable_retain(element)
#define RELEASE(element) VuoTable_release(element)
#endif
 
extern "C" {
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "List of VuoTable elements",
                     "keywords" : [ ],
                     "version" : "1.0.0",
                     "dependencies" : [
                        "VuoInteger",
                        "VuoTable"
                     ]
                 });
#endif
}
 
void VuoListDestroy_VuoTable(void *list);
 
 
VuoList_VuoTable VuoList_VuoTable_makeFromJson(json_object * js)
{
    if (!js)
        return nullptr;
 
    VuoList_VuoTable list = VuoListCreate_VuoTable();
 
    if (json_object_get_type(js) == json_type_array)
    {
        int itemCount = json_object_array_length(js);
        for (int i = 0; i < itemCount; ++i)
        {
            json_object *itemObject = json_object_array_get_idx(js, i);
            VuoTable item = VuoTable_makeFromJson(itemObject);
            VuoListAppendValue_VuoTable(list, item);
        }
    }
 
    return list;
}
 
json_object * VuoList_VuoTable_getJson(const VuoList_VuoTable value)
{
    if (!value)
        return nullptr;
 
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoTable(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoTable item = VuoListGetValue_VuoTable(value, i);
        json_object *itemObject = VuoTable_getJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
 
#ifdef VuoTable_REQUIRES_INTERPROCESS_JSON
struct json_object * VuoList_VuoTable_getInterprocessJson(const VuoList_VuoTable value)
{
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoTable(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoTable item = VuoListGetValue_VuoTable(value, i);
        json_object *itemObject = VuoTable_getInterprocessJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
#endif
 
char * VuoList_VuoTable_getSummary(const VuoList_VuoTable value)
{
    const int maxItems = 20;
    const int maxCharacters = 400;
 
    unsigned long itemCount = VuoListGetCount_VuoTable(value);
    if (itemCount == 0)
        return strdup("Empty list");
 
    unsigned long characterCount = 0;
 
    std::ostringstream summary;
    summary << "List containing " << itemCount << " item" << (itemCount == 1 ? "" : "s") << ": <ul>";
    unsigned long i;
    for (i = 1; i <= itemCount && i <= maxItems && characterCount <= maxCharacters; ++i)
    {
        VuoTable item = VuoListGetValue_VuoTable(value, i);
        char *itemSummaryCstr = VuoTable_getSummary(item);
        std::string itemSummary = itemSummaryCstr;
        free(itemSummaryCstr);
        if (itemSummary.length() && itemSummary.find_first_not_of(' ') != std::string::npos)
            summary << "\n<li>" << itemSummary << "</li>";
        else
            summary << "\n<li>&nbsp;</li>";
        characterCount += itemSummary.length();
    }
 
    if (i <= itemCount)
        summary << "\n<li>…</li>";
 
    summary << "</ul>";
 
    return strdup(summary.str().c_str());
}
 
VuoList_VuoTable VuoListCreate_VuoTable(void)
{
    std::vector<VuoTable> * l = new std::vector<VuoTable>;
    VuoRegister(l, VuoListDestroy_VuoTable);
    return reinterpret_cast<VuoList_VuoTable>(l);
}
 
VuoList_VuoTable VuoListCreateWithCount_VuoTable(const unsigned long count, const VuoTable value)
{
    std::vector<VuoTable> * l = new std::vector<VuoTable>(count, value);
    VuoRegister(l, VuoListDestroy_VuoTable);
 
#if 2 != 0
    for (unsigned long i = 0; i < count; ++i)
        RETAIN(value);
#endif
 
    return reinterpret_cast<VuoList_VuoTable>(l);
}
 
VuoList_VuoTable VuoListCopy_VuoTable(const VuoList_VuoTable list)
{
    if (!list)
        return NULL;
 
    std::vector<VuoTable> *oldList = (std::vector<VuoTable> *)list;
 
    std::vector<VuoTable> *newList = new std::vector<VuoTable>(*oldList);
    VuoRegister(newList, VuoListDestroy_VuoTable);
 
    for (std::vector<VuoTable>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoTable>(newList);
}
 
void VuoListDestroy_VuoTable(void *list)
{
    if (!list)
        return;
 
#if 2 != 0
    VuoListRemoveAll_VuoTable(reinterpret_cast<VuoList_VuoTable>(list));
#endif
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
    delete l;
}
 
VuoTable VuoListGetValue_VuoTable(const VuoList_VuoTable list, const unsigned long index)
{
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    if (!l || l->size() == 0)
        return VuoTable_makeFromJson(NULL);
 
    if (index == 0)
        return (*l)[0];
 
    if (index > l->size())
        return (*l)[l->size()-1];
 
    return (*l)[index-1];
}
 
VuoTable *VuoListGetData_VuoTable(const VuoList_VuoTable list)
{
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    if (!l || l->size() == 0)
        return NULL;
 
    return &((*l)[0]);
}
 
void VuoListForeach_VuoTable(const VuoList_VuoTable list, bool (^function)(const VuoTable value))
{
    auto l = reinterpret_cast<const std::vector<VuoTable> *>(list);
 
    if (!l || l->size() == 0)
        return;
 
    for (auto item : *l)
        if (!function(item))
            break;
}
 
void VuoListSetValue_VuoTable(const VuoList_VuoTable list, const VuoTable value, const unsigned long index, bool expandListIfNeeded)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    if (!expandListIfNeeded && l->size() == 0)
        return;
 
    unsigned long clampedIndex = index - 1;
 
    if (index == 0)
        clampedIndex = 0;
 
    if (expandListIfNeeded && clampedIndex >= l->size())
    {
        l->resize(clampedIndex + 1);
        (*l)[clampedIndex] = value;
        RETAIN(value);
    }
    else
    {
        if (index > l->size())
            clampedIndex = l->size() - 1;
 
#if 2 != 0
        VuoTable oldValue = (*l)[clampedIndex];
#endif
        (*l)[clampedIndex] = value;
        RETAIN(value);
        RELEASE(oldValue);
    }
}
 
void VuoListInsertValue_VuoTable(const VuoList_VuoTable list, const VuoTable value, const unsigned long index)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    unsigned long clampedIndex = index - 1;
 
    if (index == 0)
        clampedIndex = 0;
 
    if (index > l->size())
        clampedIndex = l->size() - 1;
 
    RETAIN(value);
    if (index <= l->size())
        l->insert(l->begin() + clampedIndex, value);
    else
        l->push_back(value);
}
 
void VuoListPrependValue_VuoTable(VuoList_VuoTable list, const VuoTable value)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
    RETAIN(value);
    l->insert(l->begin(), value);
}
 
void VuoListAppendValue_VuoTable(VuoList_VuoTable list, const VuoTable value)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
    RETAIN(value);
    l->push_back(value);
}
 
void VuoListExchangeValues_VuoTable(VuoList_VuoTable list, const unsigned long indexA, const unsigned long indexB)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return;
 
    unsigned long clampedIndexA = indexA - 1;
    if (indexA == 0)
        clampedIndexA = 0;
    if (indexA > size)
        clampedIndexA = size - 1;
 
    unsigned long clampedIndexB = indexB - 1;
    if (indexB == 0)
        clampedIndexB = 0;
    if (indexB > size)
        clampedIndexB = size - 1;
 
    VuoTable value = (*l)[clampedIndexA];
    (*l)[clampedIndexA] = (*l)[clampedIndexB];
    (*l)[clampedIndexB] = value;
}
 
#ifdef VuoTable_SUPPORTS_COMPARISON
void VuoListSort_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size < 2)
        return;
 
    std::sort(l->begin(), l->end(), VuoTable_isLessThan);
}
 
bool VuoList_VuoTable_areEqual(const VuoList_VuoTable _a, const VuoList_VuoTable _b)
{
    if (_a == _b)
        return true;
 
    if (!_a || !_b)
        return false;
 
    std::vector<VuoTable> *a = (std::vector<VuoTable> *)_a;
    std::vector<VuoTable> *b = (std::vector<VuoTable> *)_b;
    if (a->size() != b->size())
        return false;
 
    for (std::vector<VuoTable>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
        if (!VuoTable_areEqual(*ia, *ib))
            return false;
 
    return true;
}
 
bool VuoList_VuoTable_isLessThan(const VuoList_VuoTable _a, const VuoList_VuoTable _b)
{
    if (!_a || !_b)
        return _a < _b;
 
    std::vector<VuoTable> *a = (std::vector<VuoTable> *)_a;
    std::vector<VuoTable> *b = (std::vector<VuoTable> *)_b;
    if (a->size() < b->size()) return true;
    if (a->size() > b->size()) return false;
 
    for (std::vector<VuoTable>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
    {
        if (VuoTable_isLessThan(*ia, *ib)) return true;
        if (VuoTable_isLessThan(*ib, *ia)) return false;
    }
 
    return false;
}
#endif
 
void VuoListShuffle_VuoTable(VuoList_VuoTable list, const double chaos)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return;
 
    double clampedChaos = MIN(MAX(chaos,0),1);
    for (unsigned long i = 0; i < size * clampedChaos; ++i)
    {
        unsigned long j = VuoInteger_random(i, size-1);
        VuoTable value = (*l)[i];
        (*l)[i] = (*l)[j];
        (*l)[j] = value;
    }
}
 
void VuoListReverse_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
    std::reverse(l->begin(), l->end());
}
 
VuoList_VuoTable VuoListSubset_VuoTable(VuoList_VuoTable list, const signed long startIndex, const unsigned long itemCount)
{
    if (!list)
        return NULL;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return NULL;
 
    signed long clampedStartIndex = startIndex - 1;
    signed long clampedEndIndex = clampedStartIndex + itemCount - 1;
 
    if (clampedStartIndex < 0)
        clampedStartIndex = 0;
    if (clampedEndIndex >= (signed long)size)
        clampedEndIndex = size - 1;
 
    if (clampedStartIndex > clampedEndIndex)
        return NULL;
 
    std::vector<VuoTable> *newList = new std::vector<VuoTable>(
                l->begin() + clampedStartIndex,
                l->begin() + clampedEndIndex + 1);
    VuoRegister(newList, VuoListDestroy_VuoTable);
 
    for (std::vector<VuoTable>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoTable>(newList);
}
 
#ifdef VuoTable_SUPPORTS_COMPARISON
VuoList_VuoTable VuoListRemoveDuplicates_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return NULL;
 
    auto *l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return NULL;
 
    auto *newList = new std::vector<VuoTable>;
    VuoRegister(newList, VuoListDestroy_VuoTable);
 
    for (auto i = l->begin(); i != l->end(); ++i)
    {
        bool found = false;
        for (auto j = newList->begin(); j != newList->end(); ++j)
            if (VuoTable_areEqual(*i, *j))
            {
                found = true;
                break;
            }
        if (!found)
            newList->push_back(*i);
    }
 
    for (auto i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoTable>(newList);
}
#endif
 
void VuoListRemoveFirstValue_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->front());
    l->erase(l->begin());
}
 
void VuoListRemoveLastValue_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->back());
    l->pop_back();
}
 
void VuoListRemoveAll_VuoTable(VuoList_VuoTable list)
{
    if (!list)
        return;
 
    while (VuoListGetCount_VuoTable(list) > 0)
        VuoListRemoveLastValue_VuoTable(list);
}
 
void VuoListRemoveValue_VuoTable(VuoList_VuoTable list, const unsigned long index)
{
    if (!list)
        return;
 
    if (index == 0)
        return;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
 
    size_t size = l->size();
    if (size == 0 || index > size)
        return;
 
    l->erase(l->begin() + index - 1);
}
 
unsigned long VuoListGetCount_VuoTable(const VuoList_VuoTable list)
{
    if (!list)
        return 0;
 
    std::vector<VuoTable> * l = (std::vector<VuoTable> *)list;
    return l->size();
}