meshVariableArray.h

Go to the documentation of this file.

 
#ifndef MESH_VARIABLE_ARRAY_H
#define MESH_VARIABLE_ARRAY_H
 
#include "meshHelper.h"
 
 
template<typename T>
class MeshVariableArray {
public:
 
    MeshVariableArray(){
 
    }
 
    MeshVariableArray(const uint16_t length) {
        ResizeArray(length, true);
    }
 
    MeshVariableArray(const T* newData, const uint16_t newDataLength) {
        SetArray(newData, newDataLength);
    }
 
    MeshVariableArray(const T fillItem, const uint16_t length) {
        ResizeArray(length, true);
        FillArray(fillItem);
    }
 
    MeshVariableArray(const MeshVariableArray<T>& mva) {
        CopyFrom(mva);
    }
 
    MeshVariableArray(MeshVariableArray<T>&& mva) noexcept {
        MoveFrom(mva);
    }
 
    ~MeshVariableArray() {
        Clear();
    }
 
    MeshVariableArray<T>& operator=(const MeshVariableArray<T>& mva) {
        CopyFrom(mva);
        return *this;
    }
 
    MeshVariableArray<T>& operator=(MeshVariableArray<T>&& mva) noexcept {
        MoveFrom(mva);
        return *this;
    }
 
 
    inline uint16_t Length() const{
        return DataLength;
    }
 
    T operator [](uint16_t i) const{
        return Data[i];
    }
 
    T& operator [](uint16_t i) {
        return Data[i];
    }
 
    T GetAt(uint16_t index) const {
        Data[index];
    }
 
    bool SetAt(uint16_t index, T value) {
        if (index < DataLength) {
            Data[index] = value;
            return true;
        }
        else return false;
    }
 
    bool SetArray(const T* newData, const uint16_t newDataLength) {
        //Array resizing if needed
        if (DataLength != newDataLength) {
            if (!ResizeArray(newDataLength, true)) {
                return false;
            }
        }
 
        //Data copying
        memcpy(Data, newData, newDataLength * sizeof(T));
        return true;
    }
 
    bool SetData(const T* newData, uint16_t startIndex, const uint16_t newDataLength) {
        uint16_t maxLength = startIndex + newDataLength;
        if (maxLength > DataLength) {
            //Array expand needed
            if (!ResizeArray(maxLength, false)) {
                return false;
            }
        }
 
        //Data copying
        memcpy(Data + startIndex * sizeof(T), newData, newDataLength * sizeof(T));
        return true;
    }
 
    void FillArray(const T fillItem) {
        for (uint16_t i = 0; i < DataLength; i++) {
            Data[i] = fillItem;
        }
    }
 
    bool FillData(const T fillItem, uint16_t startIndex, uint16_t count) {
        uint16_t maxLength = startIndex + count;
        if (maxLength > DataLength) {
            //Array expand needed
            if (!ResizeArray(maxLength, false)) {
                return false;
            }
        }
 
        for (uint16_t i = startIndex; i < maxLength; i++) {
            Data[i] = fillItem;
        }
        return true;
    }
 
    void GetData(T* data, uint16_t& dataLength) const {
        dataLength = (dataLength > DataLength) ? DataLength : dataLength;
        memcpy(data, Data, dataLength * sizeof(T));
    }
 
    bool ResizeArray(uint16_t size, bool doNotCopy = false) {
        if (size > 32767) //Payload limit exceeded
            return false;
        if (size == 0) {
            Clear();
            return true;
        }
 
        T* newPayloadPtr = NULL;
        if (doNotCopy) {
            Clear();
            newPayloadPtr = (T*)malloc(size * sizeof(T));
        }
        else {
            //just use realloc
            newPayloadPtr = (T*)realloc(Data, size * sizeof(T));
        }
 
        if (newPayloadPtr != NULL) {
            //Allocation was successful
            Data = newPayloadPtr;
            DataLength = size;
            return true;
        }
        else {
            //Allocation error
            return false;
        }
    }
 
    void Clear() {
        if (Data != NULL) {
            free(Data);
            Data = NULL;
        }
        DataLength = 0;
    }
 
    bool CopyFrom(const MeshVariableArray<T>& another) {
        Clear();
        return SetData(another.d_ptr(), another.Length());
    }
 
    void MoveFrom(MeshVariableArray<T>& another) {
        Clear();
        Data = another.Data;
        DataLength = another.DataLength;
        another.Data = NULL;
        another.DataLength = 0;
    }
 
    void MoveFrom(T*& dataPtr, uint16_t dataLength) {
        Clear();
        Data = dataPtr;
        DataLength = dataLength;
        dataPtr = NULL;
    }
 
    inline T* UnsafeDataMove() {
        T* ptr = Data;
        Data = NULL;
        DataLength = 0;
        return ptr;
    }
 
    inline const T* d_ptr() const{
        return Data;
    }
    
protected:
 
    T* Data = NULL;
 
    uint16_t DataLength = 0;
};
 
#endif // !MESH_VARIABLE_ARRAY_H