simple.h

Go to the documentation of this file.

/* *****************************************************************************
 * kblib is a general utility library for C++14 and C++17, intended to provide
 * performant high-level abstractions and more expressive ways to do simple
 * things.
 *
 * Copyright (c) 2021 killerbee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 * ****************************************************************************/
 
#ifndef KBLIB_SIMPLE_H
#define KBLIB_SIMPLE_H
 
#include "iterators.h"
 
#include <bitset>
#include <climits>
#include <cstdint>
#include <initializer_list>
#include <limits>
#include <numeric>
#include <utility>
 
#define KBLIB_DEBUG_LOG_RANGES 0
#if KBLIB_DEBUG_LOG_RANGES
#  include <iostream>
#endif
 
namespace kblib {
 
namespace detail_simple {
   template <typename T>
   struct simple_range {
      const T& low;
      const T& high;
   };
} // namespace detail_simple
 
template <typename T>
constexpr auto in_range(const T& v, detail_simple::simple_range<T> r) {
   return (r.low <= v) and (v < r.high);
}
template <typename T>
constexpr auto in_range_i(const T& v, detail_simple::simple_range<T> r) {
   return (r.low <= v) and (v <= r.high);
}
 
#if KBLIB_USE_CXX17
 
template <typename... Ts>
constexpr bool any_void = (std::is_void_v<Ts> or ...);
 
template <typename F, typename... T>
KBLIB_NODISCARD auto map(F f, T&&... t) noexcept(noexcept(std::tuple{
    kblib::apply(f, std::forward<T>(t))...}))
    -> enable_if_t<
        not any_void<decltype(kblib::apply(f, std::forward<T>(t)))...>,
        decltype(std::tuple{kblib::apply(f, std::forward<T>(t))...})> {
   return std::tuple{kblib::apply(f, std::forward<T>(t))...};
}
 
template <typename F, typename... T>
auto map(F f, T&&... t) noexcept(
    noexcept((static_cast<void>(kblib::apply(f, std::forward<T>(t))), ...)))
    -> enable_if_t<any_void<decltype(kblib::apply(f, std::forward<T>(t)))...>,
                   void> {
   (static_cast<void>(kblib::apply(f, std::forward<T>(t))), ...);
}
#endif
 
template <typename T>
struct KBLIB_NODISCARD RAII_wrapper {
   T t;
   ~RAII_wrapper() noexcept(noexcept(t())) { t(); }
 
   RAII_wrapper(T&& t_)
       : t(std::move(t_)) {}
   RAII_wrapper(const T& t_)
       : t(t_) {}
   RAII_wrapper(const RAII_wrapper&) = delete;
   RAII_wrapper(RAII_wrapper&&) = delete;
   RAII_wrapper& operator=(const RAII_wrapper&) = delete;
   RAII_wrapper& operator=(RAII_wrapper&&) = delete;
};
 
template <typename F>
auto defer(F f) {
   return RAII_wrapper<F>{std::move(f)};
}
 
template <typename BinaryOperation>
KBLIB_NODISCARD constexpr auto flip() -> auto {
   return [](auto&& a, auto&& b) {
      return BinaryOperation{}(static_cast<decltype(b)>(b),
                               static_cast<decltype(a)>(a));
   };
}
 
template <typename BinaryOperation>
KBLIB_NODISCARD constexpr auto flip(BinaryOperation op) -> auto {
   return [op = std::move(op)](auto&& a, auto&& b) {
      return op(static_cast<decltype(b)>(b), static_cast<decltype(a)>(a));
   };
}
 
template <typename T, std::size_t N>
KBLIB_NODISCARD constexpr auto is_consecutive(const T (&array)[N])
    -> enable_if_t<std::is_integral<T>::value, bool> {
   if (N <= 1) {
      return true;
   } else if (N == 2) {
      return (array[1] - array[0]) == 1;
   } else {
      for (std::size_t i = 1; i < N; ++i) {
         if ((array[i] - array[i - 1]) != 1) {
            return false;
         }
      }
      return true;
   }
}
 
KBLIB_NODISCARD constexpr auto filg2(
    const std::bitset<std::numeric_limits<std::uintmax_t>::digits> val) noexcept
    -> int {
   for (auto i : range<int>(to_signed(val.size()) - 1, 0, -1)) {
      if (val[to_unsigned(i)])
         return i;
   }
   return 0;
}
 
template <std::size_t size, typename T, typename... Ts>
struct first_bigger_than
    : std::conditional<sizeof(T) >= size, detail::tag<T>,
                       typename first_bigger_than<size, Ts...>::type> {};
 
template <std::size_t size, typename T>
struct first_bigger_than<size, T>
    : std::conditional_t<sizeof(T) >= size, detail::tag<T>, void> {};
 
template <std::uintmax_t I>
using uint_smallest =
    typename first_bigger_than<1 + filg2(I) / CHAR_BIT, unsigned char,
                               unsigned short, unsigned int, unsigned long,
                               unsigned long long, std::uintmax_t>::type;
 
template <std::uintmax_t I>
using int_smallest =
    typename first_bigger_than<1 + (filg2(I) + 1) / CHAR_BIT, signed char,
                               signed short, signed int, signed long,
                               signed long long, std::uintmax_t>::type;
 
template <std::uintmax_t I>
using uint_smallest_t = typename uint_smallest<I>::type;
 
template <std::uintmax_t I>
using int_smallest_t = typename int_smallest<I>::type;
 
struct identity {
   template <typename T>
   KBLIB_NODISCARD auto operator()(T&& in) -> T&& {
      return static_cast<T&&>(in);
   }
};
 
template <typename T>
auto safe_auto(T&& in) -> T {
   return std::forward<T>(in);
}
 
template <typename T>
auto safe_auto(T& in) -> T& {
   return in;
}
 
template <typename LeftContainer, typename RightContainer>
auto arraycat(LeftContainer A, RightContainer&& B) noexcept(
    noexcept(A.insert(A.end(), B.begin(), B.end()))
    and std::is_nothrow_move_constructible<LeftContainer>::value)
    -> LeftContainer {
   A.insert(A.end(), B.begin(), B.end());
   return std::move(A);
}
 
template <typename T>
KBLIB_NODISCARD constexpr auto a(const std::initializer_list<T>& a) -> auto {
   return a.begin();
}
// use like:
// auto v = a({2, 3, 5, 7, 9, 11})[2];
 
#if KBLIB_USE_CXX20
 
template <typename T>
concept zero_constructible = requires(T t) {
   {t = 0};
};
 
struct zero_t {
   consteval zero_t(int i) { i == 0 ? void() : throw 0; }
   template <zero_constructible T>
   constexpr operator T() const noexcept {
      return 0;
   }
   explicit constexpr operator std::nullptr_t() const noexcept {
      return nullptr;
   }
};
 
#endif
 
} // namespace kblib
 
#undef KBLIB_DEBUG_LOG_RANGES
 
#endif // KBLIB_SIMPLE_H