ah-stl-utils.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef AH_STL_UTILS_H
#define AH_STL_UTILS_H
 
#include <list>
#include <vector>
#include <tuple>
#include <utility>
 
#include <htlist.H>
#include <tpl_dynDlist.H>
#include <tpl_array.H>
#include <tpl_dynArray.H>
#include <tpl_dynSetTree.H>
 
namespace Aleph
{
 
template<class F, class...Ts, std::size_t...Is>
inline void tuple_for_each(const std::tuple<Ts...> & tuple,
                           F func, std::index_sequence<Is...>)
{
  // Use fold expression (C++17) or initializer list expansion
  // The (void) cast silences unused-value warnings
  using expander = int[];
  (void)func;  // Silence warning when tuple is empty
  (void)expander { 0, ((void)func(std::get<Is>(tuple)), 0)... };
}
 
template<class F, class...Ts>
inline void tuple_for_each(const std::tuple<Ts...> & tuple, F func)
{
  tuple_for_each(tuple, func, std::make_index_sequence<sizeof...(Ts)>());
}
 
 
template <typename T>
[[nodiscard]] inline DynList<T> vector_to_DynList(const std::vector<T> & v)
{
  DynList<T> ret;
  for (const auto & item : v)
    ret.append(item);
  return ret;
}
 
template <typename T>
[[nodiscard]] inline DynList<T> to_DynList(const std::vector<T> & v)
{
  return vector_to_DynList(v);
}
 
template <typename Iterator>
[[nodiscard]] inline auto range_to_DynList(Iterator begin, Iterator end)
  -> DynList<std::decay_t<decltype(*begin)>>
{
  DynList<std::decay_t<decltype(*begin)>> ret;
  for (auto it = begin; it != end; ++it)
    ret.append(*it);
  return ret;
}
 
template <typename T>
[[nodiscard]] inline Array<T> to_Array(const std::vector<T> & v)
{
  Array<T> ret;
  for (const auto & item : v)
    ret.append(item);
  return ret;
}
 
template <typename Container>
[[nodiscard]] inline std::vector<typename Container::Item_Type>
to_vector(const Container & container)
{
  std::vector<typename Container::Item_Type> ret;
  for (const auto & item : container)
    ret.push_back(item);
  return ret;
}
 
template <typename T, class Op>
[[nodiscard]] inline auto map_vector(const std::vector<T> & v, Op op)
  -> std::vector<std::decay_t<decltype(op(v[0]))>>
{
  using ResultType = std::decay_t<decltype(op(v[0]))>;
  std::vector<ResultType> ret;
  ret.reserve(v.size());
  for (const auto & item : v)
    ret.push_back(op(item));
  return ret;
}
 
template <typename T, typename... Args>
[[nodiscard]] inline std::vector<T> variadic_to_vector(Args&&... args)
{
  return { static_cast<T>(std::forward<Args>(args))... };
}
 
template <typename T, typename... Args>
[[nodiscard]] inline DynList<T> variadic_to_DynList(Args&&... args)
{
  return to_DynList<T>(variadic_to_vector<T>(std::forward<Args>(args)...));
}
 
 
/* Boost Software License - Version 1.0 - August 17th, 2003 Permission
   is hereby granted, free of charge, to any person or organization
   obtaining a copy of the software and accompanying documentation
   covered by this license (the "Software") to use, reproduce,
   display, distribute, execute, and transmit the Software, and to
   prepare derivative works of the Software, and to permit
   third-parties to whom the Software is furnished to do so, all
   subject to the following:
 
   The copyright notices in the Software and this entire statement,
   including the above license grant, this restriction and the
   following disclaimer, must be included in all copies of the
   Software, in whole or in part, and all derivative works of the
   Software, unless such copies or derivative works are solely in the
   form of machine-executable object code generated by a source
   language processor.
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
   NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE
   DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER
   LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   DEALINGS IN THE SOFTWARE.
*/
 
template<unsigned... Indexes>
struct index_tuple
{
  template<unsigned N>
  using append = index_tuple<Indexes..., N>;
};
 
template<unsigned Size>
struct make_index_tuple
{
  using type = typename make_index_tuple<Size-1>::type::template append<Size-1>;
};
 
template<>
struct make_index_tuple<0u>
{
  using type = index_tuple<>;
};
 
template<typename... Types>
using to_index_tuple = typename make_index_tuple<sizeof...(Types)>::type;
 
// Based on:
//   http://stackoverflow.com/questions/10604794/convert-stdtuple-to-stdarray-c11
 
template<class Container, typename T, typename... U, unsigned... I>
[[nodiscard]] inline static Container
tuple_to_container_impl(const std::tuple<T, U...> & t, index_tuple<I...>)
{
  return build_container<Container>(std::get<I>(t)...);
}
 
template<class Container, typename T, typename... U>
[[nodiscard]] inline Container tuple_to_container(const std::tuple<T, U...> & t)
{
  using IndexTuple = typename make_index_tuple<1 + sizeof...(U)>::type;
  return tuple_to_container_impl<Container>(t, IndexTuple());
}
 
template<typename T, typename... U>
[[nodiscard]] inline DynList<T> tuple_to_dynlist(const std::tuple<T, U...> & t)
{
  return tuple_to_container<DynList<T>>(t);
}
 
template<typename T, typename... U>
[[nodiscard]] inline Array<T> tuple_to_array(const std::tuple<T, U...> & t)
{
  return tuple_to_container<Array<T>>(t);
}
 
template <typename StlContainer>
[[nodiscard]] inline auto stl_container_to_dynList(const StlContainer & container)
  -> DynList<typename StlContainer::value_type>
{
  DynList<typename StlContainer::value_type> ret;
  for (const auto & item : container)
    ret.append(item);
  return ret;
}
 
template <typename T>
[[nodiscard]] inline DynList<T> list_to_DynList(const std::list<T> & l)
{
  DynList<T> ret;
  for (const auto & item : l)
    ret.append(item);
  return ret;
}
 
template <typename T>
[[nodiscard]] inline std::list<T> DynList_to_list(const DynList<T> & l)
{
  std::list<T> ret;
  for (const auto & item : l)
    ret.push_back(item);
  return ret;
}
 
template <typename T>
[[nodiscard]] inline std::vector<T> DynArray_to_vector(const DynArray<T> & arr)
{
  std::vector<T> ret;
  ret.reserve(arr.size());
  for (size_t i = 0; i < arr.size(); ++i)
    ret.push_back(arr[i]);
  return ret;
}
 
 
template <typename T>
[[nodiscard]] inline DynArray<T> vector_to_DynArray(const std::vector<T> & v)
{
  DynArray<T> ret;
  for (const auto & item : v)
    ret.append(item);
  return ret;
}
 
} // end namespace Aleph
 
// Keep backward compatibility: expose commonly used functions at global scope
using Aleph::tuple_for_each;
using Aleph::vector_to_DynList;
using Aleph::to_DynList;
using Aleph::to_Array;
using Aleph::to_vector;
using Aleph::map_vector;
using Aleph::variadic_to_vector;
using Aleph::variadic_to_DynList;
using Aleph::tuple_to_container;
using Aleph::tuple_to_dynlist;
using Aleph::tuple_to_array;
using Aleph::stl_container_to_dynList;
using Aleph::range_to_DynList;
using Aleph::list_to_DynList;
using Aleph::DynList_to_list;
using Aleph::DynArray_to_vector;
using Aleph::vector_to_DynArray;
 
#endif // AH_STL_UTILS_H