kyarray.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/base/types.h"
#include "gwnavruntime/kernel/SF_Array.h"

namespace Kaim
{

// Array generic interface
//
// **************************
//      - UPInt   GetSize()       const;
//      - bool    IsEmpty()       const;
//      - UPInt   GetCapacity()   const;
//      - UPInt   GetNumBytes()   const;
//
//      void    ClearAndRelease();
//      void    Clear();
//      void    Resize(UPInt newSize);
//
//      void    Reserve(UPInt newCapacity);
//
//      // Basic access.
//      ValueType& At(UPInt index);
//      const ValueType& At(UPInt index); const
//      ValueType ValueAt(UPInt index) const;
//      ValueType& operator [] (UPInt index);
//      const ValueType& operator [] (UPInt index) const;
//
//      // Raw pointer to the data. Use with caution!
//      const ValueType* GetDataPtr() const;
//      ValueType* GetDataPtr();
//
//      // Insert the given element at the end of the array.
//      void    PushBack(const ValueType& val);
//      template<class S>
//      void PushBackAlt(const S& val);
//
//      // Remove the last element.
//      void    PopBack(UPInt count = 1);
//      ValueType& PushDefault();
//
//      ValueType Pop();
//
//      // Access the first element.
//      ValueType&    Front();
//      const ValueType&    Front() const;
//
//      // Access the last element.
//      ValueType&    Back();
//      const ValueType&    Back() const;
//
//      // Array copy.  Copies the contents of a into this array.
//      const SelfType& operator = (const SelfType& a);
//
//      // Removing multiple elements from the array.
//      void    RemoveMultipleAt(UPInt index, UPInt num);
//
//      // Removing an element from the array is an expensive operation!
//      // It compacts only after removing the last element.
//      void    RemoveAt(UPInt index);
//      // Insert the given object at the given index shifting all the elements up.
//      void    InsertAt(UPInt index, const ValueType& val = ValueType());
//      // Insert the given object at the given index shifting all the elements up.
//      void    InsertMultipleAt(UPInt index, UPInt num, const ValueType& val = ValueType());
//      // Append the given data to the array.
//      void    Append(const SelfType& other);
//      // Append the given data to the array.
//      void    Append(const ValueType other[], UPInt count);
//
//      bool DoesContain(const ValueType& value) const;
//      void RemoveConsecutiveDuplicates();
//
// **************************
// // Navigation array different type
// - KyArray :
//      General purpose array for movable objects that require explicit
//      construction/destruction. Global heap is in use.
// - KyArrayPOD
//      General purpose array for movable objects that DOES NOT require
//      construction/destruction. Constructors and destructors are not called!
//      Global heap is in use.
// - KyArrayLH
//      General purpose array for movable objects that require explicit
//      construction/destruction. Local heap is in use.
// - KyArrayLH_POD
//      General purpose array for movable objects that DOES NOT require
//      construction/destruction. Constructors and destructors are not called!
//      Local heap is in use.
// - KyArrayDH
//      General purpose array for movable objects that require explicit
//      construction/destruction. Dynamic heap is in use.
// - KyArrayDH_POD
//      General purpose array for movable objects that DOES NOT require
//      construction/destruction. Constructors and destructors are not called!
//      Dynamic heap is in use.

namespace ArrayAlg
{

template <typename ArrayT, typename ValueT>
bool DoesContain(const ArrayT& arr, const ValueT& value)
{
    for (UPInt i = 0; i < arr.GetSize(); ++i)
    {
        if (arr[i] == value)
            return true;
    }
    return false;
}

template <typename ArrayT>
void RemoveConsecutiveDuplicates(ArrayT& arr)
{
    if (arr.GetCount() == 0)
        return;

    UPInt writeIdx = 0;
    for (UPInt readIdx = 1; readIdx < arr.GetSize(); ++readIdx)
    {
        if (arr[writeIdx] != arr[readIdx])
        {
            ++writeIdx;
            arr[writeIdx] = arr[readIdx];
        }
    }
    arr.Resize(writeIdx + 1);
}

template<typename T1, typename T2>
bool IsEqual(const T1& a1, const T2& a2)
{
    if (a1.GetCount() != a2.GetCount())
        return false;

    for (KyUInt32 i = 0; i < a1.GetCount(); ++i)
    {
        if (a1[i] != a2[i])
            return false;
    }

    return true;
}
}

// ---- KyArrayDefaultPolicy ----
typedef ArrayConstPolicy<0, 4, true> KyArrayDefaultPolicy;


// ---- KyArray ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArray : public Array<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                               ValueType;
    typedef KyArray<T, SID, SizePolicy>     SelfType;
    typedef Array<T, SID, SizePolicy>       BaseType;

    // ------------------------------ Functions -----------------------------

    KyArray() : BaseType() {}
    explicit KyArray(int size) : BaseType(size) {}
    KyArray(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};


// ---- KyArrayPOD ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayPOD : public ArrayPOD<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                               ValueType;
    typedef KyArrayPOD<T, SID, SizePolicy>  SelfType;
    typedef ArrayPOD<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    KyArrayPOD() : BaseType() {}
    explicit KyArrayPOD(int size) : BaseType(size) {}
    KyArrayPOD(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

// ---- KyArrayLH ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayLH : public ArrayLH<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                              ValueType;
    typedef KyArrayLH<T, SID, SizePolicy>  SelfType;
    typedef ArrayLH<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    KyArrayLH() : BaseType() {}
    explicit KyArrayLH(int size) : BaseType(size) {}
    KyArrayLH(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

// ---- KyArrayCPP ----
// General purpose fully C++ compliant array. Can be used with non-movable data.
// Global heap is in use.
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayCPP : public ArrayCPP<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                               ValueType;
    typedef KyArrayCPP<T, SID, SizePolicy>  SelfType;
    typedef ArrayCPP<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    KyArrayCPP() : BaseType() {}
    explicit KyArrayCPP(int size) : BaseType(size) {}
    KyArrayCPP(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

// ---- KyArrayLH_POD ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayLH_POD : public ArrayLH_POD<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                                  ValueType;
    typedef KyArrayLH_POD<T, SID, SizePolicy>  SelfType;
    typedef ArrayLH_POD<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    KyArrayLH_POD() : BaseType() {}
    explicit KyArrayLH_POD(int size) : BaseType(size) {}
    KyArrayLH_POD(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

// ---- KyArrayLH_CPP ----
// General purpose fully C++ compliant array. Can be used with non-movable data.
// Local heap is in use.
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayLH_CPP : public ArrayLH_CPP<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                                  ValueType;
    typedef KyArrayLH_CPP<T, SID, SizePolicy>  SelfType;
    typedef ArrayLH_CPP<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    KyArrayLH_CPP() : BaseType() {}
    explicit KyArrayLH_CPP(int size) : BaseType(size) {}
    KyArrayLH_CPP(const SelfType& a) : BaseType(a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

// ---- KyArrayDH ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayDH : public ArrayDH<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                              ValueType;
    typedef KyArrayDH<T, SID, SizePolicy>  SelfType;
    typedef ArrayDH<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    explicit KyArrayDH(MemoryHeap* heap) : BaseType(heap) {}
    KyArrayDH(MemoryHeap* heap, int size) : BaseType(heap, size) {}
    KyArrayDH(MemoryHeap* heap, const SelfType& a) : BaseType(heap, a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};


// ---- KyArrayDH_POD ----
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayDH_POD : public ArrayDH_POD<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                                  ValueType;
    typedef KyArrayDH_POD<T, SID, SizePolicy>  SelfType;
    typedef ArrayDH_POD<T, SID, SizePolicy>    BaseType;


    // ------------------------------ Functions -----------------------------

    explicit KyArrayDH_POD(MemoryHeap* heap) : BaseType(heap) {}
    KyArrayDH_POD(MemoryHeap* heap, int size) : BaseType(heap, size) {}
    KyArrayDH_POD(MemoryHeap* heap, const SelfType& a) : BaseType(heap, a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};


// ---- KyArrayDH_CPP ----
// General purpose fully C++ compliant array. Can be used with non-movable data.
// Dynamic heap is in use
template<class T, int SID=Stat_Default_Mem, class SizePolicy=KyArrayDefaultPolicy>
class KyArrayDH_CPP : public ArrayDH_CPP<T, SID, SizePolicy>
{
public:
    // ---------------------------------- Public typedef ----------------------------------

    typedef T                                ValueType;
    typedef KyArrayDH_CPP<T, SID, SizePolicy> SelfType;
    typedef ArrayDH_CPP<T, SID, SizePolicy>   BaseType;


    // ------------------------------ Functions -----------------------------

    explicit KyArrayDH_CPP(MemoryHeap* heap) : BaseType(heap) {}
    KyArrayDH_CPP(MemoryHeap* heap, int size) : BaseType(heap, size) {}
    KyArrayDH_CPP(MemoryHeap* heap, const SelfType& a) : BaseType(heap, a) {}
    const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }

    KyUInt32 GetCount() const { return (KyUInt32)BaseType::GetSize(); }

    bool operator==(const SelfType& other) const { return ArrayAlg::IsEqual(*this, other); }
    bool operator!=(const SelfType& other) { return !operator==(other); }

    bool DoesContain(const ValueType& value) const { return ArrayAlg::DoesContain<SelfType,ValueType>(*this, value); }
    void RemoveConsecutiveDuplicates() { ArrayAlg::RemoveConsecutiveDuplicates<SelfType>(*this); }
    void StealFrom(SelfType& other) { this->Data.StealFrom(other.Data); }
};

} // namespace Kaim