tools/reversed.hpp

• View this file on GitHub
• Last update: 2023-07-08 14:12:19+09:00
• Include: #include "tools/reversed.hpp"

Depends on

• tools/base.hpp
• tools/container-traits.hpp

Code

#pragma once

#include "./base.hpp"
#include "./container-traits.hpp"

#include <algorithm>
#include <type_traits>

namespace matumoto {
  // array or vector or deque or string
  template <typename Container>
  constexpr Container reversed(const Container &c) {
    Container res = c;
    reverse(res.begin(), res.end());
    return res;
  }

  // list or forward_list
  template <template <typename T> typename Container, typename T, enable_if_t<(is_forward_list_v<Container<T>> or is_list_v<Container<T>>)> * = nullptr>
  constexpr auto reversed(const Container<T> &ls) {
    Container<T> res = ls;
    res.reverse();
    return res;
  }

  // set or multiset
  template <template <typename T, typename Compare> typename Container, typename T, typename Compare, enable_if_t<(is_set_v<Container<T, Compare>> or is_multiset_v<Container<T, Compare>>)> * = nullptr>
  constexpr auto reversed(const Container<T, Compare> &st) {
    if constexpr (is_same_v<Compare, less<T>>) {
      Container<T, greater<T>> res;
      for (const auto &v: st) {
        res.emplace_hint(res.begin(), v);
      }
      return res;
    } else {
      Container<T, less<T>> res;
      for (const auto &v: st) {
        res.emplace_hint(res.begin(), v);
      }
      return res;
    }
  }

  // map or multimap
  template <template <typename T1, typename T2, typename Compare> typename Container,
            typename T1,
            typename T2,
            typename Compare,
            enable_if_t<(is_map_v<Container<T1, T2, Compare>> or is_multimap_v<Container<T1, T2, Compare>>)> * = nullptr>
  constexpr auto reversed(const Container<T1, T2, Compare> &mp) {
    if constexpr (is_same_v<Compare, less<T1>>) {
      Container<T1, T2, greater<T1>> res;
      for (const auto &p: mp) {
        res.emplace_hint(res.begin(), p);
      }
      return res;
    } else {
      Container<T1, T2, less<T1>> res;
      for (const auto &p: mp) {
        res.emplace_hint(res.begin(), p);
      }
      return res;
    }
  }
} // namespace matumoto

#line 2 "tools/reversed.hpp"

#line 2 "tools/base.hpp"

namespace matumoto {
  using namespace std;
}
#line 2 "tools/container-traits.hpp"

#line 4 "tools/container-traits.hpp"

#include <array>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>


namespace matumoto {

  namespace traits_helper {
    template <template <typename...> typename Container, typename Type>
    struct IsTemplate: false_type {};

    template <template <typename...> typename Container, typename... Args>
    struct IsTemplate<Container, Container<Args...>>: true_type {};
  } // namespace traits_helper

  // Sequence containers
  template <typename T>
  struct IsArray: false_type {};

  template <typename T, size_t Size>
  struct IsArray<array<T, Size>>: true_type {};

  template <typename... Args>
  inline constexpr bool is_array_v = IsArray<Args...>::value;

  template <typename T>
  using IsVector = traits_helper::IsTemplate<vector, T>;

  template <typename T>
  inline constexpr bool is_vector_v = IsVector<T>::value;

  template <typename T>
  using IsDeque = traits_helper::IsTemplate<deque, T>;

  template <typename T>
  inline constexpr bool is_deque_v = IsDeque<T>::value;

  template <typename T>
  using IsForwardList = traits_helper::IsTemplate<forward_list, T>;

  template <typename T>
  inline constexpr bool is_forward_list_v = IsForwardList<T>::value;

  template <typename T>
  using IsList = traits_helper::IsTemplate<list, T>;

  template <typename T>
  inline constexpr bool is_list_v = IsList<T>::value;

  // Associative containers
  template <typename T>
  using IsSet = traits_helper::IsTemplate<set, T>;

  template <typename T>
  inline constexpr bool is_set_v = IsSet<T>::value;

  template <typename T>
  using IsMap = traits_helper::IsTemplate<map, T>;

  template <typename T>
  inline constexpr bool is_map_v = IsMap<T>::value;

  template <typename T>
  using IsMultiset = traits_helper::IsTemplate<multiset, T>;

  template <typename T>
  inline constexpr bool is_multiset_v = IsMultiset<T>::value;

  template <typename T>
  using IsMultimap = traits_helper::IsTemplate<multimap, T>;

  template <typename T>
  inline constexpr bool is_multimap_v = IsMultimap<T>::value;

  // Unordered associative containers
  template <typename T>
  using IsUnorderedSet = traits_helper::IsTemplate<unordered_set, T>;

  template <typename T>
  inline constexpr bool is_unordered_set_v = IsUnorderedSet<T>::value;

  template <typename T>
  using IsUnorderedMap = traits_helper::IsTemplate<unordered_map, T>;

  template <typename T>
  inline constexpr bool is_unordered_map_v = IsUnorderedMap<T>::value;

  template <typename T>
  using IsUnorderedMultiset = traits_helper::IsTemplate<unordered_multiset, T>;

  template <typename T>
  inline constexpr bool is_unordered_multiset_v = IsUnorderedMultiset<T>::value;

  template <typename T>
  using IsUnorderedMultimap = traits_helper::IsTemplate<unordered_multimap, T>;

  template <typename T>
  inline constexpr bool is_unordered_multimap_v = IsUnorderedMultimap<T>::value;

  // Container adaptors
  template <typename T>
  using IsQueue = traits_helper::IsTemplate<queue, T>;

  template <typename T>
  inline constexpr bool is_queue_v = IsQueue<T>::value;

  template <typename T>
  using IsStack = traits_helper::IsTemplate<stack, T>;

  template <typename T>
  inline constexpr bool is_stack_v = IsStack<T>::value;

  template <typename T>
  using IsPriorityQueue = traits_helper::IsTemplate<priority_queue, T>;

  template <typename T>
  inline constexpr bool is_priority_queue_v = IsPriorityQueue<T>::value;

  // Container types
  template <typename T>
  using IsSequenceContainer = disjunction<IsArray<T>, IsVector<T>, IsDeque<T>, IsForwardList<T>, IsList<T>>;

  template <typename T>
  inline constexpr bool is_sequence_container_v = IsSequenceContainer<T>::value;

  template <typename T>
  using IsAssociativeContainer = disjunction<IsSet<T>, IsMap<T>, IsMultiset<T>, IsMultimap<T>>;

  template <typename T>
  inline constexpr bool is_associative_container_v = IsAssociativeContainer<T>::value;

  template <typename T>
  using IsUnorderedAssociativeContainer = disjunction<IsUnorderedSet<T>, IsUnorderedMap<T>, IsUnorderedMultiset<T>, IsUnorderedMultimap<T>>;

  template <typename T>
  inline constexpr bool is_unordered_associative_container_v = IsUnorderedAssociativeContainer<T>::value;

  template <typename T>
  using IsContainerAdaptor = disjunction<IsQueue<T>, IsStack<T>, IsPriorityQueue<T>>;

  template <typename T>
  inline constexpr bool is_container_adaptor_v = IsContainerAdaptor<T>::value;

  template <typename T>
  using IsContainer = disjunction<IsSequenceContainer<T>, IsAssociativeContainer<T>, IsUnorderedAssociativeContainer<T>, IsContainerAdaptor<T>>;

  template <typename T>
  inline constexpr bool is_container_v = IsContainer<T>::value;

} // namespace matumoto
#line 5 "tools/reversed.hpp"

#include <algorithm>
#include <type_traits>

namespace matumoto {
  // array or vector or deque or string
  template <typename Container>
  constexpr Container reversed(const Container &c) {
    Container res = c;
    reverse(res.begin(), res.end());
    return res;
  }

  // list or forward_list
  template <template <typename T> typename Container, typename T, enable_if_t<(is_forward_list_v<Container<T>> or is_list_v<Container<T>>)> * = nullptr>
  constexpr auto reversed(const Container<T> &ls) {
    Container<T> res = ls;
    res.reverse();
    return res;
  }

  // set or multiset
  template <template <typename T, typename Compare> typename Container, typename T, typename Compare, enable_if_t<(is_set_v<Container<T, Compare>> or is_multiset_v<Container<T, Compare>>)> * = nullptr>
  constexpr auto reversed(const Container<T, Compare> &st) {
    if constexpr (is_same_v<Compare, less<T>>) {
      Container<T, greater<T>> res;
      for (const auto &v: st) {
        res.emplace_hint(res.begin(), v);
      }
      return res;
    } else {
      Container<T, less<T>> res;
      for (const auto &v: st) {
        res.emplace_hint(res.begin(), v);
      }
      return res;
    }
  }

  // map or multimap
  template <template <typename T1, typename T2, typename Compare> typename Container,
            typename T1,
            typename T2,
            typename Compare,
            enable_if_t<(is_map_v<Container<T1, T2, Compare>> or is_multimap_v<Container<T1, T2, Compare>>)> * = nullptr>
  constexpr auto reversed(const Container<T1, T2, Compare> &mp) {
    if constexpr (is_same_v<Compare, less<T1>>) {
      Container<T1, T2, greater<T1>> res;
      for (const auto &p: mp) {
        res.emplace_hint(res.begin(), p);
      }
      return res;
    } else {
      Container<T1, T2, less<T1>> res;
      for (const auto &p: mp) {
        res.emplace_hint(res.begin(), p);
      }
      return res;
    }
  }
} // namespace matumoto

Back to top page