less header pollution

2 files changed, 84 insertions, 92 deletions

diff --git a/compat/format.hpp b/compat/format.hpp
index 4fa05f26..9a61dd96 100644
--- a/compat/format.hpp
+++ b/compat/format.hpp
@@ -1,9 +1,10 @@
 #pragma once
 #include <fmt/core.h>
 #include <fmt/compile.h>
-#include <Corrade/Utility/Move.h>
 #include <Corrade/Containers/StringView.h>
 #include <Corrade/Containers/String.h>
+#include <Corrade/Utility/Math.h>
+#include <Corrade/Utility/Move.h>
 
 namespace fmt {
 
@@ -52,7 +53,7 @@ size_t snformat(char(&buf)[N], Fmt&& fmt, Xs&&... args)
 {
     constexpr size_t n = N > 0 ? N - 1 : 0;
     auto result = fmt::format_to_n(buf, n, Corrade::Utility::forward<Fmt>(fmt), Corrade::Utility::forward<Xs>(args)...);
-    const auto len = std::min(n, result.size);
+    const auto len = Utility::min(n, result.size);
     if constexpr(N > 0)
         buf[len] = '\0';
     return len;
diff --git a/src/RTree.hpp b/src/RTree.hpp
index de175fbd..01ce9b5b 100644
--- a/src/RTree.hpp
+++ b/src/RTree.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
 #include "RTree.h"
-#include "RTree-search.hpp"
+//#include "RTree-search.hpp"
 
-#include <math.h>
-#include <stdlib.h>
-#include <limits>
+#include <cmath>
+#include <cstddef>
 #include <algorithm>
+#include <Corrade/Utility/Math.h>
 
 #ifdef __GNUG__
 #pragma GCC diagnostic push
@@ -14,21 +14,12 @@
 #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
 #endif
 
-#undef _DEBUG
+#undef RTREE_DEBUG
 #ifndef FM_NO_DEBUG
-#define _DEBUG
+#define RTREE_DEBUG
 #endif
 
 #include "compat/assert.hpp"
-//#define ASSERT assert // RTree uses ASSERT( condition )
-#undef ASSERT
-#define ASSERT fm_assert
-#ifndef Min
-  #define Min std::min
-#endif //Min
-#ifndef Max
-  #define Max std::max
-#endif //Max
 
 #ifndef RTREE_NO_EXTERN_TEMPLATE
 extern template struct floormat::detail::rtree_pool<RTree<floormat::uint64_t, float, 2, float>::Node>;
@@ -85,30 +76,30 @@ public:
   }
 
   template< typename TYPE >
-  size_t Write(const TYPE& a_value)
+  std::size_t Write(const TYPE& a_value)
   {
-    ASSERT(m_file);
+    fm_assert(m_file);
     return fwrite((void*)&a_value, sizeof(a_value), 1, m_file);
   }
 
   template< typename TYPE >
-  size_t WriteArray(const TYPE* a_array, int a_count)
+  std::size_t WriteArray(const TYPE* a_array, int a_count)
   {
-    ASSERT(m_file);
+    fm_assert(m_file);
     return fwrite(const_cast<void*>((const void*)a_array), sizeof(TYPE) * a_count, 1, m_file);
   }
 
   template< typename TYPE >
-  size_t Read(TYPE& a_value)
+  std::size_t Read(TYPE& a_value)
   {
-    ASSERT(m_file);
+    fm_assert(m_file);
     return fread((void*)&a_value, sizeof(a_value), 1, m_file);
   }
 
   template< typename TYPE >
-  size_t ReadArray(TYPE* a_array, int a_count)
+  std::size_t ReadArray(TYPE* a_array, int a_count)
   {
-    ASSERT(m_file);
+    fm_assert(m_file);
     return fread((void*)a_array, sizeof(TYPE) * a_count, 1, m_file);
   }
 };
@@ -118,9 +109,9 @@ public:
 RTREE_TEMPLATE
 RTREE_QUAL::RTree()
 {
-  static_assert(std::numeric_limits<ELEMTYPEREAL>::is_iec559, "'ELEMTYPEREAL' accepts floating-point types only");
-  ASSERT(MAXNODES > MINNODES);
-  ASSERT(MINNODES > 0);
+  static_assert(std::is_floating_point_v<ELEMTYPEREAL>, "'ELEMTYPEREAL' accepts floating-point types only");
+  fm_assert(MAXNODES > MINNODES);
+  fm_assert(MINNODES > 0);
 
   // Precomputed volumes of the unit spheres for the first few dimensions
   const float UNIT_SPHERE_VOLUMES[] = {
@@ -166,12 +157,12 @@ RTREE_QUAL::~RTree() noexcept
 RTREE_TEMPLATE
 void RTREE_QUAL::Insert(const ELEMTYPE a_min[NUMDIMS], const ELEMTYPE a_max[NUMDIMS], const DATATYPE& a_dataId)
 {
-#ifdef _DEBUG
+#ifdef RTREE_DEBUG
   for(int index=0; index<NUMDIMS; ++index)
   {
-    ASSERT(a_min[index] <= a_max[index]);
+    fm_assert(a_min[index] <= a_max[index]);
   }
-#endif //_DEBUG
+#endif //RTREE_DEBUG
 
   Branch branch;
   branch.m_data = a_dataId;
@@ -190,12 +181,12 @@ void RTREE_QUAL::Insert(const ELEMTYPE a_min[NUMDIMS], const ELEMTYPE a_max[NUMD
 RTREE_TEMPLATE
 void RTREE_QUAL::Remove(const ELEMTYPE a_min[NUMDIMS], const ELEMTYPE a_max[NUMDIMS], const DATATYPE& a_dataId)
 {
-#ifdef _DEBUG
+#ifdef RTREE_DEBUG
   for(int index=0; index<NUMDIMS; ++index)
   {
-    ASSERT(a_min[index] <= a_max[index]);
+    fm_assert(a_min[index] <= a_max[index]);
   }
-#endif //_DEBUG
+#endif //RTREE_DEBUG
 
   Rect rect;
 
@@ -496,8 +487,8 @@ void RTREE_QUAL::Reset()
 RTREE_TEMPLATE
 void RTREE_QUAL::RemoveAllRec(Node* a_node)
 {
-  ASSERT(a_node);
-  ASSERT(a_node->m_level >= 0);
+  fm_assert(a_node);
+  fm_assert(a_node->m_level >= 0);
 
   if(a_node->IsInternalNode()) // This is an internal node in the tree
   {
@@ -527,7 +518,7 @@ typename RTREE_QUAL::Node* RTREE_QUAL::AllocNode()
 RTREE_TEMPLATE
 void RTREE_QUAL::FreeNode(Node* a_node)
 {
-  ASSERT(a_node);
+  fm_assert(a_node);
 
 #ifdef RTREE_DONT_USE_MEMPOOLS
   delete a_node;
@@ -590,8 +581,8 @@ void RTREE_QUAL::InitRect(Rect* a_rect)
 RTREE_TEMPLATE
 bool RTREE_QUAL::InsertRectRec(const Branch& a_branch, Node* a_node, Node** a_newNode, int a_level)
 {
-  ASSERT(a_node && a_newNode);
-  ASSERT(a_level >= 0 && a_level <= a_node->m_level);
+  fm_assert(a_node && a_newNode);
+  fm_assert(a_level >= 0 && a_level <= a_node->m_level);
 
   // recurse until we reach the correct level for the new record. data records
   // will always be called with a_level == 0 (leaf)
@@ -635,7 +626,7 @@ bool RTREE_QUAL::InsertRectRec(const Branch& a_branch, Node* a_node, Node** a_ne
   else
   {
     // Should never occur
-    ASSERT(0);
+    fm_assert(0);
     return false;
   }
 }
@@ -651,14 +642,14 @@ bool RTREE_QUAL::InsertRectRec(const Branch& a_branch, Node* a_node, Node** a_ne
 RTREE_TEMPLATE
 bool RTREE_QUAL::InsertRect(const Branch& a_branch, Node** a_root, int a_level)
 {
-  ASSERT(a_root);
-  ASSERT(a_level >= 0 && a_level <= (*a_root)->m_level);
-#ifdef _DEBUG
+  fm_assert(a_root);
+  fm_assert(a_level >= 0 && a_level <= (*a_root)->m_level);
+#ifdef RTREE_DEBUG
   for(int index=0; index < NUMDIMS; ++index)
   {
-    ASSERT(a_branch.m_rect.m_min[index] <= a_branch.m_rect.m_max[index]);
+    fm_assert(a_branch.m_rect.m_min[index] <= a_branch.m_rect.m_max[index]);
   }
-#endif //_DEBUG
+#endif //RTREE_DEBUG
 
   Node* newNode;
 
@@ -694,7 +685,7 @@ bool RTREE_QUAL::InsertRect(const Branch& a_branch, Node** a_root, int a_level)
 RTREE_TEMPLATE
 typename RTREE_QUAL::Rect RTREE_QUAL::NodeCover(Node* a_node)
 {
-  ASSERT(a_node);
+  fm_assert(a_node);
 
   Rect rect = a_node->m_branch[0].m_rect;
   for(int index = 1; index < a_node->m_count; ++index)
@@ -713,8 +704,8 @@ typename RTREE_QUAL::Rect RTREE_QUAL::NodeCover(Node* a_node)
 RTREE_TEMPLATE
 bool RTREE_QUAL::AddBranch(const Branch* a_branch, Node* a_node, Node** a_newNode)
 {
-  ASSERT(a_branch);
-  ASSERT(a_node);
+  fm_assert(a_branch);
+  fm_assert(a_node);
 
   if(a_node->m_count < MAXNODES)  // Split won't be necessary
   {
@@ -725,7 +716,7 @@ bool RTREE_QUAL::AddBranch(const Branch* a_branch, Node* a_node, Node** a_newNod
   }
   else
   {
-    ASSERT(a_newNode);
+    fm_assert(a_newNode);
 
     SplitNode(a_node, a_branch, a_newNode);
     return true;
@@ -738,8 +729,8 @@ bool RTREE_QUAL::AddBranch(const Branch* a_branch, Node* a_node, Node** a_newNod
 RTREE_TEMPLATE
 void RTREE_QUAL::DisconnectBranch(Node* a_node, int a_index)
 {
-  ASSERT(a_node && (a_index >= 0) && (a_index < MAXNODES));
-  ASSERT(a_node->m_count > 0);
+  fm_assert(a_node && (a_index >= 0) && (a_index < MAXNODES));
+  fm_assert(a_node->m_count > 0);
 
   // Remove element by swapping with the last element to prevent gaps in array
   a_node->m_branch[a_index] = a_node->m_branch[a_node->m_count - 1];
@@ -756,7 +747,7 @@ void RTREE_QUAL::DisconnectBranch(Node* a_node, int a_index)
 RTREE_TEMPLATE
 int RTREE_QUAL::PickBranch(const Rect* a_rect, Node* a_node)
 {
-  ASSERT(a_rect && a_node);
+  fm_assert(a_rect && a_node);
 
   bool firstTime = true;
   ELEMTYPEREAL increase;
@@ -794,14 +785,14 @@ int RTREE_QUAL::PickBranch(const Rect* a_rect, Node* a_node)
 RTREE_TEMPLATE
 typename RTREE_QUAL::Rect RTREE_QUAL::CombineRect(const Rect* a_rectA, const Rect* a_rectB)
 {
-  ASSERT(a_rectA && a_rectB);
+  fm_assert(a_rectA && a_rectB);
 
   Rect newRect;
 
   for(int index = 0; index < NUMDIMS; ++index)
   {
-    newRect.m_min[index] = Min(a_rectA->m_min[index], a_rectB->m_min[index]);
-    newRect.m_max[index] = Max(a_rectA->m_max[index], a_rectB->m_max[index]);
+    newRect.m_min[index] = Corrade::Utility::min(a_rectA->m_min[index], a_rectB->m_min[index]);
+    newRect.m_max[index] = Corrade::Utility::max(a_rectA->m_max[index], a_rectB->m_max[index]);
   }
 
   return newRect;
@@ -816,8 +807,8 @@ typename RTREE_QUAL::Rect RTREE_QUAL::CombineRect(const Rect* a_rectA, const Rec
 RTREE_TEMPLATE
 void RTREE_QUAL::SplitNode(Node* a_node, const Branch* a_branch, Node** a_newNode)
 {
-  ASSERT(a_node);
-  ASSERT(a_branch);
+  fm_assert(a_node);
+  fm_assert(a_branch);
 
   // Could just use local here, but member or external is faster since it is reused
   PartitionVars localVars;
@@ -837,7 +828,7 @@ void RTREE_QUAL::SplitNode(Node* a_node, const Branch* a_branch, Node** a_newNod
   a_node->m_count = 0;
   LoadNodes(a_node, *a_newNode, parVars);
 
-  ASSERT((a_node->m_count + (*a_newNode)->m_count) == parVars->m_total);
+  fm_assert((a_node->m_count + (*a_newNode)->m_count) == parVars->m_total);
 }
 
 
@@ -845,7 +836,7 @@ void RTREE_QUAL::SplitNode(Node* a_node, const Branch* a_branch, Node** a_newNod
 RTREE_TEMPLATE
 ELEMTYPEREAL RTREE_QUAL::RectVolume(Rect* a_rect)
 {
-  ASSERT(a_rect);
+  fm_assert(a_rect);
 
   ELEMTYPEREAL volume = (ELEMTYPEREAL)1;
 
@@ -854,7 +845,7 @@ ELEMTYPEREAL RTREE_QUAL::RectVolume(Rect* a_rect)
     volume *= a_rect->m_max[index] - a_rect->m_min[index];
   }
 
-  ASSERT(volume >= (ELEMTYPEREAL)0);
+  fm_assert(volume >= (ELEMTYPEREAL)0);
 
   return volume;
 }
@@ -864,7 +855,7 @@ ELEMTYPEREAL RTREE_QUAL::RectVolume(Rect* a_rect)
 RTREE_TEMPLATE
 ELEMTYPEREAL RTREE_QUAL::RectSphericalVolume(Rect* a_rect)
 {
-  ASSERT(a_rect);
+  fm_assert(a_rect);
 
   ELEMTYPEREAL sumOfSquares = (ELEMTYPEREAL)0;
   ELEMTYPEREAL radius;
@@ -875,7 +866,7 @@ ELEMTYPEREAL RTREE_QUAL::RectSphericalVolume(Rect* a_rect)
     sumOfSquares += halfExtent * halfExtent;
   }
 
-  radius = (ELEMTYPEREAL)sqrt(sumOfSquares);
+  radius = (ELEMTYPEREAL)std::sqrt(sumOfSquares);
 
   // Pow maybe slow, so test for common dims like 2,3 and just use x*x, x*x*x.
   if(NUMDIMS == 3)
@@ -888,7 +879,7 @@ ELEMTYPEREAL RTREE_QUAL::RectSphericalVolume(Rect* a_rect)
   }
   else
   {
-    return (ELEMTYPEREAL)(pow(radius, (ELEMTYPEREAL)NUMDIMS) * m_unitSphereVolume);
+    return (ELEMTYPEREAL)(std::pow(radius, (ELEMTYPEREAL)NUMDIMS) * m_unitSphereVolume);
   }
 }
 
@@ -909,10 +900,10 @@ ELEMTYPEREAL RTREE_QUAL::CalcRectVolume(Rect* a_rect)
 RTREE_TEMPLATE
 void RTREE_QUAL::GetBranches(Node* a_node, const Branch* a_branch, PartitionVars* a_parVars)
 {
-  ASSERT(a_node);
-  ASSERT(a_branch);
+  fm_assert(a_node);
+  fm_assert(a_branch);
 
-  ASSERT(a_node->m_count == MAXNODES);
+  fm_assert(a_node->m_count == MAXNODES);
 
   // Load the branch buffer
   for(int index=0; index < MAXNODES; ++index)
@@ -946,7 +937,7 @@ void RTREE_QUAL::GetBranches(Node* a_node, const Branch* a_branch, PartitionVars
 RTREE_TEMPLATE
 void RTREE_QUAL::ChoosePartition(PartitionVars* a_parVars, int a_minFill)
 {
-  ASSERT(a_parVars);
+  fm_assert(a_parVars);
 
   ELEMTYPEREAL biggestDiff;
   int group, chosen = 0, betterGroup = 0;
@@ -1015,8 +1006,8 @@ void RTREE_QUAL::ChoosePartition(PartitionVars* a_parVars, int a_minFill)
     }
   }
 
-  ASSERT((a_parVars->m_count[0] + a_parVars->m_count[1]) == a_parVars->m_total);
-  ASSERT((a_parVars->m_count[0] >= a_parVars->m_minFill) &&
+  fm_assert((a_parVars->m_count[0] + a_parVars->m_count[1]) == a_parVars->m_total);
+  fm_assert((a_parVars->m_count[0] >= a_parVars->m_minFill) &&
         (a_parVars->m_count[1] >= a_parVars->m_minFill));
 }
 
@@ -1025,20 +1016,20 @@ void RTREE_QUAL::ChoosePartition(PartitionVars* a_parVars, int a_minFill)
 RTREE_TEMPLATE
 void RTREE_QUAL::LoadNodes(Node* a_nodeA, Node* a_nodeB, PartitionVars* a_parVars)
 {
-  ASSERT(a_nodeA);
-  ASSERT(a_nodeB);
-  ASSERT(a_parVars);
+  fm_assert(a_nodeA);
+  fm_assert(a_nodeB);
+  fm_assert(a_parVars);
 
   for(int index=0; index < a_parVars->m_total; ++index)
   {
-    ASSERT(a_parVars->m_partition[index] == 0 || a_parVars->m_partition[index] == 1);
+    fm_assert(a_parVars->m_partition[index] == 0 || a_parVars->m_partition[index] == 1);
 
     int targetNodeIndex = a_parVars->m_partition[index];
     Node* targetNodes[] = {a_nodeA, a_nodeB};
 
     // It is assured that AddBranch here will not cause a node split.
     bool nodeWasSplit = AddBranch(&a_parVars->m_branchBuf[index], targetNodes[targetNodeIndex], NULL);
-    ASSERT(!nodeWasSplit);
+    fm_assert(!nodeWasSplit);
   }
 }
 
@@ -1047,7 +1038,7 @@ void RTREE_QUAL::LoadNodes(Node* a_nodeA, Node* a_nodeB, PartitionVars* a_parVar
 RTREE_TEMPLATE
 void RTREE_QUAL::InitParVars(PartitionVars* a_parVars, int a_maxRects, int a_minFill)
 {
-  ASSERT(a_parVars);
+  fm_assert(a_parVars);
 
   a_parVars->m_count[0] = a_parVars->m_count[1] = 0;
   a_parVars->m_area[0] = a_parVars->m_area[1] = (ELEMTYPEREAL)0;
@@ -1097,8 +1088,8 @@ void RTREE_QUAL::PickSeeds(PartitionVars* a_parVars)
 RTREE_TEMPLATE
 void RTREE_QUAL::Classify(int a_index, int a_group, PartitionVars* a_parVars)
 {
-  ASSERT(a_parVars);
-  ASSERT(PartitionVars::NOT_TAKEN == a_parVars->m_partition[a_index]);
+  fm_assert(a_parVars);
+  fm_assert(PartitionVars::NOT_TAKEN == a_parVars->m_partition[a_index]);
 
   a_parVars->m_partition[a_index] = a_group;
 
@@ -1126,8 +1117,8 @@ void RTREE_QUAL::Classify(int a_index, int a_group, PartitionVars* a_parVars)
 RTREE_TEMPLATE
 bool RTREE_QUAL::RemoveRect(Rect* a_rect, const DATATYPE& a_id, Node** a_root)
 {
-  ASSERT(a_rect && a_root);
-  ASSERT(*a_root);
+  fm_assert(a_rect && a_root);
+  fm_assert(*a_root);
 
   ListNode* reInsertList = NULL;
 
@@ -1160,7 +1151,7 @@ bool RTREE_QUAL::RemoveRect(Rect* a_rect, const DATATYPE& a_id, Node** a_root)
     {
       Node* tempNode = (*a_root)->m_branch[0].m_child;
 
-      ASSERT(tempNode);
+      fm_assert(tempNode);
       FreeNode(*a_root);
       *a_root = tempNode;
     }
@@ -1180,8 +1171,8 @@ bool RTREE_QUAL::RemoveRect(Rect* a_rect, const DATATYPE& a_id, Node** a_root)
 RTREE_TEMPLATE
 bool RTREE_QUAL::RemoveRectRec(Rect* a_rect, const DATATYPE& a_id, Node* a_node, ListNode** a_listNode)
 {
-  ASSERT(a_rect && a_node && a_listNode);
-  ASSERT(a_node->m_level >= 0);
+  fm_assert(a_rect && a_node && a_listNode);
+  fm_assert(a_node->m_level >= 0);
 
   if(a_node->IsInternalNode())  // not a leaf node
   {
@@ -1227,7 +1218,7 @@ bool RTREE_QUAL::RemoveRectRec(Rect* a_rect, const DATATYPE& a_id, Node* a_node,
 RTREE_TEMPLATE
 bool RTREE_QUAL::Overlap(Rect* a_rectA, Rect* a_rectB) const
 {
-  ASSERT(a_rectA && a_rectB);
+  fm_assert(a_rectA && a_rectB);
 
   for(int index=0; index < NUMDIMS; ++index)
   {
@@ -1258,10 +1249,10 @@ void RTREE_QUAL::ReInsert(Node* a_node, ListNode** a_listNode)
 RTREE_TEMPLATE
 void RTREE_QUAL::ListTree(std::vector<Rect>& treeList, std::vector<Node*>& toVisit) const
 {
-  ASSERT(m_root);
-  ASSERT(m_root->m_level >= 0);
+  fm_assert(m_root);
+  fm_assert(m_root->m_level >= 0);
 
-  size_t count = (size_t)Count();
+  std::size_t count = (std::size_t)Count();
   treeList.clear();
   treeList.reserve(count);
   toVisit.clear();
@@ -1320,7 +1311,7 @@ void RTree<DATATYPE, ELEMTYPE, NUMDIMS, ELEMTYPEREAL, TMAXNODES, TMINNODES>::Get
 RTREE_TEMPLATE
 typename RTREE_QUAL::Iterator::StackElement& RTREE_QUAL::Iterator::Pop()
 {
-    ASSERT(m_tos > 0);
+    fm_assert(m_tos > 0);
     --m_tos;
     return m_stack[m_tos];
 }
@@ -1331,13 +1322,13 @@ void RTREE_QUAL::Iterator::Push(RTree::Node* a_node, int a_branchIndex)
     m_stack[m_tos].m_node = a_node;
     m_stack[m_tos].m_branchIndex = a_branchIndex;
     ++m_tos;
-    ASSERT(m_tos <= MAX_STACK);
+    fm_assert(m_tos <= MAX_STACK);
 }
 
 RTREE_TEMPLATE
 void RTREE_QUAL::Iterator::GetBounds(ELEMTYPE a_min[NUMDIMS], ELEMTYPE a_max[NUMDIMS])
 {
-    ASSERT(IsNotNull());
+    fm_assert(IsNotNull());
     StackElement& curTos = m_stack[m_tos - 1];
     Branch& curBranch = curTos.m_node->m_branch[curTos.m_branchIndex];
 
@@ -1351,7 +1342,7 @@ void RTREE_QUAL::Iterator::GetBounds(ELEMTYPE a_min[NUMDIMS], ELEMTYPE a_max[NUM
 RTREE_TEMPLATE
 const DATATYPE& RTREE_QUAL::Iterator::operator*() const
 {
-    ASSERT(IsNotNull());
+    fm_assert(IsNotNull());
     const StackElement& curTos = m_stack[m_tos - 1];
     return curTos.m_node->m_branch[curTos.m_branchIndex].m_data;
 }
@@ -1359,7 +1350,7 @@ const DATATYPE& RTREE_QUAL::Iterator::operator*() const
 RTREE_TEMPLATE
 DATATYPE& RTREE_QUAL::Iterator::operator*()
 {
-    ASSERT(IsNotNull());
+    fm_assert(IsNotNull());
     StackElement& curTos = m_stack[m_tos - 1];
     return curTos.m_node->m_branch[curTos.m_branchIndex].m_data;
 }
@@ -1407,7 +1398,7 @@ bool RTREE_QUAL::Iterator::FindNextData()
     }
 }
 
-#undef _DEBUG
+#undef RTREE_DEBUG
 #undef ASSERT
 
 #ifdef __GNUG__