XS-librangeV3
view release on metacpan or search on metacpan
MANIFEST.SKIP
range-v3-0.12.0/.buckconfig
range-v3-0.12.0/.clang-format
range-v3-0.12.0/.gitattributes
range-v3-0.12.0/.github/workflows/range-v3-ci.yml
range-v3-0.12.0/.gitmodules
range-v3-0.12.0/BUCK
range-v3-0.12.0/BUILD.bazel
range-v3-0.12.0/cmake/aligned_new_probe.cpp
range-v3-0.12.0/cmake/concepts_test_code.cpp
range-v3-0.12.0/cmake/coro_test_code.cpp
range-v3-0.12.0/cmake/gbenchmark.cmake
range-v3-0.12.0/cmake/GoogleBenchmark.cmake.in
range-v3-0.12.0/cmake/GoogleTest.cmake.in
range-v3-0.12.0/cmake/gtest.cmake
range-v3-0.12.0/cmake/range-v3-config.cmake
range-v3-0.12.0/cmake/ranges_diagnostics.cmake
range-v3-0.12.0/cmake/ranges_env.cmake
range-v3-0.12.0/cmake/ranges_flags.cmake
range-v3-0.12.0/cmake/ranges_options.cmake
range-v3-0.12.0/cmake/readme.md
range-v3-0.12.0/cmake/coro_test_code.cpp view on Meta::CPAN
#if defined(__cpp_coroutines) && defined(__has_include)
#if __has_include(<coroutine>)
#include <coroutine>
namespace std_coro = std;
#elif __has_include(<experimental/coroutine>)
#include <experimental/coroutine>
namespace std_coro = std::experimental;
#else
#error Either the compiler or the library lacks support for coroutines
#endif
#else
#error Either the compiler or the library lacks support for coroutines
#endif
struct present
{
struct promise_type
{
int result;
present get_return_object() { return {*this}; }
std_coro::suspend_never initial_suspend() { return {}; }
std_coro::suspend_never final_suspend() noexcept { return {}; }
void return_value(int i) { result = i; }
void unhandled_exception() {}
};
promise_type& promise;
bool await_ready() const { return true; }
void await_suspend(std_coro::coroutine_handle<>) const {}
int await_resume() const { return promise.result; }
};
present f(int n)
{
if (n < 2)
co_return 1;
else
co_return n * co_await f(n - 1);
}
range-v3-0.12.0/cmake/ranges_flags.cmake view on Meta::CPAN
set(CMAKE_REQUIRED_FLAGS ${RANGES_STD_FLAG})
# Probe for library and compiler support for aligned new
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/aligned_new_probe.cpp" RANGE_V3_PROBE_CODE)
check_cxx_source_compiles("${RANGE_V3_PROBE_CODE}" RANGE_V3_ALIGNED_NEW_PROBE)
unset(RANGE_V3_PROBE_CODE)
unset(CMAKE_REQUIRED_FLAGS)
if (NOT RANGE_V3_ALIGNED_NEW_PROBE)
add_compile_options("-DRANGES_CXX_ALIGNED_NEW=0")
endif()
# Probe for coroutine TS support
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/coro_test_code.cpp" RANGE_V3_PROBE_CODE)
if(RANGES_CXX_COMPILER_MSVC)
set(CMAKE_REQUIRED_FLAGS "/await")
check_cxx_source_compiles("${RANGE_V3_PROBE_CODE}" RANGES_HAS_AWAIT)
if(RANGES_HAS_AWAIT)
set(RANGE_V3_COROUTINE_FLAGS "/await")
endif()
elseif(RANGES_CXX_COMPILER_CLANG)
set(CMAKE_REQUIRED_FLAGS "-fcoroutines-ts ${RANGES_STD_FLAG}")
check_cxx_source_compiles("${RANGE_V3_PROBE_CODE}" RANGES_HAS_FCOROUTINES_TS)
if(RANGES_HAS_FCOROUTINES_TS)
set(RANGE_V3_COROUTINE_FLAGS "-fcoroutines-ts")
endif()
endif()
unset(CMAKE_REQUIRED_FLAGS)
unset(RANGE_V3_PROBE_CODE)
if (RANGE_V3_COROUTINE_FLAGS)
add_compile_options(${RANGE_V3_COROUTINE_FLAGS})
endif()
# Test for concepts support
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/concepts_test_code.cpp" RANGE_V3_PROBE_CODE)
range-v3-0.12.0/doc/release_notes.md view on Meta::CPAN
* `writable<I>` -> `indirectly_writable<I>`
* Added the following to the `ranges::cpp20` namespace:
* Algorithm `for_each_n`
* Algorithm `sample`
* Class `view_base`
* Alias `views::all_t`
* Type `__int128` is recognized as "integer-like".
* Adds concepts `three_way_comparable[_with]` when `<=>` is supported.
* Adds concepts `partially_ordered[_with]`.
* Better conformance with C++20's use of the _`boolean-testable`_ concept.
* Support C++20 coroutines.
* Honor CMake's `CMAKE_CXX_STANDARD` variable.
* A fix for the cardinality of `views::zip[_with]` ([\#1486](https://github.com/ericniebler/range-v3/pull/1486)).
* Add `view_interface::data()` member function.
* Add necessary specializations for `std::basic_common_reference` and
`std::common_type`.
* Numerous workarounds for MSVC.
* Various CMake fixes and improvements.
* `drop_while_view` is not a `sized_range`.
* Added support for Wind River Systems.
* Bug fixes to `views::group_by` ([\#1393](https://github.com/ericniebler/range-v3/pull/1393)).
range-v3-0.12.0/doc/release_notes.md view on Meta::CPAN
* **NEW:** MSVC support, from @CaseyCarter :tada: (See the docs for the list of supported compilers.)
* **NEW:** `view::enumerate`, from @MikeGitb
* **NEW:** `view::addressof`, from @tower120
* **NEW:** `unstable_remove_if` algorithm and action, from @tower120
* **NEW:** `adjacent_remove_if` algorithm and action, from @cjdb
* **NEW:** `ostream_joiner`, from @sv1990
* `view::drop_while` and `view::take_while` get projection support, from @mrpi
* `view::filter` and `view::remove_if` get projection support, from @mrpi
* `view::unique` accepts optional comparison operator, from @tete17
* `action::slice` supports sliding from the end, from @tete17
* Support coroutines on MSVC, from @CaseyCarter
* Faster `view::generate_n`, from GitHub user @tower120
* Improved aligned new detection for libc++ on iOS, from @mtak-
* Various CMake improvements, from @johelegp
* `view_adaptor` supports `basic_iterator`-style mixins, from @tower120
* Fix `ranges::advance` for random-access iterators for `n==0`, from @tower120
* Bugs fixed: [#755](https://github.com/ericniebler/range-v3/issues/755), [#759](https://github.com/ericniebler/range-v3/issues/759), [#942](https://github.com/ericniebler/range-v3/issues/942), [#946](https://github.com/ericniebler/range-v3/issues/94...
\section v0-4-0 Version 0.4.0
_Released:_ Oct 18, 2018.
range-v3-0.12.0/doc/release_notes.md view on Meta::CPAN
_Released:_ June 30, 2017.
- Input views may now be move-only (from @CaseyCarter)
- Input `any_view`s are now *much* more efficient (from @CaseyCarter)
- Better support for systems lacking a working `<thread>` header (from @CaseyCarter)
\section v0-2-6 Version 0.2.6
_Released:_ June 21, 2017.
- Experimental coroutines with `ranges::experimental::generator` (from @CaseyCarter)
- `ranges::optional` now behaves like `std::optional` (from @CaseyCarter)
- Extensive bug fixes with Input ranges (from @CaseyCarter)
\section v0-2-5 Version 0.2.5
_Released:_ May 16, 2017.
- `view::chunk` works on Input ranges (from @CaseyCarter)
- `for_each_n` algorithm (from @khlebnikov)
- Portability fixes for MinGW, clang-3.6 and -3.7, and gcc-7; and cmake 3.0
range-v3-0.12.0/include/range/v3/detail/config.hpp view on Meta::CPAN
__pragma(message(__FILE__ "(" RANGES_STRINGIZE(__LINE__) ") : Warning: " MSG))
#endif
#else
#define RANGES_DEPRECATED_HEADER(MSG) /**/
#endif
// #ifndef RANGES_DEPRECATED_HEADER
// #define RANGES_DEPRECATED_HEADER(MSG)
// #endif
#ifndef RANGES_CXX_COROUTINES
#if defined(__cpp_coroutines) && defined(__has_include)
#if __has_include(<coroutine>)
#define RANGES_CXX_COROUTINES __cpp_coroutines
#define RANGES_COROUTINES_HEADER <coroutine>
#define RANGES_COROUTINES_NS std
#elif __has_include(<experimental/coroutine>)
#define RANGES_CXX_COROUTINES __cpp_coroutines
#define RANGES_COROUTINES_HEADER <experimental/coroutine>
#define RANGES_COROUTINES_NS std::experimental
#endif
#endif
#ifndef RANGES_CXX_COROUTINES
#define RANGES_CXX_COROUTINES RANGES_CXX_FEATURE(COROUTINES)
#endif
#endif
#ifdef NDEBUG
#define RANGES_NDEBUG_CONSTEXPR constexpr
range-v3-0.12.0/include/range/v3/experimental/utility/generator.hpp view on Meta::CPAN
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/swap.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#if defined(_MSC_VER) && !defined(RANGES_SILENCE_COROUTINE_WARNING)
#ifdef __clang__
#pragma message( \
"DANGER: clang doesn't (yet?) grok the MSVC coroutine ABI. " \
"Use at your own risk. " \
"(RANGES_SILENCE_COROUTINE_WARNING will silence this message.)")
#elif defined RANGES_WORKAROUND_MSVC_835948
#pragma message( \
"DANGER: ranges::experimental::generator is fine, but this " \
"version of MSVC likely miscompiles ranges::experimental::sized_generator. " \
"Use the latter at your own risk. " \
"(RANGES_SILENCE_COROUTINE_WARNING will silence this message.)")
#endif
#endif // RANGES_SILENCE_COROUTINE_WARNINGS
range-v3-0.12.0/include/range/v3/experimental/utility/generator.hpp view on Meta::CPAN
// The type of size() for a sized_generator
using generator_size_t = std::size_t;
// Type upon which to co_await to set the size of a sized_generator
enum struct generator_size : generator_size_t
{
invalid = ~generator_size_t(0)
};
template<typename Promise = void>
struct RANGES_EMPTY_BASES coroutine_owner;
class enable_coroutine_owner
{
template<class>
friend struct coroutine_owner;
std::atomic<unsigned int> refcount_{1};
};
} // namespace experimental
/// \cond
namespace detail
{
inline void resume(RANGES_COROUTINES_NS::coroutine_handle<> coro)
{
// Pre: coro refers to a suspended coroutine.
RANGES_EXPECT(coro);
RANGES_EXPECT(!coro.done());
coro.resume();
}
namespace coroutine_owner_
{
struct adl_hook
{};
template<typename Promise>
void swap(experimental::coroutine_owner<Promise> & x,
experimental::coroutine_owner<Promise> & y) noexcept
{
x.swap(y);
}
} // namespace coroutine_owner_
} // namespace detail
/// \endcond
namespace experimental
{
// An owning coroutine_handle
template<typename Promise>
struct RANGES_EMPTY_BASES coroutine_owner
: private RANGES_COROUTINES_NS::coroutine_handle<Promise>
, private detail::coroutine_owner_::adl_hook
{
CPP_assert(derived_from<Promise, enable_coroutine_owner>);
using base_t = RANGES_COROUTINES_NS::coroutine_handle<Promise>;
using base_t::operator bool;
using base_t::done;
using base_t::promise;
coroutine_owner() = default;
constexpr explicit coroutine_owner(base_t coro) noexcept
: base_t(coro)
{}
coroutine_owner(coroutine_owner && that) noexcept
: base_t(ranges::exchange(that.base(), {}))
, copied_(that.copied_.load(std::memory_order_relaxed))
{}
coroutine_owner(coroutine_owner const & that) noexcept
: base_t(that.handle())
, copied_(that.handle() != nullptr)
{
if(*this)
{
that.copied_.store(true, std::memory_order_relaxed);
base().promise().refcount_.fetch_add(1, std::memory_order_relaxed);
}
}
~coroutine_owner()
{
if(base() && (!copied_.load(std::memory_order_relaxed) ||
1 == base().promise().refcount_.fetch_sub(
1, std::memory_order_acq_rel)))
base().destroy();
}
coroutine_owner & operator=(coroutine_owner that) noexcept
{
swap(that);
return *this;
}
void resume()
{
detail::resume(handle());
}
void operator()()
{
detail::resume(handle());
}
void swap(coroutine_owner & that) noexcept
{
bool tmp = copied_.load(std::memory_order_relaxed);
copied_.store(that.copied_.load(std::memory_order_relaxed),
std::memory_order_relaxed);
that.copied_.store(tmp, std::memory_order_relaxed);
std::swap(base(), that.base());
}
base_t handle() const noexcept
{
return *this;
range-v3-0.12.0/include/range/v3/experimental/utility/generator.hpp view on Meta::CPAN
{
return *this;
}
};
} // namespace experimental
/// \cond
namespace detail
{
template<typename Reference>
struct generator_promise : experimental::enable_coroutine_owner
{
std::exception_ptr except_ = nullptr;
CPP_assert(std::is_reference<Reference>::value ||
copy_constructible<Reference>);
generator_promise * get_return_object() noexcept
{
return this;
}
range-v3-0.12.0/include/range/v3/experimental/utility/generator.hpp view on Meta::CPAN
return this;
}
RANGES_COROUTINES_NS::suspend_never initial_suspend() const noexcept
{
// sized_generator doesn't suspend at its initial suspend point because...
return {};
}
RANGES_COROUTINES_NS::suspend_always await_transform(
experimental::generator_size size) noexcept
{
// ...we need the coroutine set the size of the range first by
// co_awaiting on a generator_size.
size_ = size;
return {};
}
experimental::generator_size_t size() const noexcept
{
RANGES_EXPECT(size_ != experimental::generator_size::invalid);
return static_cast<experimental::generator_size_t>(size_);
}
range-v3-0.12.0/include/range/v3/experimental/utility/generator.hpp view on Meta::CPAN
template<typename Reference, typename Value = uncvref_t<Reference>>
struct sized_generator;
template<typename Reference, typename Value = uncvref_t<Reference>>
struct generator : view_facade<generator<Reference, Value>>
{
using promise_type = detail::generator_promise<Reference>;
constexpr generator() noexcept = default;
generator(promise_type * p)
: coro_{handle::from_promise(*p)}
{
RANGES_EXPECT(coro_);
}
private:
friend range_access;
friend struct sized_generator<Reference, Value>;
using handle = RANGES_COROUTINES_NS::coroutine_handle<promise_type>;
coroutine_owner<promise_type> coro_;
struct cursor
{
using value_type = Value;
cursor() = default;
constexpr explicit cursor(handle coro) noexcept
: coro_{coro}
{}
bool equal(default_sentinel_t) const
{
RANGES_EXPECT(coro_);
if(coro_.done())
{
auto & e = coro_.promise().except_;
if(e)
std::rethrow_exception(std::move(e));
return true;
}
return false;
}
void next()
{
detail::resume(coro_);
}
Reference read() const
{
RANGES_EXPECT(coro_);
return coro_.promise().read();
}
private:
handle coro_ = nullptr;
};
cursor begin_cursor()
{
detail::resume(coro_.handle());
return cursor{coro_.handle()};
}
};
template<typename Reference, typename Value /* = uncvref_t<Reference>*/>
struct sized_generator : generator<Reference, Value>
{
using promise_type = detail::sized_generator_promise<Reference>;
using handle = RANGES_COROUTINES_NS::coroutine_handle<promise_type>;
constexpr sized_generator() noexcept = default;
sized_generator(promise_type * p)
: generator<Reference, Value>{p}
{}
generator_size_t size() const noexcept
{
return promise().size();
}
private:
using generator<Reference, Value>::coro_;
promise_type const & promise() const noexcept
{
RANGES_EXPECT(coro_);
return static_cast<promise_type const &>(coro_.promise());
}
};
} // namespace experimental
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_CXX_COROUTINES >= RANGES_CXX_COROUTINES_TS1
range-v3-0.12.0/test/experimental/utility/generator.cpp view on Meta::CPAN
#include <range/v3/view/take_exactly.hpp>
#include <range/v3/view/transform.hpp>
#include "../../simple_test.hpp"
#include "../../test_utils.hpp"
#ifdef __clang__
#pragma GCC diagnostic ignored "-Wunused-const-variable"
#endif
#if RANGES_CXX_COROUTINES < RANGES_CXX_COROUTINES_TS1
#error This test uses coroutines.
#endif
template<bool Condition>
using maybe_sized_generator = meta::if_c<Condition,
meta::quote<ranges::experimental::sized_generator>,
meta::quote<ranges::experimental::generator>>;
template<typename T>
constexpr bool is_copy_constructible_or_ref() noexcept
{
return std::is_reference<T>::value ||(bool) ranges::copy_constructible<T>;
}
struct coro_fn
{
private:
template<typename V>
using generator_for = meta::invoke<
maybe_sized_generator<(bool) ranges::sized_range<V>>,
ranges::range_reference_t<V>,
ranges::range_value_t<V>>;
CPP_template(typename V)(
requires ranges::input_range<V> && ranges::view_<V> &&
range-v3-0.12.0/test/experimental/utility/generator.cpp view on Meta::CPAN
template<typename R, typename V>
ranges::experimental::sized_generator<R, V>
operator()(ranges::experimental::sized_generator<R, V> g) const noexcept
{
return g;
}
};
inline namespace function_objects
{
RANGES_INLINE_VARIABLE(coro_fn, coro)
}
auto f(int const n)
{
return ::coro(ranges::views::iota(0, n));
}
ranges::experimental::sized_generator<int> g(int const n)
{
co_await static_cast<ranges::experimental::generator_size>((std::size_t) (n > 0 ? n : 0));
for (int i = 0; i < n; ++i)
co_yield i;
}
ranges::experimental::sized_generator<int &> h(int const n)
range-v3-0.12.0/test/experimental/utility/generator.cpp view on Meta::CPAN
auto even = [](int i){ return i % 2 == 0; };
#ifndef RANGES_WORKAROUND_MSVC_835948
{
auto rng = ::iota_generator(0, 10);
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 10u);
::check_equal(rng, {0,1,2,3,4,5,6,7,8,9});
}
{
auto rng = ::coro(::coro(::coro(::iota_generator(0, 10))));
::has_type<decltype(::iota_generator(0, 10)) &>(rng);
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 10u);
::check_equal(rng, {0,1,2,3,4,5,6,7,8,9});
}
{
auto rng = ::coro(views::ints | views::filter(even) | views::take_exactly(10));
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 10u);
::check_equal(rng, {0,2,4,6,8,10,12,14,16,18});
}
{
auto const control = {1, 2, 3};
MoveInt a[] = {{1}, {2}, {3}};
MoveInt b[3];
CHECK(equal(a, control, std::equal_to<int>{}, &MoveInt::i_));
CHECK(count(b, 42, &MoveInt::i_) == 3);
auto rng = ::coro(views::move(a));
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 3u);
copy(rng, b);
CHECK(equal(b, control, std::equal_to<int>{}, &MoveInt::i_));
CHECK(count(a, 0, &MoveInt::i_) == 3);
}
{
int some_ints[] = {0,1,2};
auto rng = ::coro(some_ints);
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 3u);
auto i = begin(rng);
auto e = end(rng);
CHECK(i != e);
CHECK(&*i == &some_ints[0]);
++i;
CHECK(i != e);
CHECK(&*i == &some_ints[1]);
++i;
CHECK(i != e);
CHECK(&*i == &some_ints[2]);
++i;
CHECK(i == e);
}
{
std::vector<bool> vec(3, false);
auto rng = ::coro(vec);
CPP_assert(sized_range<decltype(rng)>);
CHECK(size(rng) == 3u);
::check_equal(rng, {false,false,false});
}
::check_equal(f(42), g(42));
::check_equal(f(42), h(42));
{
auto rng = h(20) | views::transform([](int &x) { return ++x; });
( run in 0.475 second using v1.01-cache-2.11-cpan-3cd7ad12f66 )