stl.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * 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, version 3.
 *
 * 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.
 */
#ifndef PLASK__UTILS_STL_H
#define PLASK__UTILS_STL_H
 
#include <algorithm>
#include <cstddef> // for std::size_t
 
namespace plask {
 
template <typename map_t>
inline typename map_t::mapped_type map_find(map_t& map, const typename map_t::key_type& to_find, typename map_t::mapped_type&& if_not_found = nullptr) {
    auto f = map.find(to_find);
    return f == map.end() ? std::forward<typename map_t::mapped_type>(if_not_found) : f->second;
}
 
/*
 * Try find value in (const) map by key and return @a if_not_found value if object was not found.
 * @param map map to find in it
 * @param to_find key to find
 * @param if_not_found value to return when there is no object with @a to_find key in @a map
 * @return founded object or @a if_not_found value
 */
/*template <typename map_t>
inline const typename map_t::mapped_type map_find(const map_t& map, const typename map_t::key_type& to_find, const typename map_t::mapped_type&& if_not_found = nullptr) {
    auto f = map.find(to_find);
    return f == map.end() ? std::forward<const typename map_t::mapped_type>(if_not_found) : f->second;
}*/
 
template <typename Iter, typename Val>
inline Iter find_nearest_using_lower_bound(Iter begin, Iter end, const Val& to_find, Iter lower_bound) {
    if (lower_bound == begin) return lower_bound; //before first
    if (lower_bound == end) return lower_bound-1; //after last
    Iter lo_candidate = lower_bound - 1;
    //now: *lo_candidate <= to_find < *lower_bound
    if (to_find - *lo_candidate <= *lower_bound - to_find) //nearest to *lo_candidate?
        return lo_candidate;
    else
        return lower_bound;
}
 
template <typename Iter, typename Val>
inline Iter find_nearest_binary(Iter begin, Iter end, const Val& to_find) {
    return find_nearest_using_lower_bound(begin, end, to_find, std::lower_bound(begin, end, to_find));
}
 
template <typename... Types>
struct VariadicTemplateTypesHolder {};
 
template <typename ForwadIterator>
std::ostream& printRange(std::ostream& out, ForwadIterator begin, ForwadIterator end, const char* separator = ", ") {
    if (begin != end) {
        out << *begin;
        for (++begin ; begin != end; ++begin)
            out << separator << *begin;
    }
    return out;
}
 
template <typename T>
struct AssignWithBackup {
    T& original;
    T store;
 
    template <typename... ConstructorArgsT>
    AssignWithBackup(T& varible_to_back, ConstructorArgsT&&... newValueCtrArgs)
    : original(varible_to_back), store(std::forward<ConstructorArgsT>(newValueCtrArgs)...) {
        std::swap(varible_to_back, store);
    }
 
    ~AssignWithBackup() { std::swap(original, store); }
};
 
 
 
#include <cstddef>
#include <tuple>
#include <type_traits>
 
//===================================================================
 
template <std::size_t...>
struct indices { };
 
//===================================================================
 
template <
  std::size_t Begin,
  std::size_t End,
  typename Indices
>
struct make_seq_indices_impl;
 
template <
  std::size_t Begin,
  std::size_t End,
  std::size_t... Indices
>
struct make_seq_indices_impl<Begin, End, indices<Indices...>>
{
  using type =
    typename
      make_seq_indices_impl<Begin+1, End,indices<Indices..., Begin>
    >::type
  ;
};
 
template <std::size_t End, std::size_t... Indices>
struct make_seq_indices_impl<End, End, indices<Indices...>>
{
  using type = indices<Indices...>;
};
 
template <std::size_t Begin, std::size_t End>
using make_seq_indices =
  typename make_seq_indices_impl<Begin, End, indices<>>::type;
 
//===================================================================
 
template <typename F>
using return_type = typename std::result_of<F>::type;
 
template <typename Tuple>
constexpr std::size_t tuple_size()
{
  return std::tuple_size<typename std::decay<Tuple>::type>::value;
}
 
// No definition exists for the next prototype...
template <
  typename Op,
  typename T,
  template <std::size_t...> class I, std::size_t... Indices
>
constexpr auto apply_tuple_return_type_impl(
  Op&& op,
  T&& t,
  I<Indices...>
) ->
  return_type<Op(
    decltype(std::get<Indices>(std::forward<T>(t)))...
  )>
;
 
// No definition exists for the next prototype...
template <typename Op, typename T>
constexpr auto apply_tuple_return_type(Op&& op, T&& t) ->
  decltype(apply_tuple_return_type_impl(
    op, t, make_seq_indices<0,tuple_size<T>()>{}
  ));
 
template <
  typename Ret, typename Op, typename T,
  template <std::size_t...> class I, std::size_t... Indices
>
inline Ret apply_tuple(Op&& op, T&& t, I<Indices...>)
{
  return op(std::get<Indices>(std::forward<T>(t))...);
}
 
template <typename Op, typename Tuple>
inline auto apply_tuple(Op&& op, Tuple&& t)
  -> decltype(apply_tuple_return_type(
    std::forward<Op>(op), std::forward<Tuple>(t)
  ))
{
  return
    apply_tuple<
      decltype(apply_tuple_return_type(
        std::forward<Op>(op), std::forward<Tuple>(t)
      ))
    >(
      std::forward<Op>(op), std::forward<Tuple>(t),
      make_seq_indices<0,tuple_size<Tuple>()>{}
    );
  ;
}   //http://preney.ca/paul/archives/934
 
 
template <typename T>
struct DontCopyThisField: public T {
 
    /*template <typename... Args>
    DontCopyThisField(Args&&... args) noexcept(noexcept(T(::std::forward<Args>(args)...)))
        : T(::std::forward<Args>(args)...)
    {}*/
 
    DontCopyThisField() = default;
 
    DontCopyThisField(const DontCopyThisField<T>&) noexcept: T() {}
 
    DontCopyThisField(const T&) noexcept {}
 
    DontCopyThisField(DontCopyThisField&& from) = default;
 
    DontCopyThisField(T&& from) noexcept(noexcept(T(::std::move(from))))
        : T(::std::move(from))
    {}
 
    DontCopyThisField& operator=(const T&) noexcept {
        return *this;
    }
 
    DontCopyThisField& operator=(const DontCopyThisField&) noexcept {
        return *this;
    }
 
    DontCopyThisField& operator=(T&& from) noexcept(noexcept(T::operator=(::std::move(from)))) {
        T::operator=(::std::move(from));
        return *this;
    }
 
    DontCopyThisField& operator=(DontCopyThisField&& from) = default;
};
 
 
} // namespace plask
 
#endif // PLASK__STL_H