RNBO: common/RNBO_List.h Source File

 #ifndef _RNBO_LIST_H_
 #define _RNBO_LIST_H_
  
 #include "RNBO_Types.h"
 #include "RNBO_PlatformInterface.h"
  
 #ifdef RNBO_NOSTDLIB
 #include "RNBO_UniquePtr.h"
 #else
 #include <memory>
 #endif // RNBO_NOSTDLIB
  
 namespace RNBO {
  
     static const size_t listChunkSize = 8;
  
     template<typename T> class listbase {
     public:
  
         listbase()
         : length(0)
         , _values(nullptr)
         , _allocatedLength(0)
         {
             allocate(length, false);
         }
  
         template<typename... Ts> listbase(Ts ... args)
         : length(sizeof...(args))
         , _values(nullptr)
         , _allocatedLength(0)
         {
             allocate(length, false);
             T listValues[sizeof...(args)] = {static_cast<T>(args)...};
             for (size_t i = 0; i < length; i++) {
                 _values[i] = listValues[i];
             }
         }
  
         listbase(const listbase &l)
         : length(l.length)
         , _values(nullptr)
         , _allocatedLength(0)
         {
             allocate(length, false);
             for (size_t i = 0; i < length; i++) {
                 _values[i] = l._values[i];
             }
         }
  
         listbase(listbase&& l)
         : length(l.length)
         , _values(l._values)
         , _allocatedLength(l._allocatedLength)
         {
             l._allocatedLength = 0;
             l._values = nullptr;
         }
  
         ~listbase()
         {
             if (_values) {
                 Platform::get()->free(_values);
                 _values = nullptr;
             }
         }
  
         T& operator[](size_t i) {
             if (i >= length) {
                 Platform::get()->errorOrDefault(RuntimeError::OutOfRange, "list index out of range", false /*unused*/);
                 _dummy = static_cast<T>(0);
                 return _dummy;
             }
             return _values[i];
         }
  
         T operator[](size_t i) const {
             if (i >= length) {
                 return Platform::get()->errorOrDefault(RuntimeError::OutOfRange, "list index out of range", 0);
             }
             return _values[i];
         }
  
         listbase* operator->() {
             return this;
         }
  
         const listbase* operator->() const {
             return this;
         }
  
         listbase& operator=(const listbase& l)
         {
             if (&l != this) {
                 length = l.length;
                 allocate(length, false);
                 for (size_t i = 0; i < length; i++) {
                     _values[i] = l._values[i];
                 }
             }
             return *this;
         }
  
         void push(T item) {
             allocate(length + 1, true);
             _values[length] = item;
             length++;
         }
  
         T pop() {
             T tmp = 0;
             if (length > 0) {
                 tmp = _values[length - 1];
                 length--;
             }
             return tmp;
         }
  
         T shift() {
             if (length == 0) {
                 return Platform::get()->errorOrDefault(RuntimeError::OutOfRange, "cannot shift out of empty list", 0);
             }
             T tmp = _values[0];
             Platform::get()->memmove(_values, _values + 1, (length - 1) * sizeof(T));
             length--;
             return tmp;
         }
  
         listbase concat(T item) const {
             listbase tmp(*this);
             tmp.push(item);
             return tmp;
         }
  
         listbase concat(const listbase& item) const {
             listbase tmp(*this);
             tmp.allocate(tmp.length + item.length, true);
             for (size_t i = 0; i < item.length; i++) {
                 tmp._values[tmp.length] = item[i];
                 tmp.length++;
             }
  
             return tmp;
         }
  
         listbase& fill(T value, size_t start = 0, size_t end = 0)
         {
             if (end == 0) end = length;
             allocate(end, true);
             if (end > length) length = end;
             for (size_t i = start; i < end; i++) {
                 _values[i] = value;
             }
  
             return *this;
         }
  
         template<typename... Ts> void unshift(Ts ... args) {
             splice(0, 0, args...);
         }
  
         template<typename... Ts> listbase<T> splice(Int start, size_t deleteCount, Ts ... args)
         {
             if (start < 0) start += length;
             if (start < 0) start = 0;
             size_t iStart = (size_t)start;
             if (iStart >= length) {
                 deleteCount = 0;
                 iStart = length;
             }
  
             if (iStart + deleteCount > length) deleteCount = length - iStart;
  
             const size_t addLength = sizeof...(args);
             const long diff = (long)(addLength - deleteCount);
  
             listbase<T> deletedItems;
             deletedItems.allocate(deleteCount, false);
             for (size_t i = 0; i < deleteCount; i++) {
                 deletedItems.push(_values[iStart + i]);
             }
  
             long newLength = (long)(length) + diff;
             if (newLength <= 0) {
                 length = 0;
                 return deletedItems;
             }
  
             allocate(static_cast<size_t>(newLength), true);
  
             if (diff < 0) {
                 for (long i = (long)start - diff; i < (long)length; i++) {
                     _values[i + diff] = _values[i];
                 }
             } else if (diff > 0) {
                 for (long i = (long)(length - 1); i >= (long)start; i--) {
                     _values[i + diff] = _values[i];
                 }
             }
  
             // since allocating an array of 0 length is invalid, we always allocate at least length 1
             T addValues[(sizeof...(args)) + 1] = {static_cast<T>(args)...};
             for (size_t i = 0; i < addLength; i++) {
                 _values[i + start] = addValues[i];
             }
  
             length = static_cast<size_t>(newLength);
  
             return deletedItems;
         }
  
         listbase slice(int start = 0, int end = 0) const {
             listbase tmp;
             int ilen = static_cast<int>(this->length);
  
             //negative is offset from end
             if (start < 0) {
                 start = ilen + start;
                 if (start < 0) {
                     start = 0;
                 }
             }
  
             //offset from end
             if (end <= 0) {
                 end = ilen + end;
             }
  
             //bounds check
             if (start >= ilen || ilen == 0) {
                 return tmp;
             }
             if (end > ilen) {
                 end = ilen;
             }
  
             //allocate and copy
             tmp.allocate(static_cast<size_t>(end - start), false);
             for (int i = start; i < end; i++) {
                 tmp._values[tmp.length] = _values[i];
                 tmp.length++;
             }
  
             return tmp;
         }
  
         bool includes(T value, int fromIndex = 0) const {
             if (fromIndex < 0) {
                 fromIndex = int(length) + fromIndex;
                 if (fromIndex < 0) fromIndex = 0;
             }
  
             for (size_t i = size_t(fromIndex); i < length; i++) {
                 if (_values[i] == value) return true;
             }
  
             return false;
         }
  
         int indexOf(T value, int fromIndex = 0) const {
             if (fromIndex < 0) {
                 fromIndex = int(length) + fromIndex;
                 if (fromIndex < 0) fromIndex = 0;
             }
  
             for (size_t i = size_t(fromIndex); i < length; i++) {
                 if (_values[i] == value) return (int)i;
             }
  
             return -1;
         }
  
         listbase& reverse() {
             size_t len2 = length >> 1;
  
             for (size_t i = 0; i < len2; ++i) {
                 T tmp = _values[i];
                 size_t target = length - i - 1;
                 _values[i] = _values[target];
                 _values[target] = tmp;
             }
  
             return *this;
         }
  
         void reserve(size_t size) {
             allocate(size, true);
         }
  
         size_t  length = 0;
  
         T* inner() const { return _values; }
  
     protected:
         void allocate(size_t size, bool keepValues)
         {
             if (size > _allocatedLength) {
                 T *old_values = _values;
  
                 _allocatedLength = listChunkSize + (size_t(size/listChunkSize)) * listChunkSize;
                 _values = (T*) Platform::get()->malloc(sizeof(T) * _allocatedLength);
  
                 if (keepValues) {
                     Platform::get()->memcpy(_values, old_values, length * sizeof(T));
                 }
  
                 if (old_values) {
                     Platform::get()->free(old_values);
                 }
             }
         }
  
         T*  _values;
  
         size_t  _allocatedLength;
  
         T _dummy = static_cast<T>(0);
     };
  
     using list = listbase<number>;
     using indexlist = listbase<Index>;
     using intlist = listbase<int>;
  
  
     class ListNum {
     public:
         ListNum()
         : _val()
         {}
  
         ListNum(number val)
         : _val(val)
         {}
  
         ListNum(list val)
         : _val(val)
         {}
  
         operator number() const { return _val.length > 0 ? _val[0] : 0; }
         operator list() const { return _val; }
  
         list& operator->() {
             return _val;
         }
  
         const list& operator->() const {
             return _val;
         }
  
     private:
         list _val;
     };
  
 #ifdef RNBO_NOSTDLIB
     using UniqueListPtr = UniquePtr<list>;
 #else
     using UniqueListPtr = std::unique_ptr<listbase<number>>;
 #endif // RNBO_NOSTDLIB
  
 } // namespace RNBO
  
 #endif // #ifndef _RNBO_LIST_H_
C++ Guides

RNBO: common/RNBO_List.h Source File
