VuoList_VuoInteger.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 "VuoInteger.h"
#include "VuoList_VuoInteger.h"
}
#include "type.h"
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
 
 
#if 0 == 0
#define RETAIN(element)
#define RELEASE(element)
#elif 0 == 1
#define RETAIN(element) VuoRetain((void *)element)
#define RELEASE(element) VuoRelease((void *)element)
#elif 0 == 2
#define RETAIN(element) VuoInteger_retain(element)
#define RELEASE(element) VuoInteger_release(element)
#endif
 
extern "C" {
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "List of VuoInteger elements",
                     "keywords" : [ ],
                     "version" : "1.0.0",
                     "dependencies" : [
                        "VuoInteger",
                        "VuoInteger"
                     ]
                 });
#endif
}
 
void VuoListDestroy_VuoInteger(void *list);
 
 
VuoList_VuoInteger VuoList_VuoInteger_makeFromJson(json_object * js)
{
    VuoList_VuoInteger list = VuoListCreate_VuoInteger();
 
    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);
            VuoInteger item = VuoInteger_makeFromJson(itemObject);
            VuoListAppendValue_VuoInteger(list, item);
        }
    }
 
    return list;
}
 
json_object * VuoList_VuoInteger_getJson(const VuoList_VuoInteger value)
{
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoInteger(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoInteger item = VuoListGetValue_VuoInteger(value, i);
        json_object *itemObject = VuoInteger_getJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
 
#ifdef VuoInteger_REQUIRES_INTERPROCESS_JSON
struct json_object * VuoList_VuoInteger_getInterprocessJson(const VuoList_VuoInteger value)
{
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoInteger(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoInteger item = VuoListGetValue_VuoInteger(value, i);
        json_object *itemObject = VuoInteger_getInterprocessJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
#endif
 
char * VuoList_VuoInteger_getSummary(const VuoList_VuoInteger value)
{
    if (!value)
        return strdup("Empty list");
 
    const int maxItems = 20;
    const int maxCharacters = 400;
 
    unsigned long itemCount = VuoListGetCount_VuoInteger(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)
    {
        VuoInteger item = VuoListGetValue_VuoInteger(value, i);
        char *itemSummaryCstr = VuoInteger_getSummary(item);
        std::string itemSummary = itemSummaryCstr;
        free(itemSummaryCstr);
        if (itemSummary.length() && itemSummary.find_first_not_of(' ') != std::string::npos)
            summary << "<li>" << itemSummary << "</li>";
        else
            summary << "<li>&nbsp;</li>";
        characterCount += itemSummary.length();
    }
 
    if (i <= itemCount)
        summary << "<li>…</li>";
 
    summary << "</ul>";
 
    return strdup(summary.str().c_str());
}
 
VuoList_VuoInteger VuoListCreate_VuoInteger(void)
{
    std::vector<VuoInteger> * l = new std::vector<VuoInteger>;
    VuoRegister(l, VuoListDestroy_VuoInteger);
    return reinterpret_cast<VuoList_VuoInteger>(l);
}
 
VuoList_VuoInteger VuoListCreateWithCount_VuoInteger(const unsigned long count, const VuoInteger value)
{
    std::vector<VuoInteger> * l = new std::vector<VuoInteger>(count, value);
    VuoRegister(l, VuoListDestroy_VuoInteger);
    return reinterpret_cast<VuoList_VuoInteger>(l);
}
 
VuoList_VuoInteger VuoListCopy_VuoInteger(const VuoList_VuoInteger list)
{
    if (!list)
        return NULL;
 
    std::vector<VuoInteger> *oldList = (std::vector<VuoInteger> *)list;
 
    std::vector<VuoInteger> *newList = new std::vector<VuoInteger>(*oldList);
    VuoRegister(newList, VuoListDestroy_VuoInteger);
 
    for (std::vector<VuoInteger>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoInteger>(newList);
}
 
void VuoListDestroy_VuoInteger(void *list)
{
    if (!list)
        return;
 
#if 0 != 0
    VuoListRemoveAll_VuoInteger(reinterpret_cast<VuoList_VuoInteger>(list));
#endif
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
    delete l;
}
 
VuoInteger VuoListGetValue_VuoInteger(const VuoList_VuoInteger list, const unsigned long index)
{
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    if (!l || l->size() == 0)
        return VuoInteger_makeFromJson(NULL);
 
    if (index == 0)
        return (*l)[0];
 
    if (index > l->size())
        return (*l)[l->size()-1];
 
    return (*l)[index-1];
}
 
VuoInteger *VuoListGetData_VuoInteger(const VuoList_VuoInteger list)
{
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    if (!l || l->size() == 0)
        return NULL;
 
    return &((*l)[0]);
}
 
void VuoListForeach_VuoInteger(const VuoList_VuoInteger list, bool (^function)(const VuoInteger value))
{
    auto l = reinterpret_cast<const std::vector<VuoInteger> *>(list);
 
    if (!l || l->size() == 0)
        return;
 
    for (auto item : *l)
        if (!function(item))
            break;
}
 
void VuoListSetValue_VuoInteger(const VuoList_VuoInteger list, const VuoInteger value, const unsigned long index, bool expandListIfNeeded)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)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 0 != 0
        VuoInteger oldValue = (*l)[clampedIndex];
#endif
        (*l)[clampedIndex] = value;
        RETAIN(value);
        RELEASE(oldValue);
    }
}
 
void VuoListInsertValue_VuoInteger(const VuoList_VuoInteger list, const VuoInteger value, const unsigned long index)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)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_VuoInteger(VuoList_VuoInteger list, const VuoInteger value)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
    RETAIN(value);
    l->insert(l->begin(), value);
}
 
void VuoListAppendValue_VuoInteger(VuoList_VuoInteger list, const VuoInteger value)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
    RETAIN(value);
    l->push_back(value);
}
 
void VuoListExchangeValues_VuoInteger(VuoList_VuoInteger list, const unsigned long indexA, const unsigned long indexB)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)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;
 
    VuoInteger value = (*l)[clampedIndexA];
    (*l)[clampedIndexA] = (*l)[clampedIndexB];
    (*l)[clampedIndexB] = value;
}
 
#ifdef VuoInteger_SUPPORTS_COMPARISON
void VuoListSort_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    size_t size = l->size();
    if (size < 2)
        return;
 
    std::sort(l->begin(), l->end(), VuoInteger_isLessThan);
}
 
bool VuoList_VuoInteger_areEqual(const VuoList_VuoInteger _a, const VuoList_VuoInteger _b)
{
    if (_a == _b)
        return true;
 
    if (!_a || !_b)
        return _a == _b;
 
    std::vector<VuoInteger> *a = (std::vector<VuoInteger> *)_a;
    std::vector<VuoInteger> *b = (std::vector<VuoInteger> *)_b;
    if (a->size() != b->size())
        return false;
 
    for (std::vector<VuoInteger>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
        if (!VuoInteger_areEqual(*ia, *ib))
            return false;
 
    return true;
}
 
bool VuoList_VuoInteger_isLessThan(const VuoList_VuoInteger _a, const VuoList_VuoInteger _b)
{
    if (!_a || !_b)
        return _a < _b;
 
    std::vector<VuoInteger> *a = (std::vector<VuoInteger> *)_a;
    std::vector<VuoInteger> *b = (std::vector<VuoInteger> *)_b;
    if (a->size() < b->size()) return true;
    if (a->size() > b->size()) return false;
 
    for (std::vector<VuoInteger>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
    {
        if (VuoInteger_isLessThan(*ia, *ib)) return true;
        if (VuoInteger_isLessThan(*ib, *ia)) return false;
    }
 
    return false;
}
#endif
 
void VuoListShuffle_VuoInteger(VuoList_VuoInteger list, const double chaos)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)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);
        VuoInteger value = (*l)[i];
        (*l)[i] = (*l)[j];
        (*l)[j] = value;
    }
}
 
void VuoListReverse_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
    std::reverse(l->begin(), l->end());
}
 
VuoList_VuoInteger VuoListSubset_VuoInteger(VuoList_VuoInteger list, const signed long startIndex, const unsigned long itemCount)
{
    if (!list)
        return NULL;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)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<VuoInteger> *newList = new std::vector<VuoInteger>(
                l->begin() + clampedStartIndex,
                l->begin() + clampedEndIndex + 1);
    VuoRegister(newList, VuoListDestroy_VuoInteger);
 
    for (std::vector<VuoInteger>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoInteger>(newList);
}
 
#ifdef VuoInteger_SUPPORTS_COMPARISON
VuoList_VuoInteger VuoListRemoveDuplicates_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return NULL;
 
    auto *l = (std::vector<VuoInteger> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return NULL;
 
    auto *newList = new std::vector<VuoInteger>;
    VuoRegister(newList, VuoListDestroy_VuoInteger);
 
    for (auto i = l->begin(); i != l->end(); ++i)
    {
        bool found = false;
        for (auto j = newList->begin(); j != newList->end(); ++j)
            if (VuoInteger_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_VuoInteger>(newList);
}
#endif
 
void VuoListRemoveFirstValue_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->front());
    l->erase(l->begin());
}
 
void VuoListRemoveLastValue_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->back());
    l->pop_back();
}
 
void VuoListRemoveAll_VuoInteger(VuoList_VuoInteger list)
{
    if (!list)
        return;
 
    while (VuoListGetCount_VuoInteger(list) > 0)
        VuoListRemoveLastValue_VuoInteger(list);
}
 
void VuoListRemoveValue_VuoInteger(VuoList_VuoInteger list, const unsigned long index)
{
    if (!list)
        return;
 
    if (index == 0)
        return;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
 
    size_t size = l->size();
    if (size == 0 || index > size)
        return;
 
    l->erase(l->begin() + index - 1);
}
 
unsigned long VuoListGetCount_VuoInteger(const VuoList_VuoInteger list)
{
    if (!list)
        return 0;
 
    std::vector<VuoInteger> * l = (std::vector<VuoInteger> *)list;
    return l->size();
}