431a9c00a5
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
152 lines
4.1 KiB
C++
152 lines
4.1 KiB
C++
#ifndef STAR_ID_MAP_HPP
|
|
#define STAR_ID_MAP_HPP
|
|
|
|
#include "StarMap.hpp"
|
|
#include "StarMathCommon.hpp"
|
|
#include "StarDataStream.hpp"
|
|
|
|
namespace Star {
|
|
|
|
STAR_EXCEPTION(IdMapException, StarException);
|
|
|
|
// Maps key ids to values with auto generated ids in a given id range. Tries
|
|
// to cycle through ids as new values are added and avoid re-using ids until
|
|
// the id space wraps around.
|
|
template <typename BaseMap>
|
|
class IdMapWrapper : private BaseMap {
|
|
public:
|
|
typedef typename BaseMap::iterator iterator;
|
|
typedef typename BaseMap::const_iterator const_iterator;
|
|
typedef typename BaseMap::key_type key_type;
|
|
typedef typename BaseMap::value_type value_type;
|
|
typedef typename BaseMap::mapped_type mapped_type;
|
|
|
|
typedef key_type IdType;
|
|
typedef value_type ValueType;
|
|
typedef mapped_type MappedType;
|
|
|
|
IdMapWrapper();
|
|
IdMapWrapper(IdType min, IdType max);
|
|
|
|
// New valid id that does not exist in this map. Tries not to immediately
|
|
// recycle ids, to avoid temporally close id repeats.
|
|
IdType nextId();
|
|
|
|
// Throws exception if key already exists
|
|
void add(IdType id, MappedType mappedType);
|
|
|
|
// Add with automatically allocated id
|
|
IdType add(MappedType mappedType);
|
|
|
|
void clear();
|
|
|
|
bool operator==(IdMapWrapper const& rhs) const;
|
|
bool operator!=(IdMapWrapper const& rhs) const;
|
|
|
|
using BaseMap::keys;
|
|
using BaseMap::values;
|
|
using BaseMap::pairs;
|
|
using BaseMap::contains;
|
|
using BaseMap::size;
|
|
using BaseMap::empty;
|
|
using BaseMap::get;
|
|
using BaseMap::ptr;
|
|
using BaseMap::maybe;
|
|
using BaseMap::take;
|
|
using BaseMap::maybeTake;
|
|
using BaseMap::remove;
|
|
using BaseMap::value;
|
|
using BaseMap::begin;
|
|
using BaseMap::end;
|
|
using BaseMap::erase;
|
|
|
|
template <typename Base>
|
|
friend DataStream& operator>>(DataStream& ds, IdMapWrapper<Base>& map);
|
|
template <typename Base>
|
|
friend DataStream& operator<<(DataStream& ds, IdMapWrapper<Base> const& map);
|
|
|
|
private:
|
|
IdType m_min;
|
|
IdType m_max;
|
|
IdType m_nextId;
|
|
};
|
|
|
|
template <class Key, class Value>
|
|
using IdMap = IdMapWrapper<Map<Key, Value>>;
|
|
|
|
template <class Key, class Value>
|
|
using IdHashMap = IdMapWrapper<HashMap<Key, Value>>;
|
|
|
|
template <typename BaseMap>
|
|
IdMapWrapper<BaseMap>::IdMapWrapper()
|
|
: m_min(lowest<IdType>()), m_max(highest<IdType>()), m_nextId(m_min) {}
|
|
|
|
template <typename BaseMap>
|
|
IdMapWrapper<BaseMap>::IdMapWrapper(IdType min, IdType max)
|
|
: m_min(min), m_max(max), m_nextId(m_min) {
|
|
starAssert(m_max > m_min);
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
auto IdMapWrapper<BaseMap>::nextId() -> IdType {
|
|
if ((IdType)BaseMap::size() > m_max - m_min)
|
|
throw IdMapException("No id space left in IdMapWrapper");
|
|
|
|
IdType nextId = m_nextId;
|
|
while (BaseMap::contains(nextId))
|
|
nextId = cycleIncrement(nextId, m_min, m_max);
|
|
m_nextId = cycleIncrement(nextId, m_min, m_max);
|
|
return nextId;
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
void IdMapWrapper<BaseMap>::add(IdType id, MappedType mappedType) {
|
|
if (!BaseMap::insert(make_pair(std::move(id), std::move(mappedType))).second)
|
|
throw IdMapException::format("IdMapWrapper::add(id, value) called with pre-existing id '{}'", outputAny(id));
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
auto IdMapWrapper<BaseMap>::add(MappedType mappedType) -> IdType {
|
|
auto id = nextId();
|
|
BaseMap::insert(id, mappedType);
|
|
return id;
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
void IdMapWrapper<BaseMap>::clear() {
|
|
BaseMap::clear();
|
|
m_nextId = m_min;
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
bool IdMapWrapper<BaseMap>::operator==(IdMapWrapper const& rhs) const {
|
|
return tie(m_min, m_max) == tie(rhs.m_min, rhs.m_max) && BaseMap::operator==(rhs);
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
bool IdMapWrapper<BaseMap>::operator!=(IdMapWrapper const& rhs) const {
|
|
return !operator==(rhs);
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
DataStream& operator>>(DataStream& ds, IdMapWrapper<BaseMap>& map) {
|
|
ds.readMapContainer((BaseMap&)map);
|
|
ds.read(map.m_min);
|
|
ds.read(map.m_max);
|
|
ds.read(map.m_nextId);
|
|
return ds;
|
|
}
|
|
|
|
template <typename BaseMap>
|
|
DataStream& operator<<(DataStream& ds, IdMapWrapper<BaseMap> const& map) {
|
|
ds.writeMapContainer((BaseMap const&)map);
|
|
ds.write(map.m_min);
|
|
ds.write(map.m_max);
|
|
ds.write(map.m_nextId);
|
|
return ds;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|