typedarray.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2024-10-31
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include "variant.h"
#include <cstring>
#include <initializer_list>
 
namespace cil
{
    class ArrayBuffer : public Variant
    {
    public:
        ArrayBuffer();
        virtual ~ArrayBuffer();
    };
 
    template <typename T>
    class TypedArray : public ArrayBuffer
    {
    protected:
        T* m_data;
        int m_size;
 
    public:
        TypedArray() : ArrayBuffer()
        {
            this->m_size = 0;
            this->m_data = nullptr;
        }
 
        virtual ~TypedArray()
        {
            this->clear();
        }
 
        const T& operator[](int index) const
        {
            return this->m_data[index];
        }
 
        T& operator[](int index)
        {
            return this->m_data[index];
        }
 
        void set(int size, T* data = nullptr, bool copy = true)
        {
            this->clear();
 
            if (size > 0)
            {
                this->m_size = size;
                if (data)
                {
                    if (copy)
                    {
                        this->m_data = new T[this->m_size];
                        memcpy(this->m_data, data, this->m_size * sizeof(T));
                    }
                    else
                    {
                        this->m_data = data;
                    }
                }
                else
                {
                    this->m_data = new T[this->m_size]{};
                }
            }
        }
 
        void clear()
        {
            if (this->m_data)
            {
                delete[] this->m_data;
                this->m_data = nullptr;
                this->m_size = 0;
            }
        }
 
        int size() const
        {
            return this->m_size;
        }
 
        T* data()
        {
            return this->m_data;
        }
 
        const T* data() const
        {
            return this->m_data;
        }
    };
 
    class Int8Array final : public TypedArray<char>
    {
    public:
        Int8Array(int size = 0, char* data = nullptr, bool copy = true);
        Int8Array(const std::initializer_list<char>& array);
    };
 
    class Uint8Array final : public TypedArray<unsigned char>
    {
    public:
        Uint8Array(int size = 0, unsigned char* data = nullptr, bool copy = true);
        Uint8Array(const std::initializer_list<unsigned char>& array);
    };
 
    class Int16Array final : public TypedArray<short>
    {
    public:
        Int16Array(int size = 0, short* data = nullptr, bool copy = true);
        Int16Array(const std::initializer_list<short>& array);
    };
 
    class Uint16Array final : public TypedArray<unsigned short>
    {
    public:
        Uint16Array(int size = 0, unsigned short* data = nullptr, bool copy = true);
        Uint16Array(const std::initializer_list<unsigned short>& array);
    };
 
    class Int32Array final : public TypedArray<int>
    {
    public:
        Int32Array(int size = 0, int* data = nullptr, bool copy = true);
        Int32Array(const std::initializer_list<int>& array);
    };
 
    class Uint32Array final : public TypedArray<unsigned int>
    {
    public:
        Uint32Array(int size = 0, unsigned int* data = nullptr, bool copy = true);
        Uint32Array(const std::initializer_list<unsigned int>& array);
    };
 
    class Float32Array final : public TypedArray<float>
    {
    public:
        Float32Array(int size = 0, float* data = nullptr, bool copy = true);
        Float32Array(const std::initializer_list<float>& array);
    };
 
    class Float64Array final : public TypedArray<double>
    {
    public:
        Float64Array(int size = 0, double* data = nullptr, bool copy = true);
        Float64Array(const std::initializer_list<double>& array);
    };
 
    using i8array = Int8Array;
    using u8array = Uint8Array;
    using i16array = Int16Array;
    using u16array = Uint16Array;
    using i32array = Int32Array;
    using u32array = Uint32Array;
    using f32array = Float32Array;
    using f64array = Float64Array;
}