diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 50eccfc84..1c1b16638 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -14,6 +14,7 @@ add_subdirectory(libigl) add_subdirectory(hints) add_subdirectory(qoi) add_subdirectory(libnest2d) +add_subdirectory(tcbspan) find_package(Qhull 7.2 REQUIRED) add_library(qhull INTERFACE) diff --git a/src/libslic3r/Brim.cpp b/src/libslic3r/Brim.cpp index 5239d7f03..62d886785 100644 --- a/src/libslic3r/Brim.cpp +++ b/src/libslic3r/Brim.cpp @@ -39,7 +39,7 @@ static void append_and_translate(Polygons &dst, const Polygons &src, const Print dst[dst_idx].translate(instance.shift.x(), instance.shift.y()); } -static float max_brim_width(const ConstPrintObjectPtrsAdaptor &objects) +static float max_brim_width(const SpanOfConstPtrs &objects) { assert(!objects.empty()); return float(std::accumulate(objects.begin(), objects.end(), 0., diff --git a/src/libslic3r/GCode.hpp b/src/libslic3r/GCode.hpp index ce4a505fc..4592402e3 100644 --- a/src/libslic3r/GCode.hpp +++ b/src/libslic3r/GCode.hpp @@ -32,7 +32,6 @@ class GCode; namespace { struct Item; } struct PrintInstance; -class ConstPrintObjectPtrsAdaptor; class OozePrevention { public: diff --git a/src/libslic3r/MultiMaterialSegmentation.cpp b/src/libslic3r/MultiMaterialSegmentation.cpp index 9560096be..21b53c40d 100644 --- a/src/libslic3r/MultiMaterialSegmentation.cpp +++ b/src/libslic3r/MultiMaterialSegmentation.cpp @@ -1305,7 +1305,7 @@ static inline std::vector> mmu_segmentation_top_and_bott { const size_t num_extruders = print_object.print()->config().nozzle_diameter.size() + 1; const size_t num_layers = input_expolygons.size(); - const ConstLayerPtrsAdaptor layers = print_object.layers(); + const SpanOfConstPtrs layers = print_object.layers(); // Maximum number of top / bottom layers accounts for maximum overlap of one thread group into a neighbor thread group. int max_top_layers = 0; @@ -1685,7 +1685,7 @@ std::vector> multi_material_segmentation_by_painting(con std::vector> painted_lines(num_layers); std::array painted_lines_mutex; std::vector edge_grids(num_layers); - const ConstLayerPtrsAdaptor layers = print_object.layers(); + const SpanOfConstPtrs layers = print_object.layers(); std::vector input_expolygons(num_layers); throw_on_cancel_callback(); diff --git a/src/libslic3r/Print.hpp b/src/libslic3r/Print.hpp index 967c9e707..9e21111ce 100644 --- a/src/libslic3r/Print.hpp +++ b/src/libslic3r/Print.hpp @@ -21,6 +21,7 @@ #include #include +#include namespace Slic3r { @@ -117,37 +118,12 @@ private: inline bool operator==(const PrintRegion &lhs, const PrintRegion &rhs) { return lhs.config_hash() == rhs.config_hash() && lhs.config() == rhs.config(); } inline bool operator!=(const PrintRegion &lhs, const PrintRegion &rhs) { return ! (lhs == rhs); } -template -class ConstVectorOfPtrsAdaptor { -public: - // Returning a non-const pointer to const pointers to T. - T * const * begin() const { return m_data->data(); } - T * const * end() const { return m_data->data() + m_data->size(); } - const T* front() const { return m_data->front(); } - const T* back() const { return m_data->back(); } - size_t size() const { return m_data->size(); } - bool empty() const { return m_data->empty(); } - const T* operator[](size_t i) const { return (*m_data)[i]; } - const T* at(size_t i) const { return m_data->at(i); } -protected: - ConstVectorOfPtrsAdaptor(const std::vector *data) : m_data(data) {} -private: - const std::vector *m_data; -}; +// For const correctness: Wrapping a vector of non-const pointers as a span of const pointers. +template +using SpanOfConstPtrs = tcb::span; -typedef std::vector LayerPtrs; -typedef std::vector ConstLayerPtrs; -class ConstLayerPtrsAdaptor : public ConstVectorOfPtrsAdaptor { - friend PrintObject; - ConstLayerPtrsAdaptor(const LayerPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} -}; - -typedef std::vector SupportLayerPtrs; -typedef std::vector ConstSupportLayerPtrs; -class ConstSupportLayerPtrsAdaptor : public ConstVectorOfPtrsAdaptor { - friend PrintObject; - ConstSupportLayerPtrsAdaptor(const SupportLayerPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} -}; +using LayerPtrs = std::vector; +using SupportLayerPtrs = std::vector; class BoundingBoxf3; // TODO: for temporary constructor parameter @@ -255,8 +231,8 @@ public: // Size of an object: XYZ in scaled coordinates. The size might not be quite snug in XY plane. const Vec3crd& size() const { return m_size; } const PrintObjectConfig& config() const { return m_config; } - ConstLayerPtrsAdaptor layers() const { return ConstLayerPtrsAdaptor(&m_layers); } - ConstSupportLayerPtrsAdaptor support_layers() const { return ConstSupportLayerPtrsAdaptor(&m_support_layers); } + auto layers() const { return SpanOfConstPtrs(const_cast(m_layers.data()), m_layers.size()); } + auto support_layers() const { return SpanOfConstPtrs(const_cast(m_support_layers.data()), m_support_layers.size()); } const Transform3d& trafo() const { return m_trafo; } // Trafo with the center_offset() applied after the transformation, to center the object in XY before slicing. Transform3d trafo_centered() const @@ -497,21 +473,10 @@ struct PrintStatistics } }; -typedef std::vector PrintObjectPtrs; -typedef std::vector ConstPrintObjectPtrs; -class ConstPrintObjectPtrsAdaptor : public ConstVectorOfPtrsAdaptor { - friend Print; - ConstPrintObjectPtrsAdaptor(const PrintObjectPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} -}; +using PrintObjectPtrs = std::vector; +using ConstPrintObjectPtrs = std::vector; -typedef std::vector PrintRegionPtrs; -/* -typedef std::vector ConstPrintRegionPtrs; -class ConstPrintRegionPtrsAdaptor : public ConstVectorOfPtrsAdaptor { - friend Print; - ConstPrintRegionPtrsAdaptor(const PrintRegionPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} -}; -*/ +using PrintRegionPtrs = std::vector; // The complete print tray with possibly multiple objects. class Print : public PrintBaseWithState @@ -574,7 +539,7 @@ public: const PrintConfig& config() const { return m_config; } const PrintObjectConfig& default_object_config() const { return m_default_object_config; } const PrintRegionConfig& default_region_config() const { return m_default_region_config; } - ConstPrintObjectPtrsAdaptor objects() const { return ConstPrintObjectPtrsAdaptor(&m_objects); } + SpanOfConstPtrs objects() const { return SpanOfConstPtrs(const_cast(m_objects.data()), m_objects.size()); } PrintObject* get_object(size_t idx) { return const_cast(m_objects[idx]); } const PrintObject* get_object(size_t idx) const { return m_objects[idx]; } // PrintObject by its ObjectID, to be used to uniquely bind slicing warnings to their source PrintObjects diff --git a/src/libslic3r/PrintObject.cpp b/src/libslic3r/PrintObject.cpp index 9ffb57a72..bdcb034ab 100644 --- a/src/libslic3r/PrintObject.cpp +++ b/src/libslic3r/PrintObject.cpp @@ -2205,7 +2205,7 @@ void PrintObject::_generate_support_material() } } -static void project_triangles_to_slabs(ConstLayerPtrsAdaptor layers, const indexed_triangle_set &custom_facets, const Transform3f &tr, bool seam, std::vector &out) +static void project_triangles_to_slabs(SpanOfConstPtrs layers, const indexed_triangle_set &custom_facets, const Transform3f &tr, bool seam, std::vector &out) { if (custom_facets.indices.empty()) return; diff --git a/src/tcbspan/CMakeLists.txt b/src/tcbspan/CMakeLists.txt new file mode 100644 index 000000000..0668f838e --- /dev/null +++ b/src/tcbspan/CMakeLists.txt @@ -0,0 +1,6 @@ +cmake_minimum_required(VERSION 2.8.12) +project(tcbspan) + +add_library(tcbspan STATIC + span.hpp +) diff --git a/src/tcbspan/README.md b/src/tcbspan/README.md new file mode 100644 index 000000000..6e2fba84c --- /dev/null +++ b/src/tcbspan/README.md @@ -0,0 +1,124 @@ +Bundled with PrusaSlicer: +https://github.com/tcbrindle/span +commit 836dc6a0efd9849cb194e88e4aa2387436bb079b +This is not the full distribution, it only contains README and span.hpp +Original README follows: + + +[![Standard](https://img.shields.io/badge/c%2B%2B-11/14/17/20-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization) +[![License](https://img.shields.io/badge/license-BSL-blue.svg)](http://www.boost.org/LICENSE_1_0.txt) +[![Build Status](https://travis-ci.org/tcbrindle/span.svg?branch=master)](https://travis-ci.org/tcbrindle/span) +[![Build status](https://ci.appveyor.com/api/projects/status/ow7cj56s108fs439/branch/master?svg=true)](https://ci.appveyor.com/project/tcbrindle/span/branch/master) +[![Try it on godbolt online](https://img.shields.io/badge/on-godbolt-blue.svg)](https://godbolt.org/z/-vlZZR) + +`std::span` implementation for C++11 and later +============================================== + +This repository contains a single-header implementation of C++20's `std::span`, +conforming to the C++20 committee draft. +It is compatible with C++11, but will use newer language features if they +are available. + +It differs from the implementation in the [Microsoft GSL](https://github.com/Microsoft/GSL/) +in that it is single-header and does not depend on any other GSL facilities. It +also works with C++11, while the GSL version requires C++14. + +Usage +----- + +The recommended way to use the implementation simply copy the file `span.hpp` +from `include/tcb/` into your own sources and `#include` it like +any other header. By default, it lives in namespace `tcb`, but this can be +customised by setting the macro `TCB_SPAN_NAMESPACE_NAME` to an appropriate string +before `#include`-ing the header -- or simply edit the source code. + +The rest of the repository contains testing machinery, and is not required for +use. + +Compatibility +------------- + +This implementation requires a conforming C++11 (or later) compiler, and is tested as far +back as GCC 5, Clang 3.5 and MSVC 2015 Update 3. Older compilers may work, but this is not guaranteed. + +Documentation +------------- + +Documentation for `std::span` is available [on cppreference](https://en.cppreference.com/w/cpp/container/span). + +Implementation Notes +-------------------- + +### Bounds Checking ### + +This implementation of `span` includes optional bounds checking, which is handled +either by throwing an exception or by calling `std::terminate()`. + +The default behaviour with C++14 and later is to check the macro `NDEBUG`: +if this is set, bounds checking is disabled. Otherwise, `std::terminate()` will +be called if there is a precondition violation (i.e. the same behaviour as +`assert()`). If you wish to terminate on errors even if `NDEBUG` is set, define +the symbol `TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION` before `#include`-ing the +header. + +Alternatively, if you want to throw on a contract violation, define +`TCB_SPAN_THROW_ON_CONTRACT_VIOLATION`. This will throw an exception of an +implementation-defined type (deriving from `std::logic_error`), allowing +cleanup to happen. Note that defining this symbol will cause the checks to be +run even if `NDEBUG` is set. + +Lastly, if you wish to disable contract checking even in debug builds, +`#define TCB_SPAN_NO_CONTRACT_CHECKING`. + +Under C++11, due to the restrictions on `constexpr` functions, contract checking +is disabled by default even if `NDEBUG` is not set. You can change this by +defining either of the above symbols, but this will result in most of `span`'s +interface becoming non-`constexpr`. + +### `constexpr` ### + +This implementation is fully `constexpr` under C++17 and later. Under earlier +versions, it is "as `constexpr` as possible". + +Note that even in C++17, it is generally not possible to declare a `span` +as non-default constructed `constexpr` variable, for the same reason that you +cannot form a `constexpr` pointer to a value: it involves taking the address of +a compile-time variable in a way that would be visible at run-time. +You can however use a `span` freely in a `constexpr` function. For example: + +```cpp +// Okay, even in C++11 +constexpr std::ptrdiff_t get_span_size(span span) +{ + return span.size(); +} + +constexpr int arr[] = {1, 2, 3}; +constexpr auto size = get_span_size(arr); // Okay +constexpr span span{arr}; // ERROR -- not a constant expression +constexpr const int* p = arr; // ERROR -- same +``` + +Constructor deduction guides are provided if the compiler supports them. For +older compilers, a set of `make_span()` functions are provided as an extension +which use the same logic, for example: + + ```cpp + constexpr int c_array[] = {1, 2, 3}; + std::array std_array{1, 2, 3}; + const std::vector vec{1, 2, 3}; + + auto s1 = make_span(c_array); // returns span + auto s2 = make_span(std_array); // returns span + auto s3 = make_span(vec); // returns span + ``` + +Alternatives +------------ + +* [Microsoft/GSL](https://github.com/Microsoft/GSL): The original `span` reference + implementation from which `std::span` was born. + +* [martinmoene/span_lite](https://github.com/martinmoene/span-lite): An + alternative implementation which offers C++98 compatibility. + diff --git a/src/tcbspan/span.hpp b/src/tcbspan/span.hpp new file mode 100644 index 000000000..fdc3a988a --- /dev/null +++ b/src/tcbspan/span.hpp @@ -0,0 +1,618 @@ + +/* +This is an implementation of C++20's std::span +http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf +*/ + +// Copyright Tristan Brindle 2018. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file ../../LICENSE_1_0.txt or copy at +// https://www.boost.org/LICENSE_1_0.txt) + +#ifndef TCB_SPAN_HPP_INCLUDED +#define TCB_SPAN_HPP_INCLUDED + +#include +#include +#include +#include + +#ifndef TCB_SPAN_NO_EXCEPTIONS +// Attempt to discover whether we're being compiled with exception support +#if !(defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) +#define TCB_SPAN_NO_EXCEPTIONS +#endif +#endif + +#ifndef TCB_SPAN_NO_EXCEPTIONS +#include +#include +#endif + +// Various feature test macros + +#ifndef TCB_SPAN_NAMESPACE_NAME +#define TCB_SPAN_NAMESPACE_NAME tcb +#endif + +#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +#define TCB_SPAN_HAVE_CPP17 +#endif + +#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) +#define TCB_SPAN_HAVE_CPP14 +#endif + +namespace TCB_SPAN_NAMESPACE_NAME { + +// Establish default contract checking behavior +#if !defined(TCB_SPAN_THROW_ON_CONTRACT_VIOLATION) && \ + !defined(TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION) && \ + !defined(TCB_SPAN_NO_CONTRACT_CHECKING) +#if defined(NDEBUG) || !defined(TCB_SPAN_HAVE_CPP14) +#define TCB_SPAN_NO_CONTRACT_CHECKING +#else +#define TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION +#endif +#endif + +#if defined(TCB_SPAN_THROW_ON_CONTRACT_VIOLATION) +struct contract_violation_error : std::logic_error { + explicit contract_violation_error(const char* msg) : std::logic_error(msg) + {} +}; + +inline void contract_violation(const char* msg) +{ + throw contract_violation_error(msg); +} + +#elif defined(TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION) +[[noreturn]] inline void contract_violation(const char* /*unused*/) +{ + std::terminate(); +} +#endif + +#if !defined(TCB_SPAN_NO_CONTRACT_CHECKING) +#define TCB_SPAN_STRINGIFY(cond) #cond +#define TCB_SPAN_EXPECT(cond) \ + cond ? (void) 0 : contract_violation("Expected " TCB_SPAN_STRINGIFY(cond)) +#else +#define TCB_SPAN_EXPECT(cond) +#endif + +#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_inline_variables) +#define TCB_SPAN_INLINE_VAR inline +#else +#define TCB_SPAN_INLINE_VAR +#endif + +#if defined(TCB_SPAN_HAVE_CPP14) || \ + (defined(__cpp_constexpr) && __cpp_constexpr >= 201304) +#define TCB_SPAN_HAVE_CPP14_CONSTEXPR +#endif + +#if defined(TCB_SPAN_HAVE_CPP14_CONSTEXPR) +#define TCB_SPAN_CONSTEXPR14 constexpr +#else +#define TCB_SPAN_CONSTEXPR14 +#endif + +#if defined(TCB_SPAN_HAVE_CPP14_CONSTEXPR) && \ + (!defined(_MSC_VER) || _MSC_VER > 1900) +#define TCB_SPAN_CONSTEXPR_ASSIGN constexpr +#else +#define TCB_SPAN_CONSTEXPR_ASSIGN +#endif + +#if defined(TCB_SPAN_NO_CONTRACT_CHECKING) +#define TCB_SPAN_CONSTEXPR11 constexpr +#else +#define TCB_SPAN_CONSTEXPR11 TCB_SPAN_CONSTEXPR14 +#endif + +#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_deduction_guides) +#define TCB_SPAN_HAVE_DEDUCTION_GUIDES +#endif + +#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte) +#define TCB_SPAN_HAVE_STD_BYTE +#endif + +#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr) +#define TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC +#endif + +#if defined(TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC) +#define TCB_SPAN_ARRAY_CONSTEXPR constexpr +#else +#define TCB_SPAN_ARRAY_CONSTEXPR +#endif + +#ifdef TCB_SPAN_HAVE_STD_BYTE +using byte = std::byte; +#else +using byte = unsigned char; +#endif + +#if defined(TCB_SPAN_HAVE_CPP17) +#define TCB_SPAN_NODISCARD [[nodiscard]] +#else +#define TCB_SPAN_NODISCARD +#endif + +TCB_SPAN_INLINE_VAR constexpr std::size_t dynamic_extent = SIZE_MAX; + +template +class span; + +namespace detail { + +template +struct span_storage { + constexpr span_storage() noexcept = default; + + constexpr span_storage(E* p_ptr, std::size_t /*unused*/) noexcept + : ptr(p_ptr) + {} + + E* ptr = nullptr; + static constexpr std::size_t size = S; +}; + +template +struct span_storage { + constexpr span_storage() noexcept = default; + + constexpr span_storage(E* p_ptr, std::size_t p_size) noexcept + : ptr(p_ptr), size(p_size) + {} + + E* ptr = nullptr; + std::size_t size = 0; +}; + +// Reimplementation of C++17 std::size() and std::data() +#if defined(TCB_SPAN_HAVE_CPP17) || \ + defined(__cpp_lib_nonmember_container_access) +using std::data; +using std::size; +#else +template +constexpr auto size(const C& c) -> decltype(c.size()) +{ + return c.size(); +} + +template +constexpr std::size_t size(const T (&)[N]) noexcept +{ + return N; +} + +template +constexpr auto data(C& c) -> decltype(c.data()) +{ + return c.data(); +} + +template +constexpr auto data(const C& c) -> decltype(c.data()) +{ + return c.data(); +} + +template +constexpr T* data(T (&array)[N]) noexcept +{ + return array; +} + +template +constexpr const E* data(std::initializer_list il) noexcept +{ + return il.begin(); +} +#endif // TCB_SPAN_HAVE_CPP17 + +#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_void_t) +using std::void_t; +#else +template +using void_t = void; +#endif + +template +using uncvref_t = + typename std::remove_cv::type>::type; + +template +struct is_span : std::false_type {}; + +template +struct is_span> : std::true_type {}; + +template +struct is_std_array : std::false_type {}; + +template +struct is_std_array> : std::true_type {}; + +template +struct has_size_and_data : std::false_type {}; + +template +struct has_size_and_data())), + decltype(detail::data(std::declval()))>> + : std::true_type {}; + +template > +struct is_container { + static constexpr bool value = + !is_span::value && !is_std_array::value && + !std::is_array::value && has_size_and_data::value; +}; + +template +using remove_pointer_t = typename std::remove_pointer::type; + +template +struct is_container_element_type_compatible : std::false_type {}; + +template +struct is_container_element_type_compatible< + T, E, + typename std::enable_if< + !std::is_same< + typename std::remove_cv()))>::type, + void>::value && + std::is_convertible< + remove_pointer_t()))> (*)[], + E (*)[]>::value + >::type> + : std::true_type {}; + +template +struct is_complete : std::false_type {}; + +template +struct is_complete : std::true_type {}; + +} // namespace detail + +template +class span { + static_assert(std::is_object::value, + "A span's ElementType must be an object type (not a " + "reference type or void)"); + static_assert(detail::is_complete::value, + "A span's ElementType must be a complete type (not a forward " + "declaration)"); + static_assert(!std::is_abstract::value, + "A span's ElementType cannot be an abstract class type"); + + using storage_type = detail::span_storage; + +public: + // constants and types + using element_type = ElementType; + using value_type = typename std::remove_cv::type; + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using pointer = element_type*; + using const_pointer = const element_type*; + using reference = element_type&; + using const_reference = const element_type&; + using iterator = pointer; + using reverse_iterator = std::reverse_iterator; + + static constexpr size_type extent = Extent; + + // [span.cons], span constructors, copy, assignment, and destructor + template < + std::size_t E = Extent, + typename std::enable_if<(E == dynamic_extent || E <= 0), int>::type = 0> + constexpr span() noexcept + {} + + TCB_SPAN_CONSTEXPR11 span(pointer ptr, size_type count) + : storage_(ptr, count) + { + TCB_SPAN_EXPECT(extent == dynamic_extent || count == extent); + } + + TCB_SPAN_CONSTEXPR11 span(pointer first_elem, pointer last_elem) + : storage_(first_elem, last_elem - first_elem) + { + TCB_SPAN_EXPECT(extent == dynamic_extent || + last_elem - first_elem == + static_cast(extent)); + } + + template ::value, + int>::type = 0> + constexpr span(element_type (&arr)[N]) noexcept : storage_(arr, N) + {} + + template &, ElementType>::value, + int>::type = 0> + TCB_SPAN_ARRAY_CONSTEXPR span(std::array& arr) noexcept + : storage_(arr.data(), N) + {} + + template &, ElementType>::value, + int>::type = 0> + TCB_SPAN_ARRAY_CONSTEXPR span(const std::array& arr) noexcept + : storage_(arr.data(), N) + {} + + template < + typename Container, std::size_t E = Extent, + typename std::enable_if< + E == dynamic_extent && detail::is_container::value && + detail::is_container_element_type_compatible< + Container&, ElementType>::value, + int>::type = 0> + constexpr span(Container& cont) + : storage_(detail::data(cont), detail::size(cont)) + {} + + template < + typename Container, std::size_t E = Extent, + typename std::enable_if< + E == dynamic_extent && detail::is_container::value && + detail::is_container_element_type_compatible< + const Container&, ElementType>::value, + int>::type = 0> + constexpr span(const Container& cont) + : storage_(detail::data(cont), detail::size(cont)) + {} + + constexpr span(const span& other) noexcept = default; + + template ::value, + int>::type = 0> + constexpr span(const span& other) noexcept + : storage_(other.data(), other.size()) + {} + + ~span() noexcept = default; + + TCB_SPAN_CONSTEXPR_ASSIGN span& + operator=(const span& other) noexcept = default; + + // [span.sub], span subviews + template + TCB_SPAN_CONSTEXPR11 span first() const + { + TCB_SPAN_EXPECT(Count <= size()); + return {data(), Count}; + } + + template + TCB_SPAN_CONSTEXPR11 span last() const + { + TCB_SPAN_EXPECT(Count <= size()); + return {data() + (size() - Count), Count}; + } + + template + using subspan_return_t = + span; + + template + TCB_SPAN_CONSTEXPR11 subspan_return_t subspan() const + { + TCB_SPAN_EXPECT(Offset <= size() && + (Count == dynamic_extent || Offset + Count <= size())); + return {data() + Offset, + Count != dynamic_extent ? Count : size() - Offset}; + } + + TCB_SPAN_CONSTEXPR11 span + first(size_type count) const + { + TCB_SPAN_EXPECT(count <= size()); + return {data(), count}; + } + + TCB_SPAN_CONSTEXPR11 span + last(size_type count) const + { + TCB_SPAN_EXPECT(count <= size()); + return {data() + (size() - count), count}; + } + + TCB_SPAN_CONSTEXPR11 span + subspan(size_type offset, size_type count = dynamic_extent) const + { + TCB_SPAN_EXPECT(offset <= size() && + (count == dynamic_extent || offset + count <= size())); + return {data() + offset, + count == dynamic_extent ? size() - offset : count}; + } + + // [span.obs], span observers + constexpr size_type size() const noexcept { return storage_.size; } + + constexpr size_type size_bytes() const noexcept + { + return size() * sizeof(element_type); + } + + TCB_SPAN_NODISCARD constexpr bool empty() const noexcept + { + return size() == 0; + } + + // [span.elem], span element access + TCB_SPAN_CONSTEXPR11 reference operator[](size_type idx) const + { + TCB_SPAN_EXPECT(idx < size()); + return *(data() + idx); + } + + TCB_SPAN_CONSTEXPR11 reference front() const + { + TCB_SPAN_EXPECT(!empty()); + return *data(); + } + + TCB_SPAN_CONSTEXPR11 reference back() const + { + TCB_SPAN_EXPECT(!empty()); + return *(data() + (size() - 1)); + } + + constexpr pointer data() const noexcept { return storage_.ptr; } + + // [span.iterators], span iterator support + constexpr iterator begin() const noexcept { return data(); } + + constexpr iterator end() const noexcept { return data() + size(); } + + TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rbegin() const noexcept + { + return reverse_iterator(end()); + } + + TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rend() const noexcept + { + return reverse_iterator(begin()); + } + +private: + storage_type storage_{}; +}; + +#ifdef TCB_SPAN_HAVE_DEDUCTION_GUIDES + +/* Deduction Guides */ +template +span(T (&)[N])->span; + +template +span(std::array&)->span; + +template +span(const std::array&)->span; + +template +span(Container&)->span()))>::type>; + +template +span(const Container&)->span; + +#endif // TCB_HAVE_DEDUCTION_GUIDES + +template +constexpr span +make_span(span s) noexcept +{ + return s; +} + +template +constexpr span make_span(T (&arr)[N]) noexcept +{ + return {arr}; +} + +template +TCB_SPAN_ARRAY_CONSTEXPR span make_span(std::array& arr) noexcept +{ + return {arr}; +} + +template +TCB_SPAN_ARRAY_CONSTEXPR span +make_span(const std::array& arr) noexcept +{ + return {arr}; +} + +template +constexpr span()))>::type> +make_span(Container& cont) +{ + return {cont}; +} + +template +constexpr span +make_span(const Container& cont) +{ + return {cont}; +} + +template +span +as_bytes(span s) noexcept +{ + return {reinterpret_cast(s.data()), s.size_bytes()}; +} + +template < + class ElementType, size_t Extent, + typename std::enable_if::value, int>::type = 0> +span +as_writable_bytes(span s) noexcept +{ + return {reinterpret_cast(s.data()), s.size_bytes()}; +} + +template +constexpr auto get(span s) -> decltype(s[N]) +{ + return s[N]; +} + +} // namespace TCB_SPAN_NAMESPACE_NAME + +namespace std { + +template +class tuple_size> + : public integral_constant {}; + +template +class tuple_size>; // not defined + +template +class tuple_element> { +public: + static_assert(Extent != TCB_SPAN_NAMESPACE_NAME::dynamic_extent && + I < Extent, + ""); + using type = ElementType; +}; + +} // end namespace std + +#endif // TCB_SPAN_HPP_INCLUDED diff --git a/tests/fff_print/test_print.cpp b/tests/fff_print/test_print.cpp index 395f75841..d8ab5a3fa 100644 --- a/tests/fff_print/test_print.cpp +++ b/tests/fff_print/test_print.cpp @@ -62,7 +62,7 @@ SCENARIO("Print: Changing number of solid surfaces does not cause all surfaces t // Precondition: Ensure that the model has 2 solid top layers (39, 38) // and one solid bottom layer (0). auto test_is_solid_infill = [&print](size_t obj_id, size_t layer_id) { - const Layer &layer = *(print.objects().at(obj_id)->get_layer((int)layer_id)); + const Layer &layer = *print.objects()[obj_id]->get_layer((int)layer_id); // iterate over all of the regions in the layer for (const LayerRegion *region : layer.regions()) { // for each region, iterate over the fill surfaces diff --git a/tests/fff_print/test_printobject.cpp b/tests/fff_print/test_printobject.cpp index 8d322f58f..cbc47345c 100644 --- a/tests/fff_print/test_printobject.cpp +++ b/tests/fff_print/test_printobject.cpp @@ -18,7 +18,7 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") { { "layer_height", 2 }, { "nozzle_diameter", 3 } }); - ConstLayerPtrsAdaptor layers = print.objects().front()->layers(); + SpanOfConstPtrs layers = print.objects().front()->layers(); THEN("The output vector has 10 entries") { REQUIRE(layers.size() == 10); } @@ -37,7 +37,7 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") { { "layer_height", 10 }, { "nozzle_diameter", 11 } }); - ConstLayerPtrsAdaptor layers = print.objects().front()->layers(); + SpanOfConstPtrs layers = print.objects().front()->layers(); THEN("The output vector has 3 entries") { REQUIRE(layers.size() == 3); } @@ -55,7 +55,7 @@ SCENARIO("PrintObject: object layer heights", "[PrintObject]") { { "layer_height", 15 }, { "nozzle_diameter", 16 } }); - ConstLayerPtrsAdaptor layers = print.objects().front()->layers(); + SpanOfConstPtrs layers = print.objects().front()->layers(); THEN("The output vector has 2 entries") { REQUIRE(layers.size() == 2); } diff --git a/tests/fff_print/test_support_material.cpp b/tests/fff_print/test_support_material.cpp index c5087263c..0720b270c 100644 --- a/tests/fff_print/test_support_material.cpp +++ b/tests/fff_print/test_support_material.cpp @@ -27,7 +27,7 @@ SCENARIO("SupportMaterial: support_layers_z and contact_distance", "[SupportMate auto check = [](Slic3r::Print &print, bool &first_support_layer_height_ok, bool &layer_height_minimum_ok, bool &layer_height_maximum_ok, bool &top_spacing_ok) { - ConstSupportLayerPtrsAdaptor support_layers = print.objects().front()->support_layers(); + SpanOfConstPtrs support_layers = print.objects().front()->support_layers(); first_support_layer_height_ok = support_layers.front()->print_z == print.config().first_layer_height.value;