VuoList_VuoAudioSamples.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 "VuoAudioSamples.h"
#include "VuoList_VuoAudioSamples.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) VuoAudioSamples_retain(element)
#define RELEASE(element) VuoAudioSamples_release(element)
#endif
 
extern "C" {
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "List of VuoAudioSamples elements",
                     "keywords" : [ ],
                     "version" : "1.0.0",
                     "dependencies" : [
                        "VuoInteger",
                        "VuoAudioSamples"
                     ]
                 });
#endif
}
 
void VuoListDestroy_VuoAudioSamples(void *list);
 
 
VuoList_VuoAudioSamples VuoList_VuoAudioSamples_makeFromJson(json_object * js)
{
    VuoList_VuoAudioSamples list = VuoListCreate_VuoAudioSamples();
 
    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);
            VuoAudioSamples item = VuoAudioSamples_makeFromJson(itemObject);
            VuoListAppendValue_VuoAudioSamples(list, item);
        }
    }
 
    return list;
}
 
json_object * VuoList_VuoAudioSamples_getJson(const VuoList_VuoAudioSamples value)
{
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoAudioSamples(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoAudioSamples item = VuoListGetValue_VuoAudioSamples(value, i);
        json_object *itemObject = VuoAudioSamples_getJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
 
#ifdef VuoAudioSamples_REQUIRES_INTERPROCESS_JSON
struct json_object * VuoList_VuoAudioSamples_getInterprocessJson(const VuoList_VuoAudioSamples value)
{
    json_object *listObject = json_object_new_array();
 
    unsigned long itemCount = VuoListGetCount_VuoAudioSamples(value);
    for (unsigned long i = 1; i <= itemCount; ++i)
    {
        VuoAudioSamples item = VuoListGetValue_VuoAudioSamples(value, i);
        json_object *itemObject = VuoAudioSamples_getInterprocessJson(item);
        json_object_array_add(listObject, itemObject);
    }
 
    return listObject;
}
#endif
 
char * VuoList_VuoAudioSamples_getSummary(const VuoList_VuoAudioSamples value)
{
    if (!value)
        return strdup("Empty list");
 
    const int maxItems = 20;
    const int maxCharacters = 400;
 
    unsigned long itemCount = VuoListGetCount_VuoAudioSamples(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)
    {
        VuoAudioSamples item = VuoListGetValue_VuoAudioSamples(value, i);
        char *itemSummaryCstr = VuoAudioSamples_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_VuoAudioSamples VuoListCreate_VuoAudioSamples(void)
{
    std::vector<VuoAudioSamples> * l = new std::vector<VuoAudioSamples>;
    VuoRegister(l, VuoListDestroy_VuoAudioSamples);
    return reinterpret_cast<VuoList_VuoAudioSamples>(l);
}
 
VuoList_VuoAudioSamples VuoListCreateWithCount_VuoAudioSamples(const unsigned long count, const VuoAudioSamples value)
{
    std::vector<VuoAudioSamples> * l = new std::vector<VuoAudioSamples>(count, value);
    VuoRegister(l, VuoListDestroy_VuoAudioSamples);
    return reinterpret_cast<VuoList_VuoAudioSamples>(l);
}
 
VuoList_VuoAudioSamples VuoListCopy_VuoAudioSamples(const VuoList_VuoAudioSamples list)
{
    if (!list)
        return NULL;
 
    std::vector<VuoAudioSamples> *oldList = (std::vector<VuoAudioSamples> *)list;
 
    std::vector<VuoAudioSamples> *newList = new std::vector<VuoAudioSamples>(*oldList);
    VuoRegister(newList, VuoListDestroy_VuoAudioSamples);
 
    for (std::vector<VuoAudioSamples>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoAudioSamples>(newList);
}
 
void VuoListDestroy_VuoAudioSamples(void *list)
{
    if (!list)
        return;
 
#if 2 != 0
    VuoListRemoveAll_VuoAudioSamples(reinterpret_cast<VuoList_VuoAudioSamples>(list));
#endif
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
    delete l;
}
 
VuoAudioSamples VuoListGetValue_VuoAudioSamples(const VuoList_VuoAudioSamples list, const unsigned long index)
{
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    if (!l || l->size() == 0)
        return VuoAudioSamples_makeFromJson(NULL);
 
    if (index == 0)
        return (*l)[0];
 
    if (index > l->size())
        return (*l)[l->size()-1];
 
    return (*l)[index-1];
}
 
VuoAudioSamples *VuoListGetData_VuoAudioSamples(const VuoList_VuoAudioSamples list)
{
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    if (!l || l->size() == 0)
        return NULL;
 
    return &((*l)[0]);
}
 
void VuoListSetValue_VuoAudioSamples(const VuoList_VuoAudioSamples list, const VuoAudioSamples value, const unsigned long index, bool expandListIfNeeded)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)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
        VuoAudioSamples oldValue = (*l)[clampedIndex];
#endif
        (*l)[clampedIndex] = value;
        RETAIN(value);
        RELEASE(oldValue);
    }
}
 
void VuoListInsertValue_VuoAudioSamples(const VuoList_VuoAudioSamples list, const VuoAudioSamples value, const unsigned long index)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)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_VuoAudioSamples(VuoList_VuoAudioSamples list, const VuoAudioSamples value)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
    RETAIN(value);
    l->insert(l->begin(), value);
}
 
void VuoListAppendValue_VuoAudioSamples(VuoList_VuoAudioSamples list, const VuoAudioSamples value)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
    RETAIN(value);
    l->push_back(value);
}
 
void VuoListExchangeValues_VuoAudioSamples(VuoList_VuoAudioSamples list, const unsigned long indexA, const unsigned long indexB)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)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;
 
    VuoAudioSamples value = (*l)[clampedIndexA];
    (*l)[clampedIndexA] = (*l)[clampedIndexB];
    (*l)[clampedIndexB] = value;
}
 
#ifdef VuoAudioSamples_SUPPORTS_COMPARISON
void VuoListSort_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    size_t size = l->size();
    if (size < 2)
        return;
 
    std::sort(l->begin(), l->end(), VuoAudioSamples_isLessThan);
}
 
bool VuoList_VuoAudioSamples_areEqual(const VuoList_VuoAudioSamples _a, const VuoList_VuoAudioSamples _b)
{
    if (_a == _b)
        return true;
 
    if (!_a || !_b)
        return _a == _b;
 
    std::vector<VuoAudioSamples> *a = (std::vector<VuoAudioSamples> *)_a;
    std::vector<VuoAudioSamples> *b = (std::vector<VuoAudioSamples> *)_b;
    if (a->size() != b->size())
        return false;
 
    for (std::vector<VuoAudioSamples>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
        if (!VuoAudioSamples_areEqual(*ia, *ib))
            return false;
 
    return true;
}
 
bool VuoList_VuoAudioSamples_isLessThan(const VuoList_VuoAudioSamples _a, const VuoList_VuoAudioSamples _b)
{
    if (!_a || !_b)
        return _a < _b;
 
    std::vector<VuoAudioSamples> *a = (std::vector<VuoAudioSamples> *)_a;
    std::vector<VuoAudioSamples> *b = (std::vector<VuoAudioSamples> *)_b;
    if (a->size() < b->size()) return true;
    if (a->size() > b->size()) return false;
 
    for (std::vector<VuoAudioSamples>::iterator ia = a->begin(), ib = b->begin(); ia != a->end(); ++ia, ++ib)
    {
        if (VuoAudioSamples_isLessThan(*ia, *ib)) return true;
        if (VuoAudioSamples_isLessThan(*ib, *ia)) return false;
    }
 
    return false;
}
#endif
 
void VuoListShuffle_VuoAudioSamples(VuoList_VuoAudioSamples list, const double chaos)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)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);
        VuoAudioSamples value = (*l)[i];
        (*l)[i] = (*l)[j];
        (*l)[j] = value;
    }
}
 
void VuoListReverse_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
    std::reverse(l->begin(), l->end());
}
 
VuoList_VuoAudioSamples VuoListSubset_VuoAudioSamples(VuoList_VuoAudioSamples list, const signed long startIndex, const unsigned long itemCount)
{
    if (!list)
        return NULL;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)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<VuoAudioSamples> *newList = new std::vector<VuoAudioSamples>(
                l->begin() + clampedStartIndex,
                l->begin() + clampedEndIndex + 1);
    VuoRegister(newList, VuoListDestroy_VuoAudioSamples);
 
    for (std::vector<VuoAudioSamples>::iterator i = newList->begin(); i != newList->end(); ++i)
        RETAIN(*i);
 
    return reinterpret_cast<VuoList_VuoAudioSamples>(newList);
}
 
#ifdef VuoAudioSamples_SUPPORTS_COMPARISON
VuoList_VuoAudioSamples VuoListRemoveDuplicates_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return NULL;
 
    auto *l = (std::vector<VuoAudioSamples> *)list;
 
    size_t size = l->size();
    if (size == 0)
        return NULL;
 
    auto *newList = new std::vector<VuoAudioSamples>;
    VuoRegister(newList, VuoListDestroy_VuoAudioSamples);
 
    for (auto i = l->begin(); i != l->end(); ++i)
    {
        bool found = false;
        for (auto j = newList->begin(); j != newList->end(); ++j)
            if (VuoAudioSamples_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_VuoAudioSamples>(newList);
}
#endif
 
void VuoListRemoveFirstValue_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->front());
    l->erase(l->begin());
}
 
void VuoListRemoveLastValue_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    if (!l->size())
        return;
 
    RELEASE(l->back());
    l->pop_back();
}
 
void VuoListRemoveAll_VuoAudioSamples(VuoList_VuoAudioSamples list)
{
    if (!list)
        return;
 
    while (VuoListGetCount_VuoAudioSamples(list) > 0)
        VuoListRemoveLastValue_VuoAudioSamples(list);
}
 
void VuoListRemoveValue_VuoAudioSamples(VuoList_VuoAudioSamples list, const unsigned long index)
{
    if (!list)
        return;
 
    if (index == 0)
        return;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
 
    size_t size = l->size();
    if (size == 0 || index > size)
        return;
 
    l->erase(l->begin() + index - 1);
}
 
unsigned long VuoListGetCount_VuoAudioSamples(const VuoList_VuoAudioSamples list)
{
    if (!list)
        return 0;
 
    std::vector<VuoAudioSamples> * l = (std::vector<VuoAudioSamples> *)list;
    return l->size();
}