build.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_BUILD_H
#define KBLIB_BUILD_H
 
#include "tdecl.h"
 
#include "algorithm.h"
#include "fakestd.h"
#include "iterators.h"
#include "traits.h"
 
#include <algorithm>
#include <iterator>
#include <numeric>
#include <tuple>
 
#if __cplusplus >= 201703L
#  include <optional>
#endif
 
namespace kblib {
 
template <typename Container, typename InputIt, typename UnaryFunction>
KBLIB_NODISCARD auto build(InputIt first, InputIt last, UnaryFunction f,
                           typename Container::allocator_type allocator
                           = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   std::transform(first, last, std::back_inserter(out), f);
   return static_cast<void>(out.resize(out.size())), out;
}
template <typename Container, typename InputIt, typename InputIt2,
          typename BinaryFunction>
KBLIB_NODISCARD auto build(InputIt first, InputIt last, InputIt2 first2,
                           BinaryFunction f,
                           typename Container::allocator_type allocator
                           = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   std::transform(first, last, first2, std::back_inserter(out), f);
   return out;
}
 
template <typename Array, typename InputIt, typename UnaryFunction,
          enable_if_t<not is_resizable_v<Array>, int> = 0>
KBLIB_NODISCARD auto build(InputIt first, InputIt last, UnaryFunction f)
    -> Array {
   Array out;
   std::transform(first, last, out.begin(), f);
   return out;
}
template <typename Array, typename InputIt, typename InputIt2,
          typename BinaryFunction,
          enable_if_t<not is_resizable_v<Array>, int> = 0>
KBLIB_NODISCARD auto build(InputIt first, InputIt last, InputIt2 first2,
                           BinaryFunction f) -> Array {
   Array out;
   std::transform(first, last, first2, out.begin(), f);
   return out;
}
 
template <typename Container, typename Functor>
KBLIB_NODISCARD auto build(Functor f, size_t size,
                           typename Container::allocator_type allocator
                           = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   try_reserve(out, size);
   std::generate_n(std::back_inserter(out), size, f);
   return out;
}
 
template <typename Array, typename Functor,
          enable_if_t<not is_resizable_v<Array>, int> = 0>
KBLIB_NODISCARD auto build(Functor f,
                           size_t size = std::tuple_size<Array>::value)
    -> Array {
   Array out;
   std::generate_n(out.begin(), size, f);
   return out;
}
 
// build_dy: workaround for non-allocator-aware dynamic containers
template <typename Container, typename InputIt, typename UnaryFunction>
KBLIB_NODISCARD auto build_dy(InputIt first, InputIt last, UnaryFunction f)
    -> Container {
   Container out;
   std::transform(first, last, std::back_inserter(out), f);
   return out;
}
template <typename Container, typename InputIt, typename InputIt2,
          typename BinaryFunction>
KBLIB_NODISCARD auto build_dy(InputIt first, InputIt last, InputIt2 first2,
                              BinaryFunction f) -> Container {
   Container out;
   std::transform(first, last, first2, std::back_inserter(out), f);
   return out;
}
 
template <typename Container, typename Functor>
KBLIB_NODISCARD auto build_dy(Functor f, size_t size) -> Container {
   Container out;
   try_reserve(out, size);
   std::generate_n(std::back_inserter(out), size, f);
   return out;
}
 
template <typename Container, typename Range, typename UnaryFunction,
          enable_if_t<is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD auto build_dy(Range&& r, UnaryFunction f) -> Container {
   using std::begin;
   using std::end;
   Container out(kblib::size(r));
   std::transform(begin(r), end(r), begin(out), std::ref(f));
   return out;
}
 
#if 0
// I can't overload on both array vs. dynamic container and execution policy
// in any sane way without concepts, so this whole set of functions is cut
// because they're less useful than the array overloads.
template <typename Container, typename ExecutionPolicy, typename InputIt,
          typename UnaryFunction>
KBLIB_NODISCARD auto
build(ExecutionPolicy&& policy, InputIt first, InputIt last, UnaryFunction f,
      KBLIB_UNUSED
      typename Container::allocator_type = typename Container::allocator_type{})
    -> Container {
   Container out;
   std::transform(policy, first, last, std::back_inserter(out), f);
   return static_cast<void>(out.resize(out.size())), out;
}
template <typename Container, typename ExecutionPolicy, typename InputIt,
          typename InputIt2, typename BinaryFunction>
KBLIB_NODISCARD auto
build(ExecutionPolicy&& policy, InputIt first, InputIt last, InputIt2 first2,
      BinaryFunction f,
      KBLIB_UNUSED
      typename Container::allocator_type = typename Container::allocator_type{})
    -> Container {
   Container out;
   std::transform(policy, first, last, first2, std::back_inserter(out), f);
   return out;
}
template <typename Array, typename ExecutionPolicy, typename InputIt,
          typename UnaryFunction,
          typename std::enable_if<
              std::is_convertible<typename std::tuple_size<Array>::value_type,
                                  size_t>::value,
              int>::type = 0>
KBLIB_NODISCARD auto build(ExecutionPolicy&& policy, InputIt first,
                           InputIt last, UnaryFunction f) -> Array {
   Array out;
   std::transform(policy, first, last, out.begin(), f);
   return out;
}
template <typename Array, typename ExecutionPolicy, typename InputIt,
          typename InputIt2, typename BinaryFunction,
          typename std::enable_if<
              std::is_convertible<typename std::tuple_size<Array>::value_type,
                                  size_t>::value,
              int>::type = 0>
KBLIB_NODISCARD auto build(ExecutionPolicy&& policy, InputIt first,
                           InputIt last, InputIt2 first2, BinaryFunction f)
    -> Array {
   Array out;
   std::transform(policy, first, last, first2, out.begin(), f);
   return out;
}
template <typename Container, typename ExecutionPolicy, typename Functor>
KBLIB_NODISCARD auto
build(ExecutionPolicy&& policy, Functor f, size_t size,
      [[gnu::unused]]
      typename Container::allocator_type = typename Container::allocator_type{})
    -> Container {
   Container out(size);
   std::generate_n(policy, out.begin(), size, f);
   return out;
}
template <typename Array, typename ExecutionPolicy, typename Functor,
          typename std::enable_if<
              std::is_convertible<typename std::tuple_size<Array>::value_type,
                                  size_t>::value,
              int>::type = 0>
KBLIB_NODISCARD auto build(ExecutionPolicy&& policy, Functor f,
                           size_t size = std::tuple_size<Array>::value)
    -> Array {
   Array out;
   std::generate_n(policy, out.begin(), size, f);
   return out;
}
#endif
 
namespace detail {
 
   template <typename Container>
   struct buildiota_impl<Container, true> {
      template <typename T>
      constexpr static auto impl(std::size_t count, T value) -> Container {
         Container out;
         try_reserve(out, count);
         while (count-- > 0) {
            out.push_back(value);
            ++value;
         }
         return out;
      }
      template <typename T, typename I>
      constexpr static auto impl(std::size_t count, T value, I incr)
          -> Container {
         Container out;
         try_reserve(out, count);
         while (count-- > 0) {
            out.push_back(value);
            value += incr;
         }
         return out;
      }
   };
 
   template <typename Array>
   struct buildiota_impl<Array, false> {
      template <typename T>
      constexpr static auto impl(T value) -> Array {
         Array out{};
         for (auto& v : out) {
            v = value;
            ++value;
         }
         return out;
      }
      template <typename T, typename I>
      constexpr static auto impl(T value, I incr) -> Array {
         Array out{};
         for (auto& v : out) {
            v = value;
            value += incr;
         }
         return out;
      }
   };
 
} // namespace detail
 
template <typename Container, typename... Args>
KBLIB_NODISCARD constexpr auto buildiota(Args&&... args) -> auto {
   return detail::buildiota_impl<Container, is_resizable_v<Container>>::impl(
       std::forward<Args>(args)...);
}
 
template <typename Container, typename InputIt>
KBLIB_NODISCARD auto build_copy(InputIt first, InputIt last,
                                typename Container::allocator_type allocator
                                = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   std::copy(first, last, std::back_inserter(out));
   return out;
}
 
template <typename Container, typename Range,
          enable_if_t<is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD auto build_copy(Range&& r) -> Container {
   using std::begin;
   using std::end;
   Container out(kblib::size(r));
   std::copy(begin(r), end(r), begin(out));
   return out;
}
 
template <typename Container, typename Range>
KBLIB_NODISCARD auto build_copy(Range&& r,
                                typename Container::allocator_type allocator
                                = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   std::copy(std::begin(r), std::end(r), std::back_inserter(out));
   return out;
}
 
template <typename Container, typename InputIt,
          enable_if_t<not is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD constexpr auto build_copy(InputIt first, InputIt last)
    -> Container {
   Container out{};
   auto pos = std::begin(out);
   auto end = std::end(out);
   for (; first != last and pos != end; ++first, ++pos) {
      *pos = *first;
   }
   return out;
}
 
template <typename Container, typename Range,
          enable_if_t<not is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD constexpr auto build_copy(Range&& r) -> Container {
   Container out{};
   auto first = std::begin(r);
   auto last = std::end(r);
   auto pos = std::begin(out);
   auto end = std::end(out);
   for (; first != last and pos != end; ++first, ++pos) {
      *pos = *first;
   }
   return out;
}
 
template <typename Container, typename InputIt,
          enable_if_t<not is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD auto build_copy(InputIt first, InputIt last, std::size_t size)
    -> Container {
   Container out;
   auto pos = std::begin(out);
   auto end = std::end(out);
   for (std::size_t count = 0; count != size and first != last and pos != end;
        ++first, ++pos, ++count) {
      *pos = *first;
   }
   return out;
}
 
template <typename Container, typename Range,
          enable_if_t<not is_resizable_v<Container>, int> = 0>
KBLIB_NODISCARD auto build_copy(Range&& r, std::size_t size) -> Container {
   Container out;
   auto first = std::begin(r);
   auto last = std::end(r);
   auto pos = std::begin(out);
   auto end = std::end(out);
   for (std::size_t count = 0; count != size and first != last and pos != end;
        ++first, ++pos, ++count) {
      *pos = *first;
   }
   return out;
}
 
template <typename Container, typename InputIt, typename Predicate>
KBLIB_NODISCARD auto build_copy_if(InputIt first, InputIt last, Predicate f,
                                   typename Container::allocator_type allocator
                                   = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   kblib::copy_if(first, last, std::back_inserter(out), f);
   return out;
}
 
template <typename Container, typename InputIt, typename Size>
KBLIB_NODISCARD auto build_copy_n(InputIt first, Size count,
                                  typename Container::allocator_type allocator
                                  = typename Container::allocator_type{})
    -> Container {
   Container out(allocator);
   std::copy_n(first, count, std::back_inserter(out));
   return out;
}
 
template <typename Container, typename InputIt, typename Size,
          typename Predicate>
KBLIB_NODISCARD auto build_copy_n_if(
    InputIt first, Size count, Predicate f,
    typename Container::allocator_type allocator
    = typename Container::allocator_type{}) -> Container {
   Container out(allocator);
   kblib::copy_n_if(first, count, std::back_inserter(out), f);
   return out;
}
 
// transform_accumulate
// transform_partial_sum
 
} // namespace kblib
 
#endif // KBLIB_BUILD_H