King_DuckZ/DoorKeeper
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Replace size_t with uint32_t for template parameter D

Browse source 
This fixes the build on 64-bit machines, where size_t and uint32_t from vector.hpp would mismatch.
This commit is contained in:
King_DuckZ 2015-01-08 12:20:17 +01:00
commit 701366bf86
16 changed files with 78 additions and 69 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/doorkeeper/implem/helpers.hpp
View file

@ -1,9 +1,11 @@
#ifndef id61F9FA08290643D0A947EC0E51060BEA
#define id61F9FA08290643D0A947EC0E51060BEA
#include <cstdint>
namespace dk {
namespace implem {
template <size_t D>
template <uint32_t D>
CoordinateScalarType area ( const Vector<CoordinateScalarType, D>& parVec ) a_pure;
} //namespace implem
} //namespace dk

2
include/doorkeeper/implem/helpers.inl
View file

@ -2,7 +2,7 @@ namespace dk {
namespace implem {
///----------------------------------------------------------------------
///----------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
CoordinateScalarType area (const Vector<CoordinateScalarType, D>& parVec) {
CoordinateScalarType retval(1);
for (size_t d = 0; d < D; ++d) {

12
include/doorkeeper/implem/layer.inl
View file

@ -1,7 +1,7 @@
namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
LayerBase<D>::LayerBase (const coords& parCount, const coords& parTileSize, const coords& parMasterTileSize) :
m_count(parCount / (parMasterTileSize / parTileSize)),
m_tilesize(parTileSize),
@ -14,7 +14,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
void LayerBase<D>::preload (const coords& parFrom, const coords& parTo) {
if (parFrom < m_haveFrom or parTo > m_haveTo) {
this->onPreload(parFrom, parTo);
@ -25,7 +25,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, size_t D>
template <typename T, uint32_t D>
Layer<T, D>::Layer (const coords& parTileSize, const coords& parMasterTileSize, TileMapData<T, D>& parTilemap) :
LayerBase<D>(parTilemap.mapSize(), parTileSize, parMasterTileSize),
m_tilemap(parTilemap)
@ -34,21 +34,21 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, size_t D>
template <typename T, uint32_t D>
typename Layer<T, D>::iterator Layer<T, D>::begin() {
return iterator(&m_tiles, coords(0), this->m_count);
}
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, size_t D>
template <typename T, uint32_t D>
typename Layer<T, D>::iterator Layer<T, D>::end() {
return iterator(&m_tiles, implem::buildPastEndCoordinate<D>(coords(0), this->m_count), this->m_count);
}
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T, size_t D>
template <typename T, uint32_t D>
void Layer<T, D>::onPreload (const coords& parFrom, const coords& parTo) {
m_tiles.clear();
m_tilemap.fetch(m_tiles, parFrom, parTo);

4
include/doorkeeper/implem/mapstreambase.inl
View file

@ -1,7 +1,7 @@
namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <std::size_t D>
template <uint32_t D>
MapStreamBase<D>::MapStreamBase (const coords& parMapSize) :
m_mapSize(parMapSize)
{
@ -9,7 +9,7 @@ namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <std::size_t D>
template <uint32_t D>
void MapStreamBase<D>::read (char* parOut, std::size_t parOutSize, const coords& parFrom, const coords& parTo) {
DK_ASSERT(parOut);
DK_ASSERT(parOutSize > 0);

16
include/doorkeeper/implem/mapstreamraw.inl
View file

@ -8,9 +8,9 @@ namespace dk {
///hardcoded in the device being passed in). The actual name could be
///something like get_device_dimensions().
///---------------------------------------------------------------------
template <std::size_t D, typename Device>
template <uint32_t D, typename Device>
inline
typename std::enable_if<Device::MapDimensions == D, std::size_t>::type err_mismatching_dimension (const Device*) noexcept {
typename std::enable_if<Device::MapDimensions == D, uint32_t>::type err_mismatching_dimension (const Device*) noexcept {
return Device::MapDimensions;
}
@ -22,15 +22,15 @@ namespace dk {
///being passed in). The actual name could be something like
///get_device_dimensions().
///---------------------------------------------------------------------
template <std::size_t D, typename Device>
template <uint32_t D, typename Device>
inline
typename std::enable_if<HasMapDimensions<Device>::result == false, std::size_t>::type err_mismatching_dimension (const Device*) noexcept {
typename std::enable_if<HasMapDimensions<Device>::result == false, uint32_t>::type err_mismatching_dimension (const Device*) noexcept {
return 0;
}
///---------------------------------------------------------------------
///---------------------------------------------------------------------
template <std::size_t D, typename Device>
template <uint32_t D, typename Device>
inline
typename std::enable_if<Device::MapDimensions == D, Vector<CoordinateScalarType, D>>::type retrieve_map_size_from_device (Device* parDevice) {
return parDevice->mapSize();
@ -38,7 +38,7 @@ namespace dk {
///---------------------------------------------------------------------
///---------------------------------------------------------------------
template <std::size_t D, typename Device>
template <uint32_t D, typename Device>
inline
typename std::enable_if<HasMapDimensions<Device>::result == false, Vector<CoordinateScalarType, D>>::type retrieve_map_size_from_device (Device* parDevice) {
return get_map_size_from_device<D>(parDevice);
@ -47,7 +47,7 @@ namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <typename T, std::size_t D>
template <typename T, uint32_t D>
template <typename Device>
MapStreamRaw<T, D>::MapStreamRaw (Device& parDevice) :
MapStreamBase<D>(implem::retrieve_map_size_from_device<D>(&parDevice)),
@ -58,7 +58,7 @@ namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <typename T, std::size_t D>
template <typename T, uint32_t D>
std::size_t MapStreamRaw<T, D>::dataBlockRequested (char* parOut, std::size_t parOutSize, const coords& parFrom, const coords& parTo) {
DK_ASSERT(parOut);

22
include/doorkeeper/implem/tileiterator.inl
View file

@ -1,6 +1,6 @@
namespace dk {
namespace implem {
template <size_t D>
template <uint32_t D>
inline size_t get_index_from_pos (const Vector<CoordinateScalarType, D>& parPos, const Vector<CoordinateScalarType, D>& parSize) {
size_t index = 0;
for (size_t d = 0; d < D; ++d) {
@ -21,7 +21,7 @@ namespace dk {
}
#endif
template <size_t D>
template <uint32_t D>
inline Vector<CoordinateScalarType, D> buildPastEndCoordinate (const Vector<CoordinateScalarType, D>& parFrom, const Vector<CoordinateScalarType, D>& parTo) {
Vector<CoordinateScalarType, D> retval;
for (size_t d = 0; d < D - 1; ++d) {
@ -32,7 +32,7 @@ namespace dk {
}
} //namespace implem
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator() :
m_pos(CoordinateScalarType()),
m_from(CoordinateScalarType()),
@ -44,7 +44,7 @@ namespace dk {
{
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const coords& parFrom, const coords& parTo) :
m_pos(parFrom),
m_from(parFrom),
@ -57,7 +57,7 @@ namespace dk {
DK_ASSERT(parData);
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const coords& parFrom, const coords& parTo, const coords& parAreaFrom, const coords& parAreaTo) :
m_pos(parFrom),
m_from(parFrom),
@ -70,7 +70,7 @@ namespace dk {
DK_ASSERT(parData);
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
TileIterator<T, D, T1>::TileIterator (qualif_vector_type* parData, const coords& parFrom, const coords& parTo, const coords& parAreaFrom, const coords& parAreaTo, const coords& parSubdiv) :
m_pos(parFrom),
m_from(parFrom),
@ -83,7 +83,7 @@ namespace dk {
DK_ASSERT(parData);
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
void TileIterator<T, D, T1>::increment() {
if (m_subindex < m_maxsubindex) {
++m_subindex;
@ -101,7 +101,7 @@ namespace dk {
++m_pos[D - 1];
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
void TileIterator<T, D, T1>::decrement() {
if (m_maxsubindex > 0 and m_subindex == 0) {
--m_subindex;
@ -120,17 +120,17 @@ namespace dk {
++m_pos[D - 1];
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
void TileIterator<T, D, T1>::advance (size_t parAdvance) {
//TODO: implement
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
ptrdiff_t TileIterator<T, D, T1>::distance_to (const TileIterator& parOther) {
return std::distance(this->get_current_index(), parOther.get_current_index());
}
template <typename T, size_t D, typename T1>
template <typename T, uint32_t D, typename T1>
bool TileIterator<T, D, T1>::equal (const TileIterator& parOther) const {
return m_data == parOther.m_data and m_pos == parOther.m_pos;
}

6
include/doorkeeper/implem/tilemapdata.inl
View file

@ -1,7 +1,7 @@
namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <typename T, std::size_t D>
template <typename T, uint32_t D>
TileMapData<T, D>::TileMapData (std::unique_ptr<MapStreamBase<D>>&& parStream) :
m_mapstream(std::move(parStream))
{
@ -9,7 +9,7 @@ namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <typename T, std::size_t D>
template <typename T, uint32_t D>
void TileMapData<T, D>::fetch (std::vector<T>& parOut, const coords& parFrom, const coords& parTo) {
DK_ASSERT(parFrom >= coords(0));
DK_ASSERT(parFrom < parTo);
@ -27,7 +27,7 @@ namespace dk {
///-------------------------------------------------------------------------
///-------------------------------------------------------------------------
template <typename T, std::size_t D>
template <typename T, uint32_t D>
const typename TileMapData<T, D>::coords& TileMapData<T, D>::mapSize() const {
return m_mapstream->mapSize();
}

10
include/doorkeeper/implem/tyler.inl
View file

@ -1,7 +1,7 @@
namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
Tyler<D>::Tyler (const coords& parSize, const coords& parTileSize) :
m_size(parSize),
m_tilesize(parTileSize)
@ -11,7 +11,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
typename Tyler<D>::coords::value_type Tyler<D>::tiles_count() const {
typename coords::value_type retval = 1;
for (size_t d = 0; d < D; ++d) {
@ -22,7 +22,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
template <typename T>
Layer<T, D>& Tyler<D>::push_layer (TileMapData<T, D>& parTilemap) {
auto newLayer = new Layer<T, D>(m_tilesize, m_tilesize, parTilemap);
@ -34,7 +34,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
template <typename T>
Layer<T, D>& Tyler<D>::push_layer (TileMapData<T, D>& parTilemap, const coords& parSubdiv) {
auto newLayer = new Layer<T, D>(m_tilesize / parSubdiv, m_tilesize, parTilemap);
@ -46,7 +46,7 @@ namespace dk {
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <size_t D>
template <uint32_t D>
void Tyler<D>::preload (const coords& parFrom, const coords& parTo) {
for (auto& layer : m_layers) {
layer->preload(parFrom, parTo);

22
include/doorkeeper/implem/viewport.inl
View file

@ -1,11 +1,11 @@
namespace dk {
template <size_t D>
template <uint32_t D>
Viewport<D>::Viewport (Tyler<D>& parTyler) :
m_tyler(parTyler)
{
}
template <size_t D>
template <uint32_t D>
Viewport<D>::Viewport (Tyler<D>& parTyler, const coords& parSize, const coords& parPos) :
m_size(parSize),
m_position(parPos),
@ -16,14 +16,14 @@ namespace dk {
m_tyler.preload(m_position, m_position + m_size);
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::iterator Viewport<D>::begin (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType;
return IterType(&parLayer.m_tiles, m_position, m_position + m_size, coords(0), m_tyler.map_size());
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::iterator Viewport<D>::end (Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::iterator IterType;
@ -31,26 +31,26 @@ namespace dk {
return IterType(&parLayer.m_tiles, implem::buildPastEndCoordinate(m_position, to), to, coords(0), m_tyler.map_size());
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::begin (const Layer<T, D>& parLayer) const {
return this->cbegin(parLayer);
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::end (const Layer<T, D>& parLayer) const {
return this->cend(parLayer);
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cbegin (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType;
return IterType(&parLayer.m_tiles, m_position, m_position + m_size, coords(0), m_tyler.map_size());
}
template <size_t D>
template <uint32_t D>
template <typename T>
typename Layer<T, D>::const_iterator Viewport<D>::cend (const Layer<T, D>& parLayer) const {
typedef typename Layer<T, D>::const_iterator IterType;
@ -58,7 +58,7 @@ namespace dk {
return IterType(&parLayer.m_tiles, implem::buildPastEndCoordinate(m_position, to), to, coords(0), m_tyler.map_size());
}
template <size_t D>
template <uint32_t D>
void Viewport<D>::setSize (const coords& parSize) {
DK_ASSERT(m_position <= m_position + parSize);
DK_ASSERT(parSize + m_position <= m_tyler.map_size());
@ -66,7 +66,7 @@ namespace dk {
m_tyler.preload(m_position, m_position + m_size);
}
template <size_t D>
template <uint32_t D>
void Viewport<D>::setFrom (const coords& parFrom) {
DK_ASSERT(parFrom <= parFrom + m_size);
DK_ASSERT(m_size + parFrom <= m_tyler.map_size());
@ -74,7 +74,7 @@ namespace dk {
m_tyler.preload(m_position, m_position + m_size);
}
template <size_t D>
template <uint32_t D>
void Viewport<D>::setFromSize (const coords& parFrom, const coords& parSize) {
DK_ASSERT(parFrom <= parFrom + parSize);
DK_ASSERT(parSize + parFrom <= m_tyler.map_size());