mirror of
https://github.com/Milxnor/Project-Reboot-3.0.git
synced 2026-01-14 03:02:22 +01:00
Dude 💀
This commit is contained in:
Gray
@@ -1,6 +1,8 @@
|
||||
#pragma once
|
||||
|
||||
#include "Set.h"
|
||||
#include "UnrealTemplate.h"
|
||||
#include "ChooseClass.h"
|
||||
|
||||
// template <typename KeyType, typename ValueType>
|
||||
// using TPair = TTuple<KeyType, ValueType>;
|
||||
@@ -9,151 +11,370 @@ template <typename KeyType, typename ValueType>
|
||||
class TPair
|
||||
{
|
||||
public:
|
||||
KeyType First;
|
||||
ValueType Second;
|
||||
|
||||
FORCEINLINE KeyType& Key()
|
||||
{
|
||||
return First;
|
||||
}
|
||||
FORCEINLINE const KeyType& Key() const
|
||||
{
|
||||
return First;
|
||||
}
|
||||
FORCEINLINE ValueType& Value()
|
||||
{
|
||||
return Second;
|
||||
}
|
||||
FORCEINLINE const ValueType& Value() const
|
||||
{
|
||||
return Second;
|
||||
}
|
||||
KeyType Key;
|
||||
ValueType Value;
|
||||
};
|
||||
|
||||
template <typename KeyType, typename ValueType>
|
||||
class TMap
|
||||
template <typename KeyInitType, typename ValueInitType>
|
||||
class TPairInitializer
|
||||
{
|
||||
public:
|
||||
typename TRValueToLValueReference<KeyInitType >::Type Key;
|
||||
typename TRValueToLValueReference<ValueInitType>::Type Value;
|
||||
|
||||
/** Initialization constructor. */
|
||||
FORCEINLINE TPairInitializer(KeyInitType InKey, ValueInitType InValue)
|
||||
: Key(InKey)
|
||||
, Value(InValue)
|
||||
{
|
||||
}
|
||||
|
||||
/** Implicit conversion to pair initializer. */
|
||||
template <typename KeyType, typename ValueType>
|
||||
FORCEINLINE TPairInitializer(const TPair<KeyType, ValueType>& Pair)
|
||||
: Key(Pair.Key)
|
||||
, Value(Pair.Value)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename KeyType, typename ValueType>
|
||||
operator TPair<KeyType, ValueType>() const
|
||||
{
|
||||
#define StaticCast static_cast // Milxnor: ??
|
||||
return TPair<KeyType, ValueType>(StaticCast<KeyInitType>(Key), StaticCast<ValueInitType>(Value));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename KeyType, typename ValueType, bool bInAllowDuplicateKeys>
|
||||
struct TDefaultMapKeyFuncs : BaseKeyFuncs<TPair<KeyType, ValueType>, KeyType, bInAllowDuplicateKeys>
|
||||
{
|
||||
typedef typename TTypeTraits<KeyType>::ConstPointerType KeyInitType;
|
||||
typedef const TPairInitializer<typename TTypeTraits<KeyType>::ConstInitType, typename TTypeTraits<ValueType>::ConstInitType>& ElementInitType;
|
||||
|
||||
static FORCEINLINE KeyInitType GetSetKey(ElementInitType Element)
|
||||
{
|
||||
return Element.Key;
|
||||
}
|
||||
static FORCEINLINE bool Matches(KeyInitType A, KeyInitType B)
|
||||
{
|
||||
return A == B;
|
||||
}
|
||||
static FORCEINLINE uint32 GetKeyHash(KeyInitType Key)
|
||||
{
|
||||
return GetTypeHash(Key);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename KeyType, typename ValueType, bool bInAllowDuplicateKeys>
|
||||
struct TDefaultMapHashableKeyFuncs : TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>
|
||||
{
|
||||
// static_assert(THasGetTypeHash<KeyType>::Value, "TMap must have a hashable KeyType unless a custom key func is provided."); // T(R)
|
||||
};
|
||||
|
||||
template <typename KeyType, typename ValueType, typename SetAllocator, typename KeyFuncs>
|
||||
class TMapBase
|
||||
{
|
||||
template <typename OtherKeyType, typename OtherValueType, typename OtherSetAllocator, typename OtherKeyFuncs>
|
||||
friend class TMapBase;
|
||||
|
||||
friend struct TContainerTraits<TMapBase>;
|
||||
|
||||
public:
|
||||
typedef typename TTypeTraits<KeyType >::ConstPointerType KeyConstPointerType;
|
||||
typedef typename TTypeTraits<KeyType >::ConstInitType KeyInitType;
|
||||
typedef typename TTypeTraits<ValueType>::ConstInitType ValueInitType;
|
||||
typedef TPair<KeyType, ValueType> ElementType;
|
||||
|
||||
protected:
|
||||
TMapBase() = default;
|
||||
TMapBase(TMapBase&&) = default;
|
||||
TMapBase(const TMapBase&) = default;
|
||||
TMapBase& operator=(TMapBase&&) = default;
|
||||
TMapBase& operator=(const TMapBase&) = default;
|
||||
|
||||
typedef TSet<ElementType, KeyFuncs, SetAllocator> ElementSetType;
|
||||
|
||||
/** The base of TMapBase iterators. */
|
||||
template<bool bConst, bool bRangedFor = false>
|
||||
class TBaseIterator
|
||||
{
|
||||
public:
|
||||
typedef typename TChooseClass<
|
||||
bConst,
|
||||
typename TChooseClass<bRangedFor, typename ElementSetType::TRangedForConstIterator, typename ElementSetType::TConstIterator>::Result,
|
||||
typename TChooseClass<bRangedFor, typename ElementSetType::TRangedForIterator, typename ElementSetType::TIterator >::Result
|
||||
>::Result PairItType;
|
||||
private:
|
||||
typedef typename TChooseClass<bConst, const TMapBase, TMapBase>::Result MapType;
|
||||
typedef typename TChooseClass<bConst, const KeyType, KeyType>::Result ItKeyType;
|
||||
typedef typename TChooseClass<bConst, const ValueType, ValueType>::Result ItValueType;
|
||||
typedef typename TChooseClass<bConst, const typename ElementSetType::ElementType, typename ElementSetType::ElementType>::Result PairType;
|
||||
|
||||
public:
|
||||
FORCEINLINE TBaseIterator(const PairItType& InElementIt)
|
||||
: PairIt(InElementIt)
|
||||
{
|
||||
}
|
||||
|
||||
FORCEINLINE TBaseIterator& operator++()
|
||||
{
|
||||
++PairIt;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** conversion to "bool" returning true if the iterator is valid. */
|
||||
FORCEINLINE explicit operator bool() const
|
||||
{
|
||||
return !!PairIt;
|
||||
}
|
||||
/** inverse of the "bool" operator */
|
||||
FORCEINLINE bool operator !() const
|
||||
{
|
||||
return !(bool)*this;
|
||||
}
|
||||
|
||||
FORCEINLINE friend bool operator==(const TBaseIterator& Lhs, const TBaseIterator& Rhs) { return Lhs.PairIt == Rhs.PairIt; }
|
||||
FORCEINLINE friend bool operator!=(const TBaseIterator& Lhs, const TBaseIterator& Rhs) { return Lhs.PairIt != Rhs.PairIt; }
|
||||
|
||||
FORCEINLINE ItKeyType& Key() const { return PairIt->Key; }
|
||||
FORCEINLINE ItValueType& Value() const { return PairIt->Value; }
|
||||
|
||||
FORCEINLINE PairType& operator* () const { return *PairIt; }
|
||||
FORCEINLINE PairType* operator->() const { return &*PairIt; }
|
||||
|
||||
protected:
|
||||
PairItType PairIt;
|
||||
};
|
||||
|
||||
/** The base type of iterators that iterate over the values associated with a specified key. */
|
||||
template<bool bConst>
|
||||
class TBaseKeyIterator
|
||||
{
|
||||
private:
|
||||
typedef typename TChooseClass<bConst, typename ElementSetType::TConstKeyIterator, typename ElementSetType::TKeyIterator>::Result SetItType;
|
||||
typedef typename TChooseClass<bConst, const KeyType, KeyType>::Result ItKeyType;
|
||||
typedef typename TChooseClass<bConst, const ValueType, ValueType>::Result ItValueType;
|
||||
|
||||
public:
|
||||
/** Initialization constructor. */
|
||||
FORCEINLINE TBaseKeyIterator(const SetItType& InSetIt)
|
||||
: SetIt(InSetIt)
|
||||
{
|
||||
}
|
||||
|
||||
FORCEINLINE TBaseKeyIterator& operator++()
|
||||
{
|
||||
++SetIt;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** conversion to "bool" returning true if the iterator is valid. */
|
||||
FORCEINLINE explicit operator bool() const
|
||||
{
|
||||
return !!SetIt;
|
||||
}
|
||||
/** inverse of the "bool" operator */
|
||||
FORCEINLINE bool operator !() const
|
||||
{
|
||||
return !(bool)*this;
|
||||
}
|
||||
|
||||
FORCEINLINE ItKeyType& Key() const { return SetIt->Key; }
|
||||
FORCEINLINE ItValueType& Value() const { return SetIt->Value; }
|
||||
|
||||
protected:
|
||||
SetItType SetIt;
|
||||
};
|
||||
|
||||
/** A set of the key-value pairs in the map. */
|
||||
ElementSetType Pairs;
|
||||
|
||||
public:
|
||||
|
||||
/** Map iterator. */
|
||||
class TIterator : public TBaseIterator<false>
|
||||
{
|
||||
public:
|
||||
|
||||
/** Initialization constructor. */
|
||||
FORCEINLINE TIterator(TMapBase& InMap, bool bInRequiresRehashOnRemoval = false)
|
||||
: TBaseIterator<false>(InMap.Pairs.CreateIterator())
|
||||
, Map(InMap)
|
||||
, bElementsHaveBeenRemoved(false)
|
||||
, bRequiresRehashOnRemoval(bInRequiresRehashOnRemoval)
|
||||
{
|
||||
}
|
||||
|
||||
/** Destructor. */
|
||||
FORCEINLINE ~TIterator()
|
||||
{
|
||||
if (bElementsHaveBeenRemoved && bRequiresRehashOnRemoval)
|
||||
{
|
||||
Map.Pairs.Relax();
|
||||
}
|
||||
}
|
||||
|
||||
/** Removes the current pair from the map. */
|
||||
FORCEINLINE void RemoveCurrent()
|
||||
{
|
||||
TBaseIterator<false>::PairIt.RemoveCurrent();
|
||||
bElementsHaveBeenRemoved = true;
|
||||
}
|
||||
|
||||
private:
|
||||
TMapBase& Map;
|
||||
bool bElementsHaveBeenRemoved;
|
||||
bool bRequiresRehashOnRemoval;
|
||||
};
|
||||
|
||||
/** Const map iterator. */
|
||||
class TConstIterator : public TBaseIterator<true>
|
||||
{
|
||||
public:
|
||||
FORCEINLINE TConstIterator(const TMapBase& InMap)
|
||||
: TBaseIterator<true>(InMap.Pairs.CreateConstIterator())
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
using TRangedForIterator = TBaseIterator<false, true>;
|
||||
using TRangedForConstIterator = TBaseIterator<true, true>;
|
||||
|
||||
/** Iterates over values associated with a specified key in a const map. */
|
||||
class TConstKeyIterator : public TBaseKeyIterator<true>
|
||||
{
|
||||
public:
|
||||
FORCEINLINE TConstKeyIterator(const TMapBase& InMap, KeyInitType InKey)
|
||||
: TBaseKeyIterator<true>(typename ElementSetType::TConstKeyIterator(InMap.Pairs, InKey))
|
||||
{}
|
||||
};
|
||||
|
||||
/** Iterates over values associated with a specified key in a map. */
|
||||
class TKeyIterator : public TBaseKeyIterator<false>
|
||||
{
|
||||
public:
|
||||
FORCEINLINE TKeyIterator(TMapBase& InMap, KeyInitType InKey)
|
||||
: TBaseKeyIterator<false>(typename ElementSetType::TKeyIterator(InMap.Pairs, InKey))
|
||||
{}
|
||||
|
||||
/** Removes the current key-value pair from the map. */
|
||||
FORCEINLINE void RemoveCurrent()
|
||||
{
|
||||
TBaseKeyIterator<false>::SetIt.RemoveCurrent();
|
||||
}
|
||||
};
|
||||
|
||||
/** Creates an iterator over all the pairs in this map */
|
||||
FORCEINLINE TIterator CreateIterator()
|
||||
{
|
||||
return TIterator(*this);
|
||||
}
|
||||
|
||||
/** Creates a const iterator over all the pairs in this map */
|
||||
FORCEINLINE TConstIterator CreateConstIterator() const
|
||||
{
|
||||
return TConstIterator(*this);
|
||||
}
|
||||
|
||||
/** Creates an iterator over the values associated with a specified key in a map */
|
||||
FORCEINLINE TKeyIterator CreateKeyIterator(KeyInitType InKey)
|
||||
{
|
||||
return TKeyIterator(*this, InKey);
|
||||
}
|
||||
|
||||
/** Creates a const iterator over the values associated with a specified key in a map */
|
||||
FORCEINLINE TConstKeyIterator CreateConstKeyIterator(KeyInitType InKey) const
|
||||
{
|
||||
return TConstKeyIterator(*this, InKey);
|
||||
}
|
||||
|
||||
FORCEINLINE ValueType* Find(KeyConstPointerType Key)
|
||||
{
|
||||
if (auto* Pair = Pairs.Find(Key))
|
||||
{
|
||||
return &Pair->Value;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
FORCEINLINE const ValueType& FindChecked(KeyConstPointerType Key) const
|
||||
{
|
||||
const auto* Pair = Pairs.Find(Key);
|
||||
// check(Pair != nullptr);
|
||||
return Pair->Value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find a reference to the value associated with a specified key.
|
||||
*
|
||||
* @param Key The key to search for.
|
||||
* @return The value associated with the specified key, or triggers an assertion if the key does not exist.
|
||||
*/
|
||||
FORCEINLINE ValueType& FindChecked(KeyConstPointerType Key)
|
||||
{
|
||||
auto* Pair = Pairs.Find(Key);
|
||||
// check(Pair != nullptr);
|
||||
return Pair->Value;
|
||||
}
|
||||
|
||||
FORCEINLINE ValueType FindRef(KeyConstPointerType Key) const
|
||||
{
|
||||
if (const auto* Pair = Pairs.Find(Key))
|
||||
{
|
||||
return Pair->Value;
|
||||
}
|
||||
|
||||
return ValueType();
|
||||
}
|
||||
|
||||
FORCEINLINE int32 Num() const
|
||||
{
|
||||
return Pairs.Num();
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* DO NOT USE DIRECTLY
|
||||
* STL-like iterators to enable range-based for loop support.
|
||||
*/
|
||||
FORCEINLINE friend TRangedForIterator begin(TMapBase& MapBase) { return TRangedForIterator(begin(MapBase.Pairs)); }
|
||||
FORCEINLINE friend TRangedForConstIterator begin(const TMapBase& MapBase) { return TRangedForConstIterator(begin(MapBase.Pairs)); }
|
||||
FORCEINLINE friend TRangedForIterator end(TMapBase& MapBase) { return TRangedForIterator(end(MapBase.Pairs)); }
|
||||
FORCEINLINE friend TRangedForConstIterator end(const TMapBase& MapBase) { return TRangedForConstIterator(end(MapBase.Pairs)); }
|
||||
};
|
||||
|
||||
template <typename KeyType, typename ValueType, typename SetAllocator, typename KeyFuncs>
|
||||
class TSortableMapBase : public TMapBase<KeyType, ValueType, SetAllocator, KeyFuncs>
|
||||
{
|
||||
// friend struct TContainerTraits<TSortableMapBase>;
|
||||
|
||||
protected:
|
||||
typedef TMapBase<KeyType, ValueType, SetAllocator, KeyFuncs> Super;
|
||||
|
||||
TSortableMapBase() = default;
|
||||
TSortableMapBase(TSortableMapBase&&) = default;
|
||||
TSortableMapBase(const TSortableMapBase&) = default;
|
||||
TSortableMapBase& operator=(TSortableMapBase&&) = default;
|
||||
TSortableMapBase& operator=(const TSortableMapBase&) = default;
|
||||
};
|
||||
|
||||
template<typename KeyType, typename ValueType, typename SetAllocator = FDefaultSetAllocator, typename KeyFuncs = TDefaultMapHashableKeyFuncs<KeyType,ValueType,false>>
|
||||
class TMap : public TSortableMapBase<KeyType, ValueType, SetAllocator, KeyFuncs>
|
||||
{
|
||||
public:
|
||||
typedef TSortableMapBase<KeyType, ValueType, SetAllocator, KeyFuncs> Super;
|
||||
typedef typename Super::KeyInitType KeyInitType;
|
||||
typedef typename Super::KeyConstPointerType KeyConstPointerType;
|
||||
|
||||
typedef TPair<KeyType, ValueType> ElementType;
|
||||
public:
|
||||
typedef TSet<ElementType, KeyFuncs, SetAllocator> ElementSetType;
|
||||
|
||||
public:
|
||||
TSet<ElementType> Pairs;
|
||||
|
||||
public:
|
||||
class FBaseIterator
|
||||
{
|
||||
private:
|
||||
TMap<KeyType, ValueType>& IteratedMap;
|
||||
TSet<ElementType>::FBaseIterator SetIt;
|
||||
|
||||
public:
|
||||
FBaseIterator(TMap<KeyType, ValueType>& InMap, TSet<ElementType>::FBaseIterator InSet)
|
||||
: IteratedMap(InMap)
|
||||
, SetIt(InSet)
|
||||
{
|
||||
}
|
||||
FORCEINLINE TMap<KeyType, ValueType>::FBaseIterator operator++()
|
||||
{
|
||||
++SetIt;
|
||||
return *this;
|
||||
}
|
||||
FORCEINLINE TMap<KeyType, ValueType>::ElementType& operator*()
|
||||
{
|
||||
return *SetIt;
|
||||
}
|
||||
FORCEINLINE const TMap<KeyType, ValueType>::ElementType& operator*() const
|
||||
{
|
||||
return *SetIt;
|
||||
}
|
||||
FORCEINLINE bool operator==(const TMap<KeyType, ValueType>::FBaseIterator& Other) const
|
||||
{
|
||||
return SetIt == Other.SetIt;
|
||||
}
|
||||
FORCEINLINE bool operator!=(const TMap<KeyType, ValueType>::FBaseIterator& Other) const
|
||||
{
|
||||
return SetIt != Other.SetIt;
|
||||
}
|
||||
FORCEINLINE bool IsElementValid() const
|
||||
{
|
||||
return SetIt.IsElementValid();
|
||||
}
|
||||
};
|
||||
|
||||
FORCEINLINE TMap<KeyType, ValueType>::FBaseIterator begin()
|
||||
{
|
||||
return TMap<KeyType, ValueType>::FBaseIterator(*this, Pairs.begin());
|
||||
}
|
||||
FORCEINLINE const TMap<KeyType, ValueType>::FBaseIterator begin() const
|
||||
{
|
||||
return TMap<KeyType, ValueType>::FBaseIterator(*this, Pairs.begin());
|
||||
}
|
||||
FORCEINLINE TMap<KeyType, ValueType>::FBaseIterator end()
|
||||
{
|
||||
return TMap<KeyType, ValueType>::FBaseIterator(*this, Pairs.end());
|
||||
}
|
||||
FORCEINLINE const TMap<KeyType, ValueType>::FBaseIterator end() const
|
||||
{
|
||||
return TMap<KeyType, ValueType>::FBaseIterator(*this, Pairs.end());
|
||||
}
|
||||
FORCEINLINE ValueType& operator[](const KeyType& Key)
|
||||
{
|
||||
return this->GetByKey(Key);
|
||||
}
|
||||
FORCEINLINE const ValueType& operator[](const KeyType& Key) const
|
||||
{
|
||||
return this->GetByKey(Key);
|
||||
}
|
||||
FORCEINLINE int32 Num() const
|
||||
{
|
||||
return Pairs.Num();
|
||||
}
|
||||
FORCEINLINE bool IsValid() const
|
||||
{
|
||||
return Pairs.IsValid();
|
||||
}
|
||||
FORCEINLINE bool IsIndexValid(int32 IndexToCheck) const
|
||||
{
|
||||
return Pairs.IsIndexValid(IndexToCheck);
|
||||
}
|
||||
FORCEINLINE bool Contains(const KeyType& ElementToLookFor) const
|
||||
{
|
||||
for (auto& Element : *this)
|
||||
{
|
||||
if (Element.Key() == ElementToLookFor)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
FORCEINLINE ValueType& GetByKey(const KeyType& Key, bool* wasSuccessful = nullptr)
|
||||
{
|
||||
for (auto& Pair : *this)
|
||||
{
|
||||
if (Pair.Key() == Key)
|
||||
{
|
||||
if (wasSuccessful)
|
||||
*wasSuccessful = true;
|
||||
|
||||
return Pair.Value();
|
||||
}
|
||||
}
|
||||
|
||||
// LOG_INFO(LogDev, "Failed to find Key!!!");
|
||||
|
||||
if (wasSuccessful)
|
||||
*wasSuccessful = false;
|
||||
}
|
||||
FORCEINLINE ValueType& Find(const KeyType& Key, bool* wasSuccessful = nullptr)
|
||||
{
|
||||
return GetByKey(Key, wasSuccessful);
|
||||
}
|
||||
FORCEINLINE ValueType GetByKeyNoRef(const KeyType& Key)
|
||||
{
|
||||
for (auto& Pair : *this)
|
||||
{
|
||||
if (Pair.Key() == Key)
|
||||
{
|
||||
return Pair.Value();
|
||||
}
|
||||
}
|
||||
}
|
||||
TMap() = default;
|
||||
TMap(TMap&&) = default;
|
||||
TMap(const TMap&) = default;
|
||||
TMap& operator=(TMap&&) = default;
|
||||
TMap& operator=(const TMap&) = default;
|
||||
};
|
||||
Reference in New Issue
Block a user