tuple.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"
 
namespace cil
{
    template <typename T>
    class Tuple : public Variant
    {
    private:
        Tuple()
            : Variant()
        {
        }
 
    protected:
        T* m_data;  
        int m_size; 
 
    public:
 
        Tuple(int size)
            : Variant()
        {
            this->m_size = size;
            this->m_data = new T[this->m_size]{};
        }
 
        virtual ~Tuple()
        {
            delete[] this->m_data;
        }
 
        int size() const
        {
            return this->m_size;
        }
 
        T* data()
        {
            return this->m_data;
        }
 
        const T* data() const
        {
            return this->m_data;
        }
 
        void setData(const T* data)
        {
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                this->m_data[i] = data[i];
        }
 
        Tuple<T>& operator=(const Tuple& other)
        {
            if (this == &other) return *this;
 
            this->setData(other.data());
 
            return *this;
        }
 
        bool operator==(const Tuple& other) const
        {
            if (this->m_type != other.type())
                return false;
 
            int size = this->m_size;
            for (int i = 0; i < size; i++)
                if (this->m_data[i] != other.data()[i])
                    return false;
 
            return true;
        }
 
        bool operator!=(const Tuple& other) const
        {
            return !this->operator==(other);
        }
    };
}