fix windows max min macro problem

include/glaze/core/write_chars.hpp

@@ -51,7 +51,7 @@ namespace glz::detail
          // maximum length for a double should be 24 chars, we use 64 to be sufficient
          if constexpr (detail::resizeable<B>) {
             if (ix + 64 > b.size()) [[unlikely]] {
-               b.resize(std::max(b.size() * 2, ix + 64));
+               b.resize((std::max)(b.size() * 2, ix + 64));
             }
          }
 

include/glaze/frozen/bits/pmh.hpp

@@ -133,7 +133,7 @@ struct seed_or_index {
   using value_type = uint64_t;
 
 private:
-  static constexpr value_type MINUS_ONE = std::numeric_limits<value_type>::max();
+  static constexpr value_type MINUS_ONE = (std::numeric_limits<value_type>::max)();
   static constexpr value_type HIGH_BIT = ~(MINUS_ONE >> 1);
 
   value_type value_ = 0;
@@ -190,7 +190,7 @@ pmh_tables<M, Hash> constexpr make_pmh_tables(const carray<Item, N> &
   carray<seed_or_index, M> G; // Default constructed to "index 0"
 
   // H becomes the second hash table in the resulting pmh function
-  constexpr std::size_t UNUSED = std::numeric_limits<std::size_t>::max();
+  constexpr std::size_t UNUSED = (std::numeric_limits<std::size_t>::max)();
   carray<std::size_t, M> H;
   H.fill(UNUSED);
 

include/glaze/frozen/random.hpp

@@ -71,8 +71,8 @@ namespace glz::frozen
        while (n--)
          operator()();
      }
-     static constexpr result_type min() { return increment == 0u ? 1u : 0u; }
-     static constexpr result_type max() { return modulus - 1u; }
+     static constexpr result_type min_value() { return increment == 0u ? 1u : 0u; }
+     static constexpr result_type max_value() { return modulus - 1u; }
      friend constexpr bool operator==(linear_congruential_engine const &self,
                                       linear_congruential_engine const &other) {
        return self.state_ == other.state_;

include/glaze/json/read.hpp

@@ -908,7 +908,7 @@ namespace glz
 
       struct key_stats_t
       {
-         uint32_t min_length = std::numeric_limits<uint32_t>::max();
+         uint32_t min_length = (std::numeric_limits<uint32_t>::max)();
          uint32_t max_length{};
          uint32_t length_range{};
       };

include/glaze/json/study.hpp

@@ -99,7 +99,7 @@ namespace glz
          {
             size_t deconst_index = i;
             for (auto &param_set : param_sets) {
-               const auto this_size = std::max(param_set.elements.size(), size_t{1});
+               const auto this_size = (std::max)(param_set.elements.size(), size_t{1});
                const auto this_index = deconst_index % this_size;
                deconst_index /= this_size;
                std::visit(

include/glaze/json/write.hpp

@@ -182,7 +182,7 @@ namespace glz
                // we use 4 * n to handle potential escape characters and quoted bounds (excessive safety)
                if constexpr (detail::resizeable<B>) {
                   if ((ix + 4 * n) >= b.size()) [[unlikely]] {
-                     b.resize(std::max(b.size() * 2, ix + 4 * n));
+                     b.resize((std::max)(b.size() * 2, ix + 4 * n));
                   }
                }
 

include/glaze/util/dump.hpp

@@ -91,7 +91,7 @@ namespace glz::detail
       static constexpr auto n = s.size();
 
       if (ix + n > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + n));
+         b.resize((std::max)(b.size() * 2, ix + n));
       }
 
       std::memcpy(b.data() + ix, s.data(), n);
@@ -111,7 +111,7 @@ namespace glz::detail
    inline void dumpn(size_t n, vector_like auto& b, auto&& ix) noexcept
    {
       if (ix + n > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + n));
+         b.resize((std::max)(b.size() * 2, ix + n));
       }
 
       std::fill_n(b.data() + ix, n, c);
@@ -124,7 +124,7 @@ namespace glz::detail
       static constexpr auto n = s.size();
 
       if (ix + n > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + n));
+         b.resize((std::max)(b.size() * 2, ix + n));
       }
 
       std::memcpy(b.data() + ix, s.data(), n);
@@ -143,7 +143,7 @@ namespace glz::detail
    inline void dump(const sv str, vector_like auto& b, auto&& ix) noexcept {
       const auto n = str.size();
       if (ix + n > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + n));
+         b.resize((std::max)(b.size() * 2, ix + n));
       }
 
       std::memcpy(b.data() + ix, str.data(), n);
@@ -250,7 +250,7 @@ namespace glz::detail
    {
       const auto n = bytes.size();
       if (ix + n > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + n));
+         b.resize((std::max)(b.size() * 2, ix + n));
       }
 
       std::memcpy(b.data() + ix, bytes.data(), n);
@@ -261,7 +261,7 @@ namespace glz::detail
    inline void dump(const std::array<uint8_t, N>& bytes, B&& b, auto&& ix) noexcept
    {
       if (ix + N > b.size()) [[unlikely]] {
-         b.resize(std::max(b.size() * 2, ix + N));
+         b.resize((std::max)(b.size() * 2, ix + N));
       }
 
       std::memcpy(b.data() + ix, bytes.data(), N);

include/glaze/util/hash_map.hpp

@@ -104,7 +104,7 @@ namespace glz
             if (index == N) return seed;
          }
 
-         return std::numeric_limits<HashType>::max();
+         return (std::numeric_limits<HashType>::max)();
       }
 
       inline bool sv_neq(const sv s0, const sv s1) noexcept { return s0 != s1; }
@@ -171,7 +171,7 @@ namespace glz
             ++i;
          }
          ht.seed = naive_perfect_hash<N, HashType>(keys);
-         if (ht.seed == std::numeric_limits<HashType>::max()) {
+         if (ht.seed == (std::numeric_limits<HashType>::max)()) {
             throw std::runtime_error("Unable to find perfect hash.");
          }
 
@@ -218,7 +218,7 @@ namespace glz
 
          std::sort(hashes.begin(), hashes.end());
 
-         uint8_t min_diff = std::numeric_limits<uint8_t>::max();
+         uint8_t min_diff = (std::numeric_limits<uint8_t>::max)();
          for (size_t i = 0; i < N - 1; ++i) {
             if ((hashes[i + 1] - hashes[i]) < min_diff) {
                min_diff = hashes[i + 1] - hashes[i];

include/glaze/util/progress_bar.hpp

@@ -21,8 +21,8 @@ namespace glz
          std::string s{};
 
          const size_t one = 1;
-         const auto one_or_total = std::max(total, one);
-         const auto one_or_completed = std::min(completed, one_or_total);
+         const auto one_or_total = (std::max)(total, one);
+         const auto one_or_completed = (std::min)(completed, one_or_total);
          const auto progress = static_cast<double>(one_or_completed) / one_or_total;
          const auto percentage = static_cast<size_t>(std::round(progress * 100));
 
@@ -44,7 +44,7 @@ namespace glz
          }
 
          const auto eta_s = static_cast<size_t>(
-            std::round(((one_or_total - one_or_completed) * time_taken) / std::max(one_or_completed, one)));
+            std::round(((one_or_total - one_or_completed) * time_taken) / (std::max)(one_or_completed, one)));
          const auto minutes = eta_s / 60;
          const auto seconds = eta_s - minutes * 60;
          s += " " + std::to_string(std::lround(percentage)) + "%";

include/glaze/util/strod.hpp

@@ -478,7 +478,7 @@ namespace glz::detail
 #undef expr_stop
          /* read more digits in integral part */
 digi_intg_more :
-      static constexpr uint64_t U64_MAX = std::numeric_limits<uint64_t>::max();  // todo
+      static constexpr uint64_t U64_MAX = (std::numeric_limits<uint64_t>::max)();  // todo
       if ((num_tmp = *cur - zero) < 10) {
          if (!digi_is_digit_or_fp(cur[1])) {
             /* this number is an integer consisting of 20 digits */