#pragma once
|
|
#include <algorithm>
|
#include <vector>
|
#include <functional>
|
#include "NonCopyable.h"
|
|
namespace il2cpp
|
{
|
namespace utils
|
{
|
namespace collections
|
{
|
// Memory compact, map-like data structure that stores values and
|
// is a able to compute the key from the value with the provided converter
|
// This data structure is perfect to storing values that will not be changed
|
// for the duration of program (like type metadata) and need fast querying
|
//
|
// It is able to store multiple values associated with a single key, and query them through find()
|
// find_first() is a special case find() which improves performance for cases where we don't store multiple values for each key
|
template<typename TKey, typename TValue, typename TValueToKeyConverter, typename TKeyLess = std::less<TKey>, typename TKeyEquals = std::equal_to<TKey> >
|
class ArrayValueMap : NonCopyable
|
{
|
public:
|
typedef ArrayValueMap<TKey, TValue, TValueToKeyConverter, TKeyLess, TKeyEquals> map_type;
|
typedef const TValue* iterator;
|
|
private:
|
const TValue* m_Values;
|
const size_t m_ValueCount;
|
bool m_OwnStorage;
|
const TValueToKeyConverter m_ValueToKeyConverter;
|
const TKeyLess m_KeyLessComparer;
|
const TKeyEquals m_KeyEqualsComparer;
|
|
struct SortComparer
|
{
|
private:
|
const TValueToKeyConverter m_ValueToKeyConverter;
|
const TKeyLess m_KeyComparer;
|
|
public:
|
SortComparer(TValueToKeyConverter valueToKeyConverter, TKeyLess keyComparer) :
|
m_ValueToKeyConverter(valueToKeyConverter), m_KeyComparer(keyComparer)
|
{
|
}
|
|
inline bool operator()(const TValue& left, const TValue& right) const
|
{
|
return m_KeyComparer(m_ValueToKeyConverter(left), m_ValueToKeyConverter(right));
|
}
|
};
|
|
struct LowerBoundFindComparer
|
{
|
private:
|
const TValueToKeyConverter m_ValueToKeyConverter;
|
const TKeyLess m_KeyComparer;
|
|
public:
|
LowerBoundFindComparer(TValueToKeyConverter valueToKeyConverter, TKeyLess keyComparer) :
|
m_ValueToKeyConverter(valueToKeyConverter), m_KeyComparer(keyComparer)
|
{
|
}
|
|
inline bool operator()(const TValue& left, const TKey& right) const
|
{
|
return m_KeyComparer(m_ValueToKeyConverter(left), right);
|
}
|
};
|
|
struct UpperBoundFindComparer
|
{
|
private:
|
const TValueToKeyConverter m_ValueToKeyConverter;
|
const TKeyLess m_KeyComparer;
|
|
public:
|
UpperBoundFindComparer(TValueToKeyConverter valueToKeyConverter, TKeyLess keyComparer) :
|
m_ValueToKeyConverter(valueToKeyConverter), m_KeyComparer(keyComparer)
|
{
|
}
|
|
inline bool operator()(const TKey& left, const TValue& right) const
|
{
|
return m_KeyComparer(left, m_ValueToKeyConverter(right));
|
}
|
};
|
|
inline static TValue* InitializeInPlace(TValue* values, size_t valueCount, TValueToKeyConverter valueToKeyConverter, TKeyLess keyLessComparer)
|
{
|
std::sort(values, values + valueCount, SortComparer(valueToKeyConverter, keyLessComparer));
|
return values;
|
}
|
|
inline static TValue* AllocateAndInitialize(const TValue* originalValues, size_t valueCount, TValueToKeyConverter valueToKeyConverter, TKeyLess keyLessComparer)
|
{
|
TValue* values = new TValue[valueCount];
|
memcpy(values, originalValues, valueCount * sizeof(TValue));
|
|
return InitializeInPlace(values, valueCount, valueToKeyConverter, keyLessComparer);
|
}
|
|
public:
|
inline ArrayValueMap() :
|
m_Values(NULL),
|
m_ValueCount(0),
|
m_OwnStorage(false),
|
m_ValueToKeyConverter(TValueToKeyConverter()),
|
m_KeyLessComparer(TKeyLess()),
|
m_KeyEqualsComparer(TKeyEquals())
|
{
|
}
|
|
// Non-allocating constructor. It will take a pointer and will not allocate any storage
|
// It WILL sort existing values
|
inline ArrayValueMap(TValue* values, size_t valueCount, TValueToKeyConverter valueToKeyConverter = TValueToKeyConverter(),
|
TKeyLess keyLessComparer = TKeyLess(), TKeyEquals keyEqualsComparer = TKeyEquals()) :
|
m_Values(InitializeInPlace(values, valueCount, valueToKeyConverter, keyLessComparer)),
|
m_ValueCount(valueCount),
|
m_ValueToKeyConverter(valueToKeyConverter),
|
m_KeyLessComparer(keyLessComparer),
|
m_KeyEqualsComparer(keyEqualsComparer),
|
m_OwnStorage(false)
|
{
|
}
|
|
// Allocating constructor
|
// Will copy values to newly allocated storage
|
inline ArrayValueMap(const std::vector<TValue>& values, TValueToKeyConverter valueToKeyConverter = TValueToKeyConverter(),
|
TKeyLess keyLessComparer = TKeyLess(), TKeyEquals keyEqualsComparer = TKeyEquals()) :
|
m_Values(AllocateAndInitialize(values.data(), values.size(), valueToKeyConverter, keyLessComparer)),
|
m_ValueCount(values.size()),
|
m_ValueToKeyConverter(valueToKeyConverter),
|
m_KeyLessComparer(keyLessComparer),
|
m_KeyEqualsComparer(keyEqualsComparer),
|
m_OwnStorage(true)
|
{
|
}
|
|
~ArrayValueMap()
|
{
|
if (m_OwnStorage)
|
{
|
delete[] m_Values;
|
}
|
}
|
|
inline void assign_external(TValue* values, size_t valueCount, TValueToKeyConverter valueToKeyConverter = TValueToKeyConverter(),
|
TKeyLess keyLessComparer = TKeyLess(), TKeyEquals keyEqualsComparer = TKeyEquals())
|
{
|
this->~ArrayValueMap();
|
new(this) map_type(values, valueCount, valueToKeyConverter, keyLessComparer, keyEqualsComparer);
|
}
|
|
// Constructs map that contains pointers to original array
|
inline void assign_addresses(const TValue& valueArray, size_t valueCount, TValueToKeyConverter valueToKeyConverter = TValueToKeyConverter(),
|
TKeyLess keyLessComparer = TKeyLess(), TKeyEquals keyEqualsComparer = TKeyEquals())
|
{
|
this->~ArrayValueMap();
|
|
TValue* storage = NULL;
|
|
if (valueCount > 0)
|
{
|
storage = new TValue[valueCount];
|
|
for (size_t i = 0; i < valueCount; i++)
|
{
|
storage[i] = &valueArray[i];
|
}
|
}
|
|
new(this) map_type(storage, valueCount, valueToKeyConverter, keyLessComparer, keyEqualsComparer);
|
m_OwnStorage = true;
|
}
|
|
inline void assign(const std::vector<TValue>& values, TValueToKeyConverter valueToKeyConverter = TValueToKeyConverter(),
|
TKeyLess keyLessComparer = TKeyLess(), TKeyEquals keyEqualsComparer = TKeyEquals())
|
{
|
this->~ArrayValueMap();
|
new(this) map_type(values, valueToKeyConverter, keyLessComparer, keyEqualsComparer);
|
}
|
|
inline iterator begin() const
|
{
|
return m_Values;
|
}
|
|
inline iterator end() const
|
{
|
return m_Values + m_ValueCount;
|
}
|
|
template<typename EqualsPredicate>
|
inline iterator find(const TKey& key, const EqualsPredicate& equalsPredicate) const
|
{
|
iterator dataStart = begin();
|
iterator dataEnd = end();
|
iterator ptr = std::lower_bound(dataStart, dataEnd, key, LowerBoundFindComparer(m_ValueToKeyConverter, m_KeyLessComparer));
|
|
for (; ptr != dataEnd && m_KeyEqualsComparer(m_ValueToKeyConverter(*ptr), key); ptr++)
|
{
|
if (equalsPredicate(*ptr))
|
return ptr;
|
}
|
|
return dataEnd;
|
}
|
|
inline iterator find_first(const TKey& key) const
|
{
|
iterator dataStart = begin();
|
iterator dataEnd = end();
|
iterator ptr = std::lower_bound(dataStart, dataEnd, key, LowerBoundFindComparer(m_ValueToKeyConverter, m_KeyLessComparer));
|
|
if (ptr != dataEnd && m_KeyEqualsComparer(m_ValueToKeyConverter(*ptr), key))
|
return ptr;
|
|
return dataEnd;
|
}
|
|
inline iterator lower_bound(const TKey& key) const
|
{
|
return std::lower_bound(begin(), end(), key, LowerBoundFindComparer(m_ValueToKeyConverter, m_KeyLessComparer));
|
}
|
|
inline iterator upper_bound(const TKey& key) const
|
{
|
return std::upper_bound(begin(), end(), key, UpperBoundFindComparer(m_ValueToKeyConverter, m_KeyLessComparer));
|
}
|
|
inline size_t size() const
|
{
|
return m_ValueCount;
|
}
|
|
inline const TValue& operator[](size_t i) const
|
{
|
return m_Values[i];
|
}
|
|
template<typename Mutator>
|
inline void mutate(Mutator& mutator)
|
{
|
size_t count = m_ValueCount;
|
const TValue* values = m_Values;
|
for (size_t i = 0; i < count; i++)
|
mutator(const_cast<TValue*>(values + i));
|
|
m_Values = InitializeInPlace(const_cast<TValue*>(values), count, m_ValueToKeyConverter, m_KeyLessComparer);
|
}
|
};
|
}
|
} // namespace utils
|
} // namespace il2cpp
|
