diff options
author | Dan Albert <danalbert@google.com> | 2016-11-02 23:23:13 +0000 |
---|---|---|
committer | android-build-merger <android-build-merger@google.com> | 2016-11-02 23:23:13 +0000 |
commit | 61a39851f1e83be625653a90de2280e72ee02c86 (patch) | |
tree | 58c9c3b6c5838d9f02a7b31cc0401cc006e48e52 | |
parent | 00d43d4dd182cc4ed525f5ac62774bd19b516a95 (diff) | |
parent | 1f29230e1792466b05064003a719187425ddc581 (diff) | |
download | platform_external_Microsoft-GSL-61a39851f1e83be625653a90de2280e72ee02c86.tar.gz platform_external_Microsoft-GSL-61a39851f1e83be625653a90de2280e72ee02c86.tar.bz2 platform_external_Microsoft-GSL-61a39851f1e83be625653a90de2280e72ee02c86.zip |
Merge remote-tracking branch 'aosp/upstream-master' into master am: 65c0aaa266 am: 8141d27f91 am: 9fbbf8bb2f
am: 1f29230e17
Change-Id: Iac67c6d3d332a769e3762b6e94087a8b3650d67c
-rw-r--r-- | .clang-format | 21 | ||||
-rw-r--r-- | .gitignore | 13 | ||||
-rw-r--r-- | .gitmodules | 3 | ||||
-rw-r--r-- | .travis.yml | 142 | ||||
-rw-r--r-- | CMakeLists.txt | 25 | ||||
-rw-r--r-- | CONTRIBUTING.md | 29 | ||||
-rw-r--r-- | LICENSE | 21 | ||||
-rw-r--r-- | README.md | 86 | ||||
-rw-r--r-- | gsl/gsl | 172 | ||||
-rw-r--r-- | gsl/gsl_assert | 85 | ||||
-rw-r--r-- | gsl/gsl_byte | 161 | ||||
-rw-r--r-- | gsl/gsl_util | 185 | ||||
-rw-r--r-- | gsl/multi_span | 2231 | ||||
-rw-r--r-- | gsl/span | 673 | ||||
-rw-r--r-- | gsl/string_span | 870 | ||||
-rw-r--r-- | tests/CMakeLists.txt | 54 | ||||
-rw-r--r-- | tests/assertion_tests.cpp | 53 | ||||
-rw-r--r-- | tests/at_tests.cpp | 71 | ||||
-rw-r--r-- | tests/bounds_tests.cpp | 103 | ||||
-rw-r--r-- | tests/byte_tests.cpp | 135 | ||||
-rw-r--r-- | tests/multi_span_tests.cpp | 1685 | ||||
-rw-r--r-- | tests/notnull_tests.cpp | 103 | ||||
-rw-r--r-- | tests/owner_tests.cpp | 43 | ||||
-rw-r--r-- | tests/span_tests.cpp | 1385 | ||||
-rw-r--r-- | tests/strided_span_tests.cpp | 748 | ||||
-rw-r--r-- | tests/string_span_tests.cpp | 971 | ||||
m--------- | tests/unittest-cpp | 0 | ||||
-rw-r--r-- | tests/utils_tests.cpp | 119 |
28 files changed, 10187 insertions, 0 deletions
diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..78696f5 --- /dev/null +++ b/.clang-format @@ -0,0 +1,21 @@ +ColumnLimit: 100 + +UseTab: Never +IndentWidth: 4 +AccessModifierOffset: -4 +NamespaceIndentation: Inner + +BreakBeforeBraces: Allman +AlwaysBreakTemplateDeclarations: true +BreakConstructorInitializersBeforeComma: true +ConstructorInitializerAllOnOneLineOrOnePerLine: true +AllowShortBlocksOnASingleLine: true +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: true +AllowShortLoopsOnASingleLine: true + +PointerAlignment: Left +AlignConsecutiveAssignments: false +AlignTrailingComments: true + +SpaceAfterCStyleCast: true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d452689 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +CMakeFiles +tests/CMakeFiles +tests/Debug +*.opensdf +*.sdf +tests/*tests.dir +*.vcxproj +*.vcxproj.filters +*.sln +*.tlog +Testing/Temporary/*.* +CMakeCache.txt +*.suo diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d9229ae --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "tests/unittest-cpp"] + path = tests/unittest-cpp + url = https://github.com/Microsoft/unittest-cpp.git diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..5c69187 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,142 @@ +# Based on https://github.com/ldionne/hana/blob/master/.travis.yml + +language: cpp +sudo: false + +cache: + directories: + - ${TRAVIS_BUILD_DIR}/deps/cmake + - ${TRAVIS_BUILD_DIR}/deps/llvm-3.5.2/install + - ${TRAVIS_BUILD_DIR}/deps/llvm-3.6.2/install + - ${TRAVIS_BUILD_DIR}/deps/llvm-3.7.1/install + - ${TRAVIS_BUILD_DIR}/deps/llvm-3.8.1/install + - ${TRAVIS_BUILD_DIR}/deps/llvm-3.9.0/install + +matrix: + include: + - env: BUILD_TYPE=Debug + os: osx + osx_image: xcode8 + compiler: clang + - env: BUILD_TYPE=Release + os: osx + osx_image: xcode8 + compiler: clang + - env: CLANG_VERSION=3.6 BUILD_TYPE=Debug + os: linux + addons: &clang36 + apt: + packages: + - clang-3.6 + - g++-5 + sources: &sources + - ubuntu-toolchain-r-test + - llvm-toolchain-precise-3.6 + - env: CLANG_VERSION=3.6 BUILD_TYPE=Release + os: linux + addons: *clang36 + - env: CLANG_VERSION=3.7 BUILD_TYPE=Debug + os: linux + addons: &clang37 + apt: + packages: + - clang-3.7 + - g++-5 + sources: &sources + - ubuntu-toolchain-r-test + - llvm-toolchain-precise-3.7 + - env: CLANG_VERSION=3.7 BUILD_TYPE=Release + os: linux + addons: *clang37 + - env: CLANG_VERSION=3.8 BUILD_TYPE=Debug + os: linux + addons: &clang38 + apt: + packages: + - clang-3.8 + - g++-5 + sources: &sources + - ubuntu-toolchain-r-test + - llvm-toolchain-precise-3.8 + - env: CLANG_VERSION=3.8 BUILD_TYPE=Release + os: linux + addons: *clang38 + - env: GCC_VERSION=5 BUILD_TYPE=Debug + os: linux + addons: &gcc5 + apt: + packages: g++-5 + sources: *sources + - env: GCC_VERSION=5 BUILD_TYPE=Release + os: linux + addons: *gcc5 + - env: GCC_VERSION=6 BUILD_TYPE=Debug + os: linux + addons: &gcc6 + apt: + packages: g++-6 + sources: *sources + - env: GCC_VERSION=6 BUILD_TYPE=Release + os: linux + addons: *gcc6 + +install: + - if [[ -n "$CLANG_VERSION" ]]; then export CXX=clang++-$CLANG_VERSION CC=clang-$CLANG_VERSION; fi + - if [[ -n "$GCC_VERSION" ]]; then export CXX=g++-$GCC_VERSION CC=gcc-$GCC_VERSION; fi + - JOBS=2 + - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps" + - mkdir -p "${DEPS_DIR}" && cd "${DEPS_DIR}" + + ############################################################################ + # Install a recent CMake (unless already installed on OS X) + ############################################################################ + - | + if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then + if [[ -z "$(ls -A ${DEPS_DIR}/cmake/bin)" ]]; then + CMAKE_URL="https://cmake.org/files/v3.6/cmake-3.6.2-Linux-x86_64.tar.gz" + mkdir -p cmake && travis_retry wget --no-check-certificate --quiet -O - "${CMAKE_URL}" | tar --strip-components=1 -xz -C cmake + fi + export PATH="${DEPS_DIR}/cmake/bin:${PATH}" + else + if ! brew ls --version cmake &>/dev/null; then brew install cmake; fi + fi + + ############################################################################ + # [linux]: Install the right version of libc++ + ############################################################################ + - | + if [[ -n "$CLANG_VERSION" && "${TRAVIS_OS_NAME}" == "linux" && "${STDLIB}" != "libstdc++" ]]; then + if [[ "$CLANG_VERSION" == "3.5" ]]; then LLVM_VERSION="3.5.2"; fi + if [[ "$CLANG_VERSION" == "3.6" ]]; then LLVM_VERSION="3.6.2"; fi + if [[ "$CLANG_VERSION" == "3.7" ]]; then LLVM_VERSION="3.7.1"; fi + if [[ "$CLANG_VERSION" == "3.8" ]]; then LLVM_VERSION="3.8.1"; fi + if [[ "$CLANG_VERSION" == "3.9" ]]; then LLVM_VERSION="3.9.0"; fi + LLVM_ROOT="${DEPS_DIR}/llvm-${LLVM_VERSION}" + LLVM_URL="http://llvm.org/releases/${LLVM_VERSION}/llvm-${LLVM_VERSION}.src.tar.xz" + LIBCXX_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxx-${LLVM_VERSION}.src.tar.xz" + LIBCXXABI_URL="http://llvm.org/releases/${LLVM_VERSION}/libcxxabi-${LLVM_VERSION}.src.tar.xz" + if [[ -z "$(ls -A ${LLVM_ROOT}/install/include)" ]]; then + mkdir -p "${LLVM_ROOT}" "${LLVM_ROOT}/build" "${LLVM_ROOT}/projects/libcxx" "${LLVM_ROOT}/projects/libcxxabi" + travis_retry wget --quiet -O - "${LLVM_URL}" | tar --strip-components=1 -xJ -C "${LLVM_ROOT}" + travis_retry wget --quiet -O - "${LIBCXX_URL}" | tar --strip-components=1 -xJ -C "${LLVM_ROOT}/projects/libcxx" + travis_retry wget --quiet -O - "${LIBCXXABI_URL}" | tar --strip-components=1 -xJ -C "${LLVM_ROOT}/projects/libcxxabi" + (cd "${LLVM_ROOT}/build" && cmake .. -DCMAKE_CXX_COMPILER="$CXX" -DCMAKE_C_COMPILER="$CC" -DCMAKE_INSTALL_PREFIX="${LLVM_ROOT}/install" -DCMAKE_BUILD_TYPE=$BUILD_TYPE) + (cd "${LLVM_ROOT}/build/projects/libcxx" && make install -j$JOBS) + (cd "${LLVM_ROOT}/build/projects/libcxxabi" && make install -j$JOBS) + fi + export CXXFLAGS="-I ${LLVM_ROOT}/install/include/c++/v1" + export LDFLAGS="-L ${LLVM_ROOT}/install/lib -lc++ -lc++abi" + export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${LLVM_ROOT}/install/lib" + fi + +before_script: + - cd "${TRAVIS_BUILD_DIR}" + - cmake . -Bbuild -DCMAKE_CXX_COMPILER="$CXX" -DCMAKE_C_COMPILER="$CC" -DCMAKE_BUILD_TYPE=$BUILD_TYPE + - cmake --build build -- -j$JOBS + +script: + - cd build + - ctest --output-on-failure -j$JOBS + +notifications: + email: false diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..2f1b0f1 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 2.8.7) + +project(GSL CXX) + +set(GSL_HEADERS + "gsl/gsl" + "gsl/gsl_assert" + "gsl/gsl_byte" + "gsl/gsl_util" + "gsl/multi_span" + "gsl/span" + "gsl/string_span" +) + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} +) + +install(FILES ${GSL_HEADERS} + DESTINATION include/gsl +) + +enable_testing() + +add_subdirectory(tests) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..10e6c32 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,29 @@ +## Contributing to the Guideline Support Library + +The Guideline Support Library (GSL) contains functions and types that are suggested for use by the +[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines). GSL design changes are made only as a result of modifications to the Guidelines. + +GSL is accepting contributions that improve or refine any of the types in this library as well as ports to other platforms. Changes should have an issue +tracking the suggestion that has been approved by the maintainers. Your pull request should include a link to the bug that you are fixing. If you've submitted +a PR, please post a comment in the associated issue to avoid duplication of effort. + +## Legal +You will need to complete a Contributor License Agreement (CLA). Briefly, this agreement testifies that you are granting us and the community permission to +use the submitted change according to the terms of the project's license, and that the work being submitted is under appropriate copyright. + +Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally. + +## Housekeeping +Your pull request should: + +* Include a description of what your change intends to do +* Be a child commit of a reasonably recent commit in the **master** branch + * Requests need not be a single commit, but should be a linear sequence of commits (i.e. no merge commits in your PR) +* It is desirable, but not necessary, for the tests to pass at each commit. Please see [README.md](./README.md) for instructions to build the test suite. +* Have clear commit messages + * e.g. "Fix issue", "Add tests for type", etc. +* Include appropriate tests + * Tests should include reasonable permutations of the target fix/change + * Include baseline changes with your change + * All changed code must have 100% code coverage +* To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration @@ -0,0 +1,21 @@ +Copyright (c) 2015 Microsoft Corporation. All rights reserved. + +This code is licensed under the MIT License (MIT). + +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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..c3aff66 --- /dev/null +++ b/README.md @@ -0,0 +1,86 @@ +# GSL: Guideline Support Library [![Build Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL) [![Build status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL) + +The Guideline Support Library (GSL) contains functions and types that are suggested for use by the +[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org). +This repo contains Microsoft's implementation of GSL. + +The library includes types like `span<T>`, `string_span`, `owner<>` and others. + +The entire implementation is provided inline in the headers under the [gsl](./gsl) directory. The implementation generally assumes a platform that implements C++14 support. There are specific workarounds to support MSVC 2013 and 2015. + +While some types have been broken out into their own headers (e.g. [gsl/span](./gsl/span)), +it is simplest to just include [gsl/gsl](./gsl/gsl) and gain access to the entire library. + +> NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to +other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing. + +# Project Code of Conduct +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. + +# Quick Start +## Supported Platforms +The test suite that exercises GSL has been built and passes successfully on the following platforms:<sup>1)</sup> + +* Windows using Visual Studio 2013 +* Windows using Visual Studio 2015 +* Windows using Clang/LLVM 3.6 +* Windows using GCC 5.1 +* GNU/Linux using Clang/LLVM 3.6 +* GNU/Linux using GCC 5.1 +* OS X Yosemite using Xcode with AppleClang 7.0.0.7000072 +* OS X Yosemite using GCC-5.2.0 +* FreeBSD 10.x with Clang/LLVM 3.6 + +> If you successfully port GSL to another platform, we would love to hear from you. Please submit an issue to let us know. Also please consider +contributing any changes that were necessary back to this project to benefit the wider community. + +<sup>1)</sup> For `gsl::byte` to work correctly with Clang and GCC you might have to use the ` -fno-strict-aliasing` compiler option. + +## Building the tests +To build the tests, you will require the following: + +* [CMake](http://cmake.org), version 2.8.7 or later to be installed and in your PATH. +* [UnitTest-cpp](https://github.com/Microsoft/unittest-cpp), to be cloned under the [tests/unittest-cpp](./tests/unittest-cpp) directory +of your GSL source. + +These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`. + +1. Create a directory to contain the build outputs for a particular architecture (we name it c:\GSL\build-x86 in this example). + + cd GSL + md build-x86 + cd build-x86 + +2. Configure CMake to use the compiler of your choice (you can see a list by running `cmake --help`). + + cmake -G "Visual Studio 14 2015" c:\GSL + +3. Build the test suite (in this case, in the Debug configuration, Release is another good choice). + + cmake --build . --config Debug + +4. Run the test suite. + + ctest -C Debug + +All tests should pass - indicating your platform is fully supported and you are ready to use the GSL types! + +## Using the libraries +As the types are entirely implemented inline in headers, there are no linking requirements. + +You can copy the [gsl](./gsl) directory into your source tree so it is available +to your compiler, then include the appropriate headers in your program. + +Alternatively set your compiler's *include path* flag to point to the GSL development folder (`c:\GSL` in the example above) or installation folder (after running the install). Eg. + +MSVC++ + + /I c:\GSL + +GCC/clang + + -I$HOME/dev/GSL + +Include the library using: + + #include <gsl/gsl> @@ -0,0 +1,172 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_GSL_H +#define GSL_GSL_H + +#include "gsl_assert" // Ensures/Expects +#include "gsl_util" // finally()/narrow()/narrow_cast()... +#include "multi_span" // multi_span, strided_span... +#include "span" // span +#include "string_span" // zstring, string_span, zstring_builder... +#include <memory> + +#ifdef _MSC_VER + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +// MSVC 2013 workarounds +#if _MSC_VER <= 1800 +// noexcept is not understood +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +namespace gsl +{ + +// +// GSL.owner: ownership pointers +// +using std::unique_ptr; +using std::shared_ptr; + +template <class T> +using owner = T; + +// +// not_null +// +// Restricts a pointer or smart pointer to only hold non-null values. +// +// Has zero size overhead over T. +// +// If T is a pointer (i.e. T == U*) then +// - allow construction from U* or U& +// - disallow construction from nullptr_t +// - disallow default construction +// - ensure construction from U* fails with nullptr +// - allow implicit conversion to U* +// +template <class T> +class not_null +{ + static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr."); + +public: + not_null(T t) : ptr_(t) { ensure_invariant(); } + not_null& operator=(const T& t) + { + ptr_ = t; + ensure_invariant(); + return *this; + } + + not_null(const not_null& other) = default; + not_null& operator=(const not_null& other) = default; + + template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>> + not_null(const not_null<U>& other) + { + *this = other; + } + + template <typename U, typename Dummy = std::enable_if_t<std::is_convertible<U, T>::value>> + not_null& operator=(const not_null<U>& other) + { + ptr_ = other.get(); + return *this; + } + + // prevents compilation when someone attempts to assign a nullptr + not_null(std::nullptr_t) = delete; + not_null(int) = delete; + not_null<T>& operator=(std::nullptr_t) = delete; + not_null<T>& operator=(int) = delete; + + T get() const + { +#ifdef _MSC_VER + __assume(ptr_ != nullptr); +#endif + return ptr_; + } // the assume() should help the optimizer + + operator T() const { return get(); } + T operator->() const { return get(); } + + bool operator==(const T& rhs) const { return ptr_ == rhs; } + bool operator!=(const T& rhs) const { return !(*this == rhs); } +private: + T ptr_; + + // we assume that the compiler can hoist/prove away most of the checks inlined from this + // function + // if not, we could make them optional via conditional compilation + void ensure_invariant() const { Expects(ptr_ != nullptr); } + + // unwanted operators...pointers only point to single objects! + // TODO ensure all arithmetic ops on this type are unavailable + not_null<T>& operator++() = delete; + not_null<T>& operator--() = delete; + not_null<T> operator++(int) = delete; + not_null<T> operator--(int) = delete; + not_null<T>& operator+(size_t) = delete; + not_null<T>& operator+=(size_t) = delete; + not_null<T>& operator-(size_t) = delete; + not_null<T>& operator-=(size_t) = delete; +}; + +} // namespace gsl + +namespace std +{ +template <class T> +struct hash<gsl::not_null<T>> +{ + size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); } +}; + +} // namespace std + +#ifdef _MSC_VER + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 + +#undef noexcept +#pragma pop_macro("noexcept") + +#pragma warning(pop) + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#endif // GSL_GSL_H diff --git a/gsl/gsl_assert b/gsl/gsl_assert new file mode 100644 index 0000000..6d8760d --- /dev/null +++ b/gsl/gsl_assert @@ -0,0 +1,85 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_CONTRACTS_H +#define GSL_CONTRACTS_H + +#include <exception> +#include <stdexcept> + +// +// There are three configuration options for this GSL implementation's behavior +// when pre/post conditions on the GSL types are violated: +// +// 1. GSL_TERMINATE_ON_CONTRACT_VIOLATION: std::terminate will be called (default) +// 2. GSL_THROW_ON_CONTRACT_VIOLATION: a gsl::fail_fast exception will be thrown +// 3. GSL_UNENFORCED_ON_CONTRACT_VIOLATION: nothing happens +// +#if !(defined(GSL_THROW_ON_CONTRACT_VIOLATION) ^ defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) ^ \ + defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)) +#define GSL_TERMINATE_ON_CONTRACT_VIOLATION +#endif + +#define GSL_STRINGIFY_DETAIL(x) #x +#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x) + +#if defined(__clang__) || defined(__GNUC__) +#define GSL_LIKELY(x) __builtin_expect (!!(x), 1) +#define GSL_UNLIKELY(x) __builtin_expect (!!(x), 0) +#else +#define GSL_LIKELY(x) (x) +#define GSL_UNLIKELY(x) (x) +#endif + +// +// GSL.assert: assertions +// + +namespace gsl +{ +struct fail_fast : public std::runtime_error +{ + explicit fail_fast(char const* const message) : std::runtime_error(message) {} +}; +} + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#define Expects(cond) \ + if (GSL_UNLIKELY(!(cond))) \ + throw gsl::fail_fast("GSL: Precondition failure at " __FILE__ ": " GSL_STRINGIFY(__LINE__)); +#define Ensures(cond) \ + if (GSL_UNLIKELY(!(cond))) \ + throw gsl::fail_fast("GSL: Postcondition failure at " __FILE__ \ + ": " GSL_STRINGIFY(__LINE__)); + +#elif defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION) + +#define Expects(cond) \ + if (GSL_UNLIKELY(!(cond))) std::terminate(); +#define Ensures(cond) \ + if (GSL_UNLIKELY(!(cond))) std::terminate(); + +#elif defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION) + +#define Expects(cond) +#define Ensures(cond) + +#endif + +#endif // GSL_CONTRACTS_H diff --git a/gsl/gsl_byte b/gsl/gsl_byte new file mode 100644 index 0000000..3f77923 --- /dev/null +++ b/gsl/gsl_byte @@ -0,0 +1,161 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_BYTE_H +#define GSL_BYTE_H + +#ifdef _MSC_VER + +#pragma warning(push) + +// don't warn about function style casts in byte related operators +#pragma warning(disable : 26493) + +// MSVC 2013 workarounds +#if _MSC_VER <= 1800 + +// constexpr is not understood +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +// noexcept is not understood +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +namespace gsl +{ +// This is a simple definition for now that allows +// use of byte within span<> to be standards-compliant +enum class byte : unsigned char +{ +}; + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +inline constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept +{ + return b = byte(static_cast<unsigned char>(b) << shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +inline constexpr byte operator<<(byte b, IntegerType shift) noexcept +{ + return byte(static_cast<unsigned char>(b) << shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +inline constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept +{ + return b = byte(static_cast<unsigned char>(b) >> shift); +} + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +inline constexpr byte operator>>(byte b, IntegerType shift) noexcept +{ + return byte(static_cast<unsigned char>(b) >> shift); +} + +inline constexpr byte& operator|=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); +} + +inline constexpr byte operator|(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r)); +} + +inline constexpr byte& operator&=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); +} + +inline constexpr byte operator&(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r)); +} + +inline constexpr byte& operator^=(byte& l, byte r) noexcept +{ + return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); +} + +inline constexpr byte operator^(byte l, byte r) noexcept +{ + return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r)); +} + +inline constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); } + +template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>> +inline constexpr IntegerType to_integer(byte b) noexcept +{ + return static_cast<IntegerType>(b); +} + +template<bool E, typename T> +inline constexpr byte to_byte_impl(T t) noexcept +{ + static_assert( + E, + "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. " + "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version." + ); + return static_cast<byte>(t); +} +template<> +inline constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept +{ + return byte(t); +} + +template<typename T> +inline constexpr byte to_byte(T t) noexcept +{ + return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t); +} + +template <int I> +inline constexpr byte to_byte() noexcept +{ + static_assert(I >= 0 && I <= 255, "gsl::byte only has 8 bits of storage, values must be in range 0-255"); + return static_cast<byte>(I); +} + +} // namespace gsl + +#ifdef _MSC_VER + +#if _MSC_VER <= 1800 + +#undef constexpr +#pragma pop_macro("constexpr") + +#undef noexcept +#pragma pop_macro("noexcept") + +#endif // _MSC_VER <= 1800 + +#pragma warning(pop) + +#endif // _MSC_VER + +#endif // GSL_BYTE_H diff --git a/gsl/gsl_util b/gsl/gsl_util new file mode 100644 index 0000000..f0ac964 --- /dev/null +++ b/gsl/gsl_util @@ -0,0 +1,185 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_UTIL_H +#define GSL_UTIL_H + +#include "gsl_assert" // Ensures/Expects +#include <array> +#include <exception> +#include <type_traits> +#include <utility> + +#ifdef _MSC_VER + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +#pragma warning(push) +#pragma warning(disable : 4127) // conditional expression is constant + +// MSVC 2013 workarounds +#if _MSC_VER <= 1800 +// noexcept is not understood +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +namespace gsl +{ +// +// GSL.util: utilities +// + +// final_act allows you to ensure something gets run at the end of a scope +template <class F> +class final_act +{ +public: + explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {} + + final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_) + { + other.invoke_ = false; + } + + final_act(const final_act&) = delete; + final_act& operator=(const final_act&) = delete; + + ~final_act() noexcept + { + if (invoke_) f_(); + } + +private: + F f_; + bool invoke_; +}; + +// finally() - convenience function to generate a final_act +template <class F> +inline final_act<F> finally(const F& f) noexcept +{ + return final_act<F>(f); +} + +template <class F> +inline final_act<F> finally(F&& f) noexcept +{ + return final_act<F>(std::forward<F>(f)); +} + +// narrow_cast(): a searchable way to do narrowing casts of values +#if _MSC_VER <= 1800 +template <class T, class U> +inline constexpr T narrow_cast(U u) noexcept +{ + return static_cast<T>(u); +} +#else +template <class T, class U> +inline constexpr T narrow_cast(U&& u) noexcept +{ + return static_cast<T>(std::forward<U>(u)); +} +#endif + +struct narrowing_error : public std::exception +{ +}; + +namespace details +{ + template <class T, class U> + struct is_same_signedness + : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value> + { + }; +} + +// narrow() : a checked version of narrow_cast() that throws if the cast changed the value +template <class T, class U> +inline T narrow(U u) +{ + T t = narrow_cast<T>(u); + if (static_cast<U>(t) != u) throw narrowing_error(); + if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{}))) + throw narrowing_error(); + return t; +} + +// +// at() - Bounds-checked way of accessing static arrays, std::array, std::vector +// +template <class T, size_t N> +constexpr T& at(T (&arr)[N], size_t index) +{ + Expects(index < N); + return arr[index]; +} + +template <class T, size_t N> +constexpr T& at(std::array<T, N>& arr, size_t index) +{ + Expects(index < N); + return arr[index]; +} + +template <class Cont> +constexpr typename Cont::value_type& at(Cont& cont, size_t index) +{ + Expects(index < cont.size()); + return cont[index]; +} + +template <class T> +constexpr const T& at(std::initializer_list<T> cont, size_t index) +{ + Expects(index < cont.size()); + return *(cont.begin() + index); +} + +} // namespace gsl + +#ifdef _MSC_VER + +#pragma warning(pop) + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 + +#undef noexcept +#pragma pop_macro("noexcept") + +#pragma warning(pop) + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#endif // GSL_UTIL_H diff --git a/gsl/multi_span b/gsl/multi_span new file mode 100644 index 0000000..2186c7b --- /dev/null +++ b/gsl/multi_span @@ -0,0 +1,2231 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_MULTI_SPAN_H +#define GSL_MULTI_SPAN_H + +#include "gsl_assert" +#include "gsl_byte" +#include "gsl_util" +#include <algorithm> +#include <array> +#include <cassert> +#include <cstddef> +#include <cstdint> +#include <functional> +#include <iterator> +#include <limits> +#include <new> +#include <numeric> +#include <stdexcept> +#include <type_traits> +#include <utility> + +#ifdef _MSC_VER + +// turn off some warnings that are noisy about our Expects statements +#pragma warning(push) +#pragma warning(disable : 4127) // conditional expression is constant + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + +// noexcept is not understood +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ +#endif + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4512) // warns that assignment op could not be generated + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma push_macro("noexcept") +#endif + +#define noexcept /*noexcept*/ + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +namespace gsl +{ + +/* +** begin definitions of index and bounds +*/ +namespace details +{ + template <typename SizeType> + struct SizeTypeTraits + { + static const SizeType max_value = std::numeric_limits<SizeType>::max(); + }; + + template <typename... Ts> + class are_integral : public std::integral_constant<bool, true> + { + }; + + template <typename T, typename... Ts> + class are_integral<T, Ts...> + : public std::integral_constant<bool, + std::is_integral<T>::value && are_integral<Ts...>::value> + { + }; +} + +template <size_t Rank> +class index final +{ + static_assert(Rank > 0, "Rank must be greater than 0!"); + + template <size_t OtherRank> + friend class index; + +public: + static const size_t rank = Rank; + using value_type = std::ptrdiff_t; + using size_type = value_type; + using reference = std::add_lvalue_reference_t<value_type>; + using const_reference = std::add_lvalue_reference_t<std::add_const_t<value_type>>; + + constexpr index() noexcept {} + + constexpr index(const value_type (&values)[Rank]) noexcept + { + std::copy(values, values + Rank, elems); + } + +#ifdef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + template < + typename T, typename... Ts, + typename = std::enable_if_t<((sizeof...(Ts) + 1) == Rank) && std::is_integral<T>::value && + details::are_integral<Ts...>::value>> + constexpr index(T t, Ts... ds) + : index({narrow_cast<value_type>(t), narrow_cast<value_type>(ds)...}) + { + } +#else + template <typename... Ts, typename = std::enable_if_t<(sizeof...(Ts) == Rank) && + details::are_integral<Ts...>::value>> + constexpr index(Ts... ds) noexcept : elems{narrow_cast<value_type>(ds)...} + { + } +#endif + + constexpr index(const index& other) noexcept = default; + + constexpr index& operator=(const index& rhs) noexcept = default; + + // Preconditions: component_idx < rank + constexpr reference operator[](size_t component_idx) + { + Expects(component_idx < Rank); // Component index must be less than rank + return elems[component_idx]; + } + + // Preconditions: component_idx < rank + constexpr const_reference operator[](size_t component_idx) const noexcept + { + Expects(component_idx < Rank); // Component index must be less than rank + return elems[component_idx]; + } + + constexpr bool operator==(const index& rhs) const noexcept + { + return std::equal(elems, elems + rank, rhs.elems); + } + + constexpr bool operator!=(const index& rhs) const noexcept { return !(this == rhs); } + + constexpr index operator+() const noexcept { return *this; } + + constexpr index operator-() const noexcept + { + index ret = *this; + std::transform(ret, ret + rank, ret, std::negate<value_type>{}); + return ret; + } + + constexpr index operator+(const index& rhs) const noexcept + { + index ret = *this; + ret += rhs; + return ret; + } + + constexpr index operator-(const index& rhs) const noexcept + { + index ret = *this; + ret -= rhs; + return ret; + } + + constexpr index& operator+=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{}); + return *this; + } + + constexpr index& operator-=(const index& rhs) noexcept + { + std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{}); + return *this; + } + + constexpr index operator*(value_type v) const noexcept + { + index ret = *this; + ret *= v; + return ret; + } + + constexpr index operator/(value_type v) const noexcept + { + index ret = *this; + ret /= v; + return ret; + } + + friend constexpr index operator*(value_type v, const index& rhs) noexcept { return rhs * v; } + + constexpr index& operator*=(value_type v) noexcept + { + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::multiplies<value_type>{}(x, v); }); + return *this; + } + + constexpr index& operator/=(value_type v) noexcept + { + std::transform(elems, elems + rank, elems, + [v](value_type x) { return std::divides<value_type>{}(x, v); }); + return *this; + } + +private: + value_type elems[Rank] = {}; +}; + +#ifndef _MSC_VER + +struct static_bounds_dynamic_range_t +{ + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr operator T() const noexcept + { + return narrow_cast<T>(-1); + } + + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr bool operator==(T other) const noexcept + { + return narrow_cast<T>(-1) == other; + } + + template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> + constexpr bool operator!=(T other) const noexcept + { + return narrow_cast<T>(-1) != other; + } +}; + +template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> +constexpr bool operator==(T left, static_bounds_dynamic_range_t right) noexcept +{ + return right == left; +} + +template <typename T, typename Dummy = std::enable_if_t<std::is_integral<T>::value>> +constexpr bool operator!=(T left, static_bounds_dynamic_range_t right) noexcept +{ + return right != left; +} + +constexpr static_bounds_dynamic_range_t dynamic_range{}; +#else +const std::ptrdiff_t dynamic_range = -1; +#endif + +struct generalized_mapping_tag +{ +}; +struct contiguous_mapping_tag : generalized_mapping_tag +{ +}; + +namespace details +{ + + template <std::ptrdiff_t Left, std::ptrdiff_t Right> + struct LessThan + { + static const bool value = Left < Right; + }; + + template <std::ptrdiff_t... Ranges> + struct BoundsRanges + { + using size_type = std::ptrdiff_t; + static const size_type Depth = 0; + static const size_type DynamicNum = 0; + static const size_type CurrentRange = 1; + static const size_type TotalSize = 1; + + // TODO : following signature is for work around VS bug + template <typename OtherRange> + BoundsRanges(const OtherRange&, bool /* firstLevel */) + { + } + + BoundsRanges(const std::ptrdiff_t* const) {} + BoundsRanges() = default; + + template <typename T, size_t Dim> + void serialize(T&) const + { + } + + template <typename T, size_t Dim> + size_type linearize(const T&) const + { + return 0; + } + + template <typename T, size_t Dim> + size_type contains(const T&) const + { + return -1; + } + + size_type elementNum(size_t) const noexcept { return 0; } + + size_type totalSize() const noexcept { return TotalSize; } + + bool operator==(const BoundsRanges&) const noexcept { return true; } + }; + + template <std::ptrdiff_t... RestRanges> + struct BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...> + { + using Base = BoundsRanges<RestRanges...>; + using size_type = std::ptrdiff_t; + static const size_t Depth = Base::Depth + 1; + static const size_t DynamicNum = Base::DynamicNum + 1; + static const size_type CurrentRange = dynamic_range; + static const size_type TotalSize = dynamic_range; + private: + size_type m_bound; + public: + + BoundsRanges(const std::ptrdiff_t* const arr) + : Base(arr + 1), m_bound(*arr * this->Base::totalSize()) + { + Expects(0 <= *arr); + } + + BoundsRanges() : m_bound(0) {} + + template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> + BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, + bool /* firstLevel */ = true) + : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) + , m_bound(other.totalSize()) + { + } + + template <typename T, size_t Dim = 0> + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type linearize(const T& arr) const + { + const size_type index = this->Base::totalSize() * arr[Dim]; + Expects(index < m_bound); + return index + this->Base::template linearize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type contains(const T& arr) const + { + const ptrdiff_t last = this->Base::template contains<T, Dim + 1>(arr); + if (last == -1) return -1; + const ptrdiff_t cur = this->Base::totalSize() * arr[Dim]; + return cur < m_bound ? cur + last : -1; + } + + size_type totalSize() const noexcept { return m_bound; } + + size_type elementNum() const noexcept { return totalSize() / this->Base::totalSize(); } + + size_type elementNum(size_t dim) const noexcept + { + if (dim > 0) + return this->Base::elementNum(dim - 1); + else + return elementNum(); + } + + bool operator==(const BoundsRanges& rhs) const noexcept + { + return m_bound == rhs.m_bound && + static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + } + }; + + template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges> + struct BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...> + { + using Base = BoundsRanges<RestRanges...>; + using size_type = std::ptrdiff_t; + static const size_t Depth = Base::Depth + 1; + static const size_t DynamicNum = Base::DynamicNum; + static const size_type CurrentRange = CurRange; + static const size_type TotalSize = + Base::TotalSize == dynamic_range ? dynamic_range : CurrentRange * Base::TotalSize; + + BoundsRanges(const std::ptrdiff_t* const arr) : Base(arr) {} + BoundsRanges() = default; + + template <std::ptrdiff_t OtherRange, std::ptrdiff_t... RestOtherRanges> + BoundsRanges(const BoundsRanges<OtherRange, RestOtherRanges...>& other, + bool firstLevel = true) + : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false) + { + (void) firstLevel; + } + + template <typename T, size_t Dim = 0> + void serialize(T& arr) const + { + arr[Dim] = elementNum(); + this->Base::template serialize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type linearize(const T& arr) const + { + Expects(arr[Dim] >= 0 && arr[Dim] < CurrentRange); // Index is out of range + return this->Base::totalSize() * arr[Dim] + + this->Base::template linearize<T, Dim + 1>(arr); + } + + template <typename T, size_t Dim = 0> + size_type contains(const T& arr) const + { + if (arr[Dim] >= CurrentRange) return -1; + const size_type last = this->Base::template contains<T, Dim + 1>(arr); + if (last == -1) return -1; + return this->Base::totalSize() * arr[Dim] + last; + } + + size_type totalSize() const noexcept { return CurrentRange * this->Base::totalSize(); } + + size_type elementNum() const noexcept { return CurrentRange; } + + size_type elementNum(size_t dim) const noexcept + { + if (dim > 0) + return this->Base::elementNum(dim - 1); + else + return elementNum(); + } + + bool operator==(const BoundsRanges& rhs) const noexcept + { + return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs); + } + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible + : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize || + TargetType::TotalSize == dynamic_range || + SourceType::TotalSize == dynamic_range || + TargetType::TotalSize == 0)> + { + }; + + template <typename TypeChain> + struct TypeListIndexer + { + const TypeChain& obj_; + TypeListIndexer(const TypeChain& obj) : obj_(obj) {} + + template <size_t N> + const TypeChain& getObj(std::true_type) + { + return obj_; + } + + template <size_t N, typename MyChain = TypeChain, typename MyBase = typename MyChain::Base> + auto getObj(std::false_type) + -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>()) + { + return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>(); + } + + template <size_t N> + auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>())) + { + return getObj<N - 1>(std::integral_constant<bool, N == 0>()); + } + }; + + template <typename TypeChain> + TypeListIndexer<TypeChain> createTypeListIndexer(const TypeChain& obj) + { + return TypeListIndexer<TypeChain>(obj); + } + + template <size_t Rank, bool Enabled = (Rank > 1), + typename Ret = std::enable_if_t<Enabled, index<Rank - 1>>> + constexpr Ret shift_left(const index<Rank>& other) noexcept + { + Ret ret{}; + for (size_t i = 0; i < Rank - 1; ++i) { + ret[i] = other[i + 1]; + } + return ret; + } +} + +template <typename IndexType> +class bounds_iterator; + +template <std::ptrdiff_t... Ranges> +class static_bounds +{ +public: + static_bounds(const details::BoundsRanges<Ranges...>&) {} +}; + +template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges> +class static_bounds<FirstRange, RestRanges...> +{ + using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>; + + MyRanges m_ranges; + constexpr static_bounds(const MyRanges& range) : m_ranges(range) {} + + template <std::ptrdiff_t... OtherRanges> + friend class static_bounds; + +public: + static const size_t rank = MyRanges::Depth; + static const size_t dynamic_rank = MyRanges::DynamicNum; + static const std::ptrdiff_t static_size = MyRanges::TotalSize; + + using size_type = std::ptrdiff_t; + using index_type = index<rank>; + using const_index_type = std::add_const_t<index_type>; + using iterator = bounds_iterator<const_index_type>; + using const_iterator = bounds_iterator<const_index_type>; + using difference_type = std::ptrdiff_t; + using sliced_type = static_bounds<RestRanges...>; + using mapping_type = contiguous_mapping_tag; + + constexpr static_bounds(const static_bounds&) = default; + + template <typename SourceType, typename TargetType, size_t Rank> + struct BoundsRangeConvertible2; + + template <size_t Rank, typename SourceType, typename TargetType, + typename Ret = BoundsRangeConvertible2<typename SourceType::Base, + typename TargetType::Base, Rank>> + static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret; + + template <size_t Rank, typename SourceType, typename TargetType> + static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type; + + template <typename SourceType, typename TargetType, size_t Rank> + struct BoundsRangeConvertible2 + : decltype(helpBoundsRangeConvertible<Rank - 1>( + SourceType(), TargetType(), + std::integral_constant<bool, + SourceType::Depth == TargetType::Depth && + (SourceType::CurrentRange == TargetType::CurrentRange || + TargetType::CurrentRange == dynamic_range || + SourceType::CurrentRange == dynamic_range)>())) + { + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible2<SourceType, TargetType, 0> : std::true_type + { + }; + + template <typename SourceType, typename TargetType, std::ptrdiff_t Rank = TargetType::Depth> + struct BoundsRangeConvertible + : decltype(helpBoundsRangeConvertible<Rank - 1>( + SourceType(), TargetType(), + std::integral_constant<bool, + SourceType::Depth == TargetType::Depth && + (!details::LessThan<SourceType::CurrentRange, + TargetType::CurrentRange>::value || + TargetType::CurrentRange == dynamic_range || + SourceType::CurrentRange == dynamic_range)>())) + { + }; + + template <typename SourceType, typename TargetType> + struct BoundsRangeConvertible<SourceType, TargetType, 0> : std::true_type + { + }; + + template <std::ptrdiff_t... Ranges, + typename = std::enable_if_t<details::BoundsRangeConvertible< + details::BoundsRanges<Ranges...>, + details::BoundsRanges<FirstRange, RestRanges...>>::value>> + constexpr static_bounds(const static_bounds<Ranges...>& other) : m_ranges(other.m_ranges) + { + Expects((MyRanges::DynamicNum == 0 && details::BoundsRanges<Ranges...>::DynamicNum == 0) || + MyRanges::DynamicNum > 0 || other.m_ranges.totalSize() >= m_ranges.totalSize()); + } + + constexpr static_bounds(std::initializer_list<size_type> il) + : m_ranges(static_cast<const std::ptrdiff_t*>(il.begin())) + { + // Size of the initializer list must match the rank of the array + Expects((MyRanges::DynamicNum == 0 && il.size() == 1 && *il.begin() == static_size) || + MyRanges::DynamicNum == il.size()); + // Size of the range must be less than the max element of the size type + Expects(m_ranges.totalSize() <= PTRDIFF_MAX); + } + + constexpr static_bounds() = default; + + constexpr sliced_type slice() const noexcept + { + return sliced_type{static_cast<const details::BoundsRanges<RestRanges...>&>(m_ranges)}; + } + + constexpr size_type stride() const noexcept { return rank > 1 ? slice().size() : 1; } + + constexpr size_type size() const noexcept { return m_ranges.totalSize(); } + + constexpr size_type total_size() const noexcept { return m_ranges.totalSize(); } + + constexpr size_type linearize(const index_type& idx) const { return m_ranges.linearize(idx); } + + constexpr bool contains(const index_type& idx) const noexcept + { + return m_ranges.contains(idx) != -1; + } + + constexpr size_type operator[](size_t index) const noexcept + { + return m_ranges.elementNum(index); + } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < rank, + "dimension should be less than rank (dimension count starts from 0)"); + return details::createTypeListIndexer(m_ranges).template get<Dim>().elementNum(); + } + + template <typename IntType> + constexpr size_type extent(IntType dim) const noexcept + { + static_assert(std::is_integral<IntType>::value, + "Dimension parameter must be supplied as an integral type."); + auto real_dim = narrow_cast<size_t>(dim); + Expects(real_dim < rank); + + return m_ranges.elementNum(real_dim); + } + + constexpr index_type index_bounds() const noexcept + { + size_type extents[rank] = {}; + m_ranges.serialize(extents); + return {extents}; + } + + template <std::ptrdiff_t... Ranges> + constexpr bool operator==(const static_bounds<Ranges...>& rhs) const noexcept + { + return this->size() == rhs.size(); + } + + template <std::ptrdiff_t... Ranges> + constexpr bool operator!=(const static_bounds<Ranges...>& rhs) const noexcept + { + return !(*this == rhs); + } + + constexpr const_iterator begin() const noexcept { return const_iterator(*this, index_type{}); } + + constexpr const_iterator end() const noexcept + { + return const_iterator(*this, this->index_bounds()); + } +}; + +template <size_t Rank> +class strided_bounds +{ + template <size_t OtherRank> + friend class strided_bounds; + +public: + static const size_t rank = Rank; + using value_type = std::ptrdiff_t; + using reference = std::add_lvalue_reference_t<value_type>; + using const_reference = std::add_const_t<reference>; + using size_type = value_type; + using difference_type = value_type; + using index_type = index<rank>; + using const_index_type = std::add_const_t<index_type>; + using iterator = bounds_iterator<const_index_type>; + using const_iterator = bounds_iterator<const_index_type>; + static const value_type dynamic_rank = rank; + static const value_type static_size = dynamic_range; + using sliced_type = std::conditional_t<rank != 0, strided_bounds<rank - 1>, void>; + using mapping_type = generalized_mapping_tag; + + constexpr strided_bounds(const strided_bounds&) noexcept = default; + + constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default; + + constexpr strided_bounds(const value_type (&values)[rank], index_type strides) + : m_extents(values), m_strides(std::move(strides)) + { + } + + constexpr strided_bounds(const index_type& extents, const index_type& strides) noexcept + : m_extents(extents), + m_strides(strides) + { + } + + constexpr index_type strides() const noexcept { return m_strides; } + + constexpr size_type total_size() const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; ++i) { + ret += (m_extents[i] - 1) * m_strides[i]; + } + return ret + 1; + } + + constexpr size_type size() const noexcept + { + size_type ret = 1; + for (size_t i = 0; i < rank; ++i) { + ret *= m_extents[i]; + } + return ret; + } + + constexpr bool contains(const index_type& idx) const noexcept + { + for (size_t i = 0; i < rank; ++i) { + if (idx[i] < 0 || idx[i] >= m_extents[i]) return false; + } + return true; + } + + constexpr size_type linearize(const index_type& idx) const noexcept + { + size_type ret = 0; + for (size_t i = 0; i < rank; i++) { + Expects(idx[i] < m_extents[i]); // index is out of bounds of the array + ret += idx[i] * m_strides[i]; + } + return ret; + } + + constexpr size_type stride() const noexcept { return m_strides[0]; } + + template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr sliced_type slice() const + { + return {details::shift_left(m_extents), details::shift_left(m_strides)}; + } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "dimension should be less than rank (dimension count starts from 0)"); + return m_extents[Dim]; + } + + constexpr index_type index_bounds() const noexcept { return m_extents; } + constexpr const_iterator begin() const noexcept { return const_iterator{*this, index_type{}}; } + + constexpr const_iterator end() const noexcept { return const_iterator{*this, index_bounds()}; } + +private: + index_type m_extents; + index_type m_strides; +}; + +template <typename T> +struct is_bounds : std::integral_constant<bool, false> +{ +}; +template <std::ptrdiff_t... Ranges> +struct is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true> +{ +}; +template <size_t Rank> +struct is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true> +{ +}; + +template <typename IndexType> +class bounds_iterator : public std::iterator<std::random_access_iterator_tag, IndexType> +{ +private: + using Base = std::iterator<std::random_access_iterator_tag, IndexType>; + +public: + static const size_t rank = IndexType::rank; + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; + using index_type = value_type; + using index_size_type = typename IndexType::value_type; + template <typename Bounds> + explicit bounds_iterator(const Bounds& bnd, value_type curr) noexcept + : boundary_(bnd.index_bounds()), + curr_(std::move(curr)) + { + static_assert(is_bounds<Bounds>::value, "Bounds type must be provided"); + } + + constexpr reference operator*() const noexcept { return curr_; } + + constexpr pointer operator->() const noexcept { return &curr_; } + + constexpr bounds_iterator& operator++() noexcept + { + for (size_t i = rank; i-- > 0;) { + if (curr_[i] < boundary_[i] - 1) { + curr_[i]++; + return *this; + } + curr_[i] = 0; + } + // If we're here we've wrapped over - set to past-the-end. + curr_ = boundary_; + return *this; + } + + constexpr bounds_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + + constexpr bounds_iterator& operator--() noexcept + { + if (!less(curr_, boundary_)) { + // if at the past-the-end, set to last element + for (size_t i = 0; i < rank; ++i) { + curr_[i] = boundary_[i] - 1; + } + return *this; + } + for (size_t i = rank; i-- > 0;) { + if (curr_[i] >= 1) { + curr_[i]--; + return *this; + } + curr_[i] = boundary_[i] - 1; + } + // If we're here the preconditions were violated + // "pre: there exists s such that r == ++s" + Expects(false); + return *this; + } + + constexpr bounds_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + + constexpr bounds_iterator operator+(difference_type n) const noexcept + { + bounds_iterator ret{*this}; + return ret += n; + } + + constexpr bounds_iterator& operator+=(difference_type n) noexcept + { + auto linear_idx = linearize(curr_) + n; + std::remove_const_t<value_type> stride = 0; + stride[rank - 1] = 1; + for (size_t i = rank - 1; i-- > 0;) { + stride[i] = stride[i + 1] * boundary_[i + 1]; + } + for (size_t i = 0; i < rank; ++i) { + curr_[i] = linear_idx / stride[i]; + linear_idx = linear_idx % stride[i]; + } + // index is out of bounds of the array + Expects(!less(curr_, index_type{}) && !less(boundary_, curr_)); + return *this; + } + + constexpr bounds_iterator operator-(difference_type n) const noexcept + { + bounds_iterator ret{*this}; + return ret -= n; + } + + constexpr bounds_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + + constexpr difference_type operator-(const bounds_iterator& rhs) const noexcept + { + return linearize(curr_) - linearize(rhs.curr_); + } + + constexpr value_type operator[](difference_type n) const noexcept { return *(*this + n); } + + constexpr bool operator==(const bounds_iterator& rhs) const noexcept + { + return curr_ == rhs.curr_; + } + + constexpr bool operator!=(const bounds_iterator& rhs) const noexcept { return !(*this == rhs); } + + constexpr bool operator<(const bounds_iterator& rhs) const noexcept + { + return less(curr_, rhs.curr_); + } + + constexpr bool operator<=(const bounds_iterator& rhs) const noexcept { return !(rhs < *this); } + + constexpr bool operator>(const bounds_iterator& rhs) const noexcept { return rhs < *this; } + + constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); } + + void swap(bounds_iterator& rhs) noexcept + { + std::swap(boundary_, rhs.boundary_); + std::swap(curr_, rhs.curr_); + } + +private: + constexpr bool less(index_type& one, index_type& other) const noexcept + { + for (size_t i = 0; i < rank; ++i) { + if (one[i] < other[i]) return true; + } + return false; + } + + constexpr index_size_type linearize(const value_type& idx) const noexcept + { + // TODO: Smarter impl. + // Check if past-the-end + index_size_type multiplier = 1; + index_size_type res = 0; + if (!less(idx, boundary_)) { + res = 1; + for (size_t i = rank; i-- > 0;) { + res += (idx[i] - 1) * multiplier; + multiplier *= boundary_[i]; + } + } + else + { + for (size_t i = rank; i-- > 0;) { + res += idx[i] * multiplier; + multiplier *= boundary_[i]; + } + } + return res; + } + + value_type boundary_; + std::remove_const_t<value_type> curr_; +}; + +template <typename IndexType> +bounds_iterator<IndexType> operator+(typename bounds_iterator<IndexType>::difference_type n, + const bounds_iterator<IndexType>& rhs) noexcept +{ + return rhs + n; +} + +namespace details +{ + template <typename Bounds> + constexpr std::enable_if_t< + std::is_same<typename Bounds::mapping_type, generalized_mapping_tag>::value, + typename Bounds::index_type> + make_stride(const Bounds& bnd) noexcept + { + return bnd.strides(); + } + + // Make a stride vector from bounds, assuming contiguous memory. + template <typename Bounds> + constexpr std::enable_if_t< + std::is_same<typename Bounds::mapping_type, contiguous_mapping_tag>::value, + typename Bounds::index_type> + make_stride(const Bounds& bnd) noexcept + { + auto extents = bnd.index_bounds(); + typename Bounds::size_type stride[Bounds::rank] = {}; + + stride[Bounds::rank - 1] = 1; + for (size_t i = 1; i < Bounds::rank; ++i) { + stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i]; + } + return {stride}; + } + + template <typename BoundsSrc, typename BoundsDest> + void verifyBoundsReshape(const BoundsSrc& src, const BoundsDest& dest) + { + static_assert(is_bounds<BoundsSrc>::value && is_bounds<BoundsDest>::value, + "The src type and dest type must be bounds"); + static_assert(std::is_same<typename BoundsSrc::mapping_type, contiguous_mapping_tag>::value, + "The source type must be a contiguous bounds"); + static_assert(BoundsDest::static_size == dynamic_range || + BoundsSrc::static_size == dynamic_range || + BoundsDest::static_size == BoundsSrc::static_size, + "The source bounds must have same size as dest bounds"); + Expects(src.size() == dest.size()); + } + +} // namespace details + +template <typename Span> +class contiguous_span_iterator; +template <typename Span> +class general_span_iterator; + +template <std::ptrdiff_t DimSize = dynamic_range> +struct dim_t +{ + static const std::ptrdiff_t value = DimSize; +}; +template <> +struct dim_t<dynamic_range> +{ + static const std::ptrdiff_t value = dynamic_range; + const std::ptrdiff_t dvalue; + dim_t(std::ptrdiff_t size) : dvalue(size) {} +}; + +template <std::ptrdiff_t N> +constexpr std::enable_if_t<(N >= 0), dim_t<N>> dim() noexcept +{ + return dim_t<N>(); +} + +template <std::ptrdiff_t N = dynamic_range> +constexpr std::enable_if_t<N == dynamic_range, dim_t<N>> dim(std::ptrdiff_t n) noexcept +{ + return dim_t<>(n); +} + +template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range, + std::ptrdiff_t... RestDimensions> +class multi_span; + +template <typename ValueType, size_t Rank> +class strided_span; + +namespace details +{ + template <typename T, typename = std::true_type> + struct SpanTypeTraits + { + using value_type = T; + using size_type = size_t; + }; + + template <typename Traits> + struct SpanTypeTraits<Traits, typename std::is_reference<typename Traits::span_traits&>::type> + { + using value_type = typename Traits::span_traits::value_type; + using size_type = typename Traits::span_traits::size_type; + }; + + template <typename T, std::ptrdiff_t... Ranks> + struct SpanArrayTraits + { + using type = multi_span<T, Ranks...>; + using value_type = T; + using bounds_type = static_bounds<Ranks...>; + using pointer = T*; + using reference = T&; + }; + template <typename T, std::ptrdiff_t N, std::ptrdiff_t... Ranks> + struct SpanArrayTraits<T[N], Ranks...> : SpanArrayTraits<T, Ranks..., N> + { + }; + + template <typename BoundsType> + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::true_type) // dynamic size + { + Expects(totalSize >= 0 && totalSize <= PTRDIFF_MAX); + return BoundsType{totalSize}; + } + template <typename BoundsType> + BoundsType newBoundsHelperImpl(std::ptrdiff_t totalSize, std::false_type) // static size + { + Expects(BoundsType::static_size <= totalSize); + return {}; + } + template <typename BoundsType> + BoundsType newBoundsHelper(std::ptrdiff_t totalSize) + { + static_assert(BoundsType::dynamic_rank <= 1, "dynamic rank must less or equal to 1"); + return newBoundsHelperImpl<BoundsType>( + totalSize, std::integral_constant<bool, BoundsType::dynamic_rank == 1>()); + } + + struct Sep + { + }; + + template <typename T, typename... Args> + T static_as_multi_span_helper(Sep, Args... args) + { + return T{narrow_cast<typename T::size_type>(args)...}; + } + template <typename T, typename Arg, typename... Args> + std::enable_if_t< + !std::is_same<Arg, dim_t<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> + static_as_multi_span_helper(Arg, Args... args) + { + return static_as_multi_span_helper<T>(args...); + } + template <typename T, typename... Args> + T static_as_multi_span_helper(dim_t<dynamic_range> val, Args... args) + { + return static_as_multi_span_helper<T>(args..., val.dvalue); + } + + template <typename... Dimensions> + struct static_as_multi_span_static_bounds_helper + { + using type = static_bounds<(Dimensions::value)...>; + }; + + template <typename T> + struct is_multi_span_oracle : std::false_type + { + }; + + template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> + struct is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>> + : std::true_type + { + }; + + template <typename ValueType, std::ptrdiff_t Rank> + struct is_multi_span_oracle<strided_span<ValueType, Rank>> : std::true_type + { + }; + + template <typename T> + struct is_multi_span : is_multi_span_oracle<std::remove_cv_t<T>> + { + }; +} + +template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> +class multi_span +{ + // TODO do we still need this? + template <typename ValueType2, std::ptrdiff_t FirstDimension2, + std::ptrdiff_t... RestDimensions2> + friend class multi_span; + +public: + using bounds_type = static_bounds<FirstDimension, RestDimensions...>; + static const size_t Rank = bounds_type::rank; + using size_type = typename bounds_type::size_type; + using index_type = typename bounds_type::index_type; + using value_type = ValueType; + using const_value_type = std::add_const_t<value_type>; + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + using iterator = contiguous_span_iterator<multi_span>; + using const_span = multi_span<const_value_type, FirstDimension, RestDimensions...>; + using const_iterator = contiguous_span_iterator<const_span>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + using sliced_type = + std::conditional_t<Rank == 1, value_type, multi_span<value_type, RestDimensions...>>; + +private: + pointer data_; + bounds_type bounds_; + + friend iterator; + friend const_iterator; + +public: + // default constructor - same as constructing from nullptr_t + constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "Default construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + } + + // construct from nullptr - get an empty multi_span + constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "nullptr_t construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + } + + // construct from nullptr with size of 0 (helps with template function calls) + template <class IntType, typename = std::enable_if_t<std::is_integral<IntType>::value>> + constexpr multi_span(std::nullptr_t, IntType size) noexcept : multi_span(nullptr, bounds_type{}) + { + static_assert(bounds_type::dynamic_rank != 0 || + (bounds_type::dynamic_rank == 0 && bounds_type::static_size == 0), + "nullptr_t construction of multi_span<T> only possible " + "for dynamic or fixed, zero-length spans."); + Expects(size == 0); + } + + // construct from a single element + constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1}) + { + static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 || + bounds_type::static_size == 1, + "Construction from a single element only possible " + "for dynamic or fixed spans of length 0 or 1."); + } + + // prevent constructing from temporaries for single-elements + constexpr multi_span(value_type&&) = delete; + + // construct from pointer + length + constexpr multi_span(pointer ptr, size_type size) noexcept : multi_span(ptr, bounds_type{size}) + { + } + + // construct from pointer + length - multidimensional + constexpr multi_span(pointer data, bounds_type bounds) noexcept : data_(data), + bounds_(std::move(bounds)) + { + Expects((bounds_.size() > 0 && data != nullptr) || bounds_.size() == 0); + } + + // construct from begin,end pointer pair + template <typename Ptr, + typename = std::enable_if_t<std::is_convertible<Ptr, pointer>::value && + details::LessThan<bounds_type::dynamic_rank, 2>::value>> + constexpr multi_span(pointer begin, Ptr end) + : multi_span(begin, + details::newBoundsHelper<bounds_type>(static_cast<pointer>(end) - begin)) + { + Expects(begin != nullptr && end != nullptr && begin <= static_cast<pointer>(end)); + } + + // construct from n-dimensions static array + template <typename T, size_t N, typename Helper = details::SpanArrayTraits<T, N>> + constexpr multi_span(T (&arr)[N]) + : multi_span(reinterpret_cast<pointer>(arr), bounds_type{typename Helper::bounds_type{}}) + { + static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<typename Helper::bounds_type, bounds_type>::value, + "Cannot construct a multi_span from an array with fewer elements."); + } + + // construct from n-dimensions dynamic array (e.g. new int[m][4]) + // (precedence will be lower than the 1-dimension pointer) + template <typename T, typename Helper = details::SpanArrayTraits<T, dynamic_range>> + constexpr multi_span(T* const& data, size_type size) + : multi_span(reinterpret_cast<pointer>(data), typename Helper::bounds_type{size}) + { + static_assert(std::is_convertible<typename Helper::value_type(*)[], value_type(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + } + + // construct from std::array + template <typename T, size_t N> + constexpr multi_span(std::array<T, N>& arr) + : multi_span(arr.data(), bounds_type{static_bounds<N>{}}) + { + static_assert( + std::is_convertible<T(*)[], typename std::remove_const_t<value_type>(*)[]>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, + "You cannot construct a multi_span from a std::array of smaller size."); + } + + // construct from const std::array + template <typename T, size_t N> + constexpr multi_span(const std::array<std::remove_const_t<value_type>, N>& arr) + : multi_span(arr.data(), static_bounds<N>()) + { + static_assert(std::is_convertible<T(*)[], std::remove_const_t<value_type>>::value, + "Cannot convert from source type to target multi_span type."); + static_assert(std::is_convertible<static_bounds<N>, bounds_type>::value, + "You cannot construct a multi_span from a std::array of smaller size."); + } + + // prevent constructing from temporary std::array + template <typename T, size_t N> + constexpr multi_span(std::array<T, N>&& arr) = delete; + + // construct from containers + // future: could use contiguous_iterator_traits to identify only contiguous containers + // type-requirements: container must have .size(), operator[] which are value_type compatible + template <typename Cont, typename DataType = typename Cont::value_type, + typename = std::enable_if_t< + !details::is_multi_span<Cont>::value && + std::is_convertible<DataType (*)[], value_type (*)[]>::value && + std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), + *std::declval<Cont>().data())>, + DataType>::value>> + constexpr multi_span(Cont& cont) + : multi_span(static_cast<pointer>(cont.data()), + details::newBoundsHelper<bounds_type>(narrow_cast<size_type>(cont.size()))) + { + } + + // prevent constructing from temporary containers + template <typename Cont, typename DataType = typename Cont::value_type, + typename = std::enable_if_t< + !details::is_multi_span<Cont>::value && + std::is_convertible<DataType (*)[], value_type (*)[]>::value && + std::is_same<std::decay_t<decltype(std::declval<Cont>().size(), + *std::declval<Cont>().data())>, + DataType>::value>> + explicit constexpr multi_span(Cont&& cont) = delete; + + // construct from a convertible multi_span + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename OtherBounds = static_bounds<OtherDimensions...>, + typename = std::enable_if_t<std::is_convertible<OtherValueType, ValueType>::value && + std::is_convertible<OtherBounds, bounds_type>::value>> + constexpr multi_span(multi_span<OtherValueType, OtherDimensions...> other) noexcept + : data_(other.data_), + bounds_(other.bounds_) + { + } + +// trivial copy and move +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr multi_span(multi_span&&) = default; +#endif + constexpr multi_span(const multi_span&) = default; + +// trivial assignment +#ifndef GSL_MSVC_NO_SUPPORT_FOR_MOVE_CTOR_DEFAULT + constexpr multi_span& operator=(multi_span&&) = default; +#endif + constexpr multi_span& operator=(const multi_span&) = default; + + // first() - extract the first Count elements into a new multi_span + template <std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> first() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + Count <= bounds_type::static_size, + "Count is out of bounds."); + + Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); + return {this->data(), Count}; + } + + // first() - extract the first count elements into a new multi_span + constexpr multi_span<ValueType, dynamic_range> first(size_type count) const noexcept + { + Expects(count >= 0 && count <= this->size()); + return {this->data(), count}; + } + + // last() - extract the last Count elements into a new multi_span + template <std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> last() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + Count <= bounds_type::static_size, + "Count is out of bounds."); + + Expects(bounds_type::static_size != dynamic_range || Count <= this->size()); + return {this->data() + this->size() - Count, Count}; + } + + // last() - extract the last count elements into a new multi_span + constexpr multi_span<ValueType, dynamic_range> last(size_type count) const noexcept + { + Expects(count >= 0 && count <= this->size()); + return {this->data() + this->size() - count, count}; + } + + // subspan() - create a subview of Count elements starting at Offset + template <std::ptrdiff_t Offset, std::ptrdiff_t Count> + constexpr multi_span<ValueType, Count> subspan() const noexcept + { + static_assert(Count >= 0, "Count must be >= 0."); + static_assert(Offset >= 0, "Offset must be >= 0."); + static_assert(bounds_type::static_size == dynamic_range || + ((Offset <= bounds_type::static_size) && + Count <= bounds_type::static_size - Offset), + "You must describe a sub-range within bounds of the multi_span."); + + Expects(bounds_type::static_size != dynamic_range || + (Offset <= this->size() && Count <= this->size() - Offset)); + return {this->data() + Offset, Count}; + } + + // subspan() - create a subview of count elements starting at offset + // supplying dynamic_range for count will consume all available elements from offset + constexpr multi_span<ValueType, dynamic_range> subspan(size_type offset, + size_type count = dynamic_range) const + noexcept + { + Expects((offset >= 0 && offset <= this->size()) && + (count == dynamic_range || (count <= this->size() - offset))); + return {this->data() + offset, count == dynamic_range ? this->length() - offset : count}; + } + + // section - creates a non-contiguous, strided multi_span from a contiguous one + constexpr strided_span<ValueType, Rank> section(index_type origin, index_type extents) const + noexcept + { + size_type size = this->bounds().total_size() - this->bounds().linearize(origin); + return {&this->operator[](origin), size, + strided_bounds<Rank>{extents, details::make_stride(bounds())}}; + } + + // length of the multi_span in elements + constexpr size_type size() const noexcept { return bounds_.size(); } + + // length of the multi_span in elements + constexpr size_type length() const noexcept { return this->size(); } + + // length of the multi_span in bytes + constexpr size_type size_bytes() const noexcept { return sizeof(value_type) * this->size(); } + + // length of the multi_span in bytes + constexpr size_type length_bytes() const noexcept { return this->size_bytes(); } + + constexpr bool empty() const noexcept { return this->size() == 0; } + + static constexpr std::size_t rank() { return Rank; } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "Dimension should be less than rank (dimension count starts from 0)."); + return bounds_.template extent<Dim>(); + } + + template <typename IntType> + constexpr size_type extent(IntType dim) const noexcept + { + return bounds_.extent(dim); + } + + constexpr bounds_type bounds() const noexcept { return bounds_; } + + constexpr pointer data() const noexcept { return data_; } + + template <typename FirstIndex> + constexpr reference operator()(FirstIndex index) + { + return this->operator[](narrow_cast<std::ptrdiff_t>(index)); + } + + template <typename FirstIndex, typename... OtherIndices> + constexpr reference operator()(FirstIndex index, OtherIndices... indices) + { + index_type idx = {narrow_cast<std::ptrdiff_t>(index), + narrow_cast<std::ptrdiff_t>(indices...)}; + return this->operator[](idx); + } + + constexpr reference operator[](const index_type& idx) const noexcept + { + return data_[bounds_.linearize(idx)]; + } + + template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr Ret operator[](size_type idx) const noexcept + { + Expects(idx >= 0 && idx < bounds_.size()); // index is out of bounds of the array + const size_type ridx = idx * bounds_.stride(); + + // index is out of bounds of the underlying data + Expects(ridx < bounds_.total_size()); + return Ret{data_ + ridx, bounds_.slice()}; + } + + constexpr iterator begin() const noexcept { return iterator{this, true}; } + + constexpr iterator end() const noexcept { return iterator{this, false}; } + + constexpr const_iterator cbegin() const noexcept + { + return const_iterator{reinterpret_cast<const const_span*>(this), true}; + } + + constexpr const_iterator cend() const noexcept + { + return const_iterator{reinterpret_cast<const const_span*>(this), false}; + } + + constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } + + constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } + + constexpr const_reverse_iterator crbegin() const noexcept + { + return const_reverse_iterator{cend()}; + } + + constexpr const_reverse_iterator crend() const noexcept + { + return const_reverse_iterator{cbegin()}; + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator==(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator!=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(*this == other); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return (other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t... OtherDimensions, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>=(const multi_span<OtherValueType, OtherDimensions...>& other) const + noexcept + { + return !(*this < other); + } +}; + +// +// Free functions for manipulating spans +// + +// reshape a multi_span into a different dimensionality +// DimCount and Enabled here are workarounds for a bug in MSVC 2015 +template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), + bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>> +constexpr auto as_multi_span(SpanType s, Dimensions2... dims) + -> multi_span<typename SpanType::value_type, Dimensions2::value...> +{ + static_assert(details::is_multi_span<SpanType>::value, + "Variadic as_multi_span() is for reshaping existing spans."); + using BoundsType = + typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type; + auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{}); + details::verifyBoundsReshape(s.bounds(), tobounds); + return {s.data(), tobounds}; +} + +// convert a multi_span<T> to a multi_span<const byte> +template <typename U, std::ptrdiff_t... Dimensions> +multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) noexcept +{ + static_assert(std::is_trivial<std::decay_t<U>>::value, + "The value_type of multi_span must be a trivial type."); + return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; +} + +// convert a multi_span<T> to a multi_span<byte> (a writeable byte multi_span) +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept +{ + static_assert(std::is_trivial<std::decay_t<U>>::value, + "The value_type of multi_span must be a trivial type."); + return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; +} + +// convert a multi_span<const byte> to a multi_span<const T> +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span< + const U, static_cast<std::ptrdiff_t>( + multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range + ? (static_cast<size_t>( + multi_span<const byte, Dimensions...>::bounds_type::static_size) / + sizeof(U)) + : dynamic_range)> +{ + using ConstByteSpan = multi_span<const byte, Dimensions...>; + static_assert( + std::is_trivial<std::decay_t<U>>::value && + (ConstByteSpan::bounds_type::static_size == dynamic_range || + ConstByteSpan::bounds_type::static_size % narrow_cast<std::ptrdiff_t>(sizeof(U)) == 0), + "Target type must be a trivial type and its size must match the byte array size"); + + Expects((s.size_bytes() % sizeof(U)) == 0 && (s.size_bytes() / sizeof(U)) < PTRDIFF_MAX); + return {reinterpret_cast<const U*>(s.data()), + s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; +} + +// convert a multi_span<byte> to a multi_span<T> +// this is not currently a portable function that can be relied upon to work +// on all implementations. It should be considered an experimental extension +// to the standard GSL interface. +template <typename U, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) noexcept + -> multi_span<U, narrow_cast<std::ptrdiff_t>( + multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range + ? static_cast<std::size_t>( + multi_span<byte, Dimensions...>::bounds_type::static_size) / + sizeof(U) + : dynamic_range)> +{ + using ByteSpan = multi_span<byte, Dimensions...>; + static_assert( + std::is_trivial<std::decay_t<U>>::value && + (ByteSpan::bounds_type::static_size == dynamic_range || + ByteSpan::bounds_type::static_size % static_cast<std::size_t>(sizeof(U)) == 0), + "Target type must be a trivial type and its size must match the byte array size"); + + Expects((s.size_bytes() % sizeof(U)) == 0); + return {reinterpret_cast<U*>(s.data()), + s.size_bytes() / narrow_cast<std::ptrdiff_t>(sizeof(U))}; +} + +template <typename T, std::ptrdiff_t... Dimensions> +constexpr auto as_multi_span(T* const& ptr, dim_t<Dimensions>... args) + -> multi_span<std::remove_all_extents_t<T>, Dimensions...> +{ + return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), + details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args..., + details::Sep{})}; +} + +template <typename T> +constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) -> + typename details::SpanArrayTraits<T, dynamic_range>::type +{ + return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; +} + +template <typename T, size_t N> +constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type +{ + return {arr}; +} + +template <typename T, size_t N> +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr) +{ + return {arr}; +} + +template <typename T, size_t N> +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete; + +template <typename T, size_t N> +constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr) +{ + return {arr}; +} + +template <typename T> +constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end) +{ + return {begin, end}; +} + +template <typename Cont> +constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< + !details::is_multi_span<std::decay_t<Cont>>::value, + multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> +{ + Expects(arr.size() < PTRDIFF_MAX); + return {arr.data(), narrow_cast<std::ptrdiff_t>(arr.size())}; +} + +template <typename Cont> +constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t< + !details::is_multi_span<std::decay_t<Cont>>::value, + multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; + +// from basic_string which doesn't have nonconst .data() member like other contiguous containers +template <typename CharT, typename Traits, typename Allocator> +constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str) + -> multi_span<CharT, dynamic_range> +{ + Expects(str.size() < PTRDIFF_MAX); + return {&str[0], narrow_cast<std::ptrdiff_t>(str.size())}; +} + +// strided_span is an extension that is not strictly part of the GSL at this time. +// It is kept here while the multidimensional interface is still being defined. +template <typename ValueType, size_t Rank> +class strided_span +{ +public: + using bounds_type = strided_bounds<Rank>; + using size_type = typename bounds_type::size_type; + using index_type = typename bounds_type::index_type; + using value_type = ValueType; + using const_value_type = std::add_const_t<value_type>; + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + using iterator = general_span_iterator<strided_span>; + using const_strided_span = strided_span<const_value_type, Rank>; + using const_iterator = general_span_iterator<const_strided_span>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + using sliced_type = + std::conditional_t<Rank == 1, value_type, strided_span<value_type, Rank - 1>>; + +private: + pointer data_; + bounds_type bounds_; + + friend iterator; + friend const_iterator; + template <typename OtherValueType, size_t OtherRank> + friend class strided_span; + +public: + // from raw data + constexpr strided_span(pointer ptr, size_type size, bounds_type bounds) + : data_(ptr), bounds_(std::move(bounds)) + { + Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0); + // Bounds cross data boundaries + Expects(this->bounds().total_size() <= size); + (void) size; + } + + // from static array of size N + template <size_type N> + constexpr strided_span(value_type (&values)[N], bounds_type bounds) + : strided_span(values, N, std::move(bounds)) + { + } + + // from array view + template <typename OtherValueType, std::ptrdiff_t... Dimensions, + bool Enabled1 = (sizeof...(Dimensions) == Rank), + bool Enabled2 = std::is_convertible<OtherValueType*, ValueType*>::value, + typename Dummy = std::enable_if_t<Enabled1 && Enabled2>> + constexpr strided_span(multi_span<OtherValueType, Dimensions...> av, bounds_type bounds) + : strided_span(av.data(), av.bounds().total_size(), std::move(bounds)) + { + } + + // convertible + template <typename OtherValueType, typename Dummy = std::enable_if_t<std::is_convertible< + OtherValueType (*)[], value_type (*)[]>::value>> + constexpr strided_span(const strided_span<OtherValueType, Rank>& other) + : data_(other.data_), bounds_(other.bounds_) + { + } + + // convert from bytes + template <typename OtherValueType> + constexpr strided_span< + typename std::enable_if<std::is_same<value_type, const byte>::value, OtherValueType>::type, + Rank> + as_strided_span() const + { + static_assert((sizeof(OtherValueType) >= sizeof(value_type)) && + (sizeof(OtherValueType) % sizeof(value_type) == 0), + "OtherValueType should have a size to contain a multiple of ValueTypes"); + auto d = narrow_cast<size_type>(sizeof(OtherValueType) / sizeof(value_type)); + + size_type size = this->bounds().total_size() / d; + return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())), + size, bounds_type{resize_extent(this->bounds().index_bounds(), d), + resize_stride(this->bounds().strides(), d)}}; + } + + constexpr strided_span section(index_type origin, index_type extents) const + { + size_type size = this->bounds().total_size() - this->bounds().linearize(origin); + return {&this->operator[](origin), size, + bounds_type{extents, details::make_stride(bounds())}}; + } + + constexpr reference operator[](const index_type& idx) const + { + return data_[bounds_.linearize(idx)]; + } + + template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>> + constexpr Ret operator[](size_type idx) const + { + Expects(idx < bounds_.size()); // index is out of bounds of the array + const size_type ridx = idx * bounds_.stride(); + + // index is out of bounds of the underlying data + Expects(ridx < bounds_.total_size()); + return {data_ + ridx, bounds_.slice().total_size(), bounds_.slice()}; + } + + constexpr bounds_type bounds() const noexcept { return bounds_; } + + template <size_t Dim = 0> + constexpr size_type extent() const noexcept + { + static_assert(Dim < Rank, + "dimension should be less than Rank (dimension count starts from 0)"); + return bounds_.template extent<Dim>(); + } + + constexpr size_type size() const noexcept { return bounds_.size(); } + + constexpr pointer data() const noexcept { return data_; } + + constexpr explicit operator bool() const noexcept { return data_ != nullptr; } + + constexpr iterator begin() const { return iterator{this, true}; } + + constexpr iterator end() const { return iterator{this, false}; } + + constexpr const_iterator cbegin() const + { + return const_iterator{reinterpret_cast<const const_strided_span*>(this), true}; + } + + constexpr const_iterator cend() const + { + return const_iterator{reinterpret_cast<const const_strided_span*>(this), false}; + } + + constexpr reverse_iterator rbegin() const { return reverse_iterator{end()}; } + + constexpr reverse_iterator rend() const { return reverse_iterator{begin()}; } + + constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; } + + constexpr const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator==(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return bounds_.size() == other.bounds_.size() && + (data_ == other.data_ || std::equal(this->begin(), this->end(), other.begin())); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator!=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(*this == other); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return std::lexicographical_compare(this->begin(), this->end(), other.begin(), other.end()); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator<=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return (other < *this); + } + + template <typename OtherValueType, std::ptrdiff_t OtherRank, + typename Dummy = std::enable_if_t<std::is_same< + std::remove_cv_t<value_type>, std::remove_cv_t<OtherValueType>>::value>> + constexpr bool operator>=(const strided_span<OtherValueType, OtherRank>& other) const noexcept + { + return !(*this < other); + } + +private: + static index_type resize_extent(const index_type& extent, std::ptrdiff_t d) + { + // The last dimension of the array needs to contain a multiple of new type elements + Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0)); + + index_type ret = extent; + ret[Rank - 1] /= d; + + return ret; + } + + template <bool Enabled = (Rank == 1), typename Dummy = std::enable_if_t<Enabled>> + static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = 0) + { + // Only strided arrays with regular strides can be resized + Expects(strides[Rank - 1] == 1); + + return strides; + } + + template <bool Enabled = (Rank > 1), typename Dummy = std::enable_if_t<Enabled>> + static index_type resize_stride(const index_type& strides, std::ptrdiff_t d) + { + // Only strided arrays with regular strides can be resized + Expects(strides[Rank - 1] == 1); + // The strides must have contiguous chunks of + // memory that can contain a multiple of new type elements + Expects(strides[Rank - 2] >= d && (strides[Rank - 2] % d == 0)); + + for (size_t i = Rank - 1; i > 0; --i) { + // Only strided arrays with regular strides can be resized + Expects((strides[i - 1] >= strides[i]) && (strides[i - 1] % strides[i] == 0)); + } + + index_type ret = strides / d; + ret[Rank - 1] = 1; + + return ret; + } +}; + +template <class Span> +class contiguous_span_iterator + : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +{ + using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; + +public: + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + +private: + template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions> + friend class multi_span; + + pointer data_; + const Span* m_validator; + void validateThis() const + { + // iterator is out of range of the array + Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size()); + } + contiguous_span_iterator(const Span* container, bool isbegin) + : data_(isbegin ? container->data_ : container->data_ + container->size()) + , m_validator(container) + { + } + +public: + reference operator*() const noexcept + { + validateThis(); + return *data_; + } + pointer operator->() const noexcept + { + validateThis(); + return data_; + } + contiguous_span_iterator& operator++() noexcept + { + ++data_; + return *this; + } + contiguous_span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + contiguous_span_iterator& operator--() noexcept + { + --data_; + return *this; + } + contiguous_span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + contiguous_span_iterator operator+(difference_type n) const noexcept + { + contiguous_span_iterator ret{*this}; + return ret += n; + } + contiguous_span_iterator& operator+=(difference_type n) noexcept + { + data_ += n; + return *this; + } + contiguous_span_iterator operator-(difference_type n) const noexcept + { + contiguous_span_iterator ret{*this}; + return ret -= n; + } + contiguous_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + difference_type operator-(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ - rhs.data_; + } + reference operator[](difference_type n) const noexcept { return *(*this + n); } + bool operator==(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ == rhs.data_; + } + bool operator!=(const contiguous_span_iterator& rhs) const noexcept { return !(*this == rhs); } + bool operator<(const contiguous_span_iterator& rhs) const noexcept + { + Expects(m_validator == rhs.m_validator); + return data_ < rhs.data_; + } + bool operator<=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs < *this); } + bool operator>(const contiguous_span_iterator& rhs) const noexcept { return rhs < *this; } + bool operator>=(const contiguous_span_iterator& rhs) const noexcept { return !(rhs > *this); } + void swap(contiguous_span_iterator& rhs) noexcept + { + std::swap(data_, rhs.data_); + std::swap(m_validator, rhs.m_validator); + } +}; + +template <typename Span> +contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>::difference_type n, + const contiguous_span_iterator<Span>& rhs) noexcept +{ + return rhs + n; +} + +template <typename Span> +class general_span_iterator + : public std::iterator<std::random_access_iterator_tag, typename Span::value_type> +{ + using Base = std::iterator<std::random_access_iterator_tag, typename Span::value_type>; + +public: + using typename Base::reference; + using typename Base::pointer; + using typename Base::difference_type; + using typename Base::value_type; + +private: + template <typename ValueType, size_t Rank> + friend class strided_span; + + const Span* m_container; + typename Span::bounds_type::iterator m_itr; + general_span_iterator(const Span* container, bool isbegin) + : m_container(container) + , m_itr(isbegin ? m_container->bounds().begin() : m_container->bounds().end()) + { + } + +public: + reference operator*() noexcept { return (*m_container)[*m_itr]; } + pointer operator->() noexcept { return &(*m_container)[*m_itr]; } + general_span_iterator& operator++() noexcept + { + ++m_itr; + return *this; + } + general_span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + general_span_iterator& operator--() noexcept + { + --m_itr; + return *this; + } + general_span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + general_span_iterator operator+(difference_type n) const noexcept + { + general_span_iterator ret{*this}; + return ret += n; + } + general_span_iterator& operator+=(difference_type n) noexcept + { + m_itr += n; + return *this; + } + general_span_iterator operator-(difference_type n) const noexcept + { + general_span_iterator ret{*this}; + return ret -= n; + } + general_span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + difference_type operator-(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr - rhs.m_itr; + } + value_type operator[](difference_type n) const noexcept { return (*m_container)[m_itr[n]]; } + + bool operator==(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr == rhs.m_itr; + } + bool operator!=(const general_span_iterator& rhs) const noexcept { return !(*this == rhs); } + bool operator<(const general_span_iterator& rhs) const noexcept + { + Expects(m_container == rhs.m_container); + return m_itr < rhs.m_itr; + } + bool operator<=(const general_span_iterator& rhs) const noexcept { return !(rhs < *this); } + bool operator>(const general_span_iterator& rhs) const noexcept { return rhs < *this; } + bool operator>=(const general_span_iterator& rhs) const noexcept { return !(rhs > *this); } + void swap(general_span_iterator& rhs) noexcept + { + std::swap(m_itr, rhs.m_itr); + std::swap(m_container, rhs.m_container); + } +}; + +template <typename Span> +general_span_iterator<Span> operator+(typename general_span_iterator<Span>::difference_type n, + const general_span_iterator<Span>& rhs) noexcept +{ + return rhs + n; +} + +} // namespace gsl + +#ifdef _MSC_VER + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 +#pragma warning(pop) + +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#undef noexcept +#pragma pop_macro("noexcept") +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#undef noexcept + +#ifdef _MSC_VER +#pragma warning(pop) +#pragma pop_macro("noexcept") +#endif + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#endif // GSL_MULTI_SPAN_H diff --git a/gsl/span b/gsl/span new file mode 100644 index 0000000..cf90e86 --- /dev/null +++ b/gsl/span @@ -0,0 +1,673 @@ + +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_SPAN_H +#define GSL_SPAN_H + +#include "gsl_assert" +#include "gsl_byte" +#include "gsl_util" +#include <array> +#include <iterator> +#include <limits> +#include <stdexcept> +#include <type_traits> +#include <utility> + +#ifdef _MSC_VER + +#pragma warning(push) + +// turn off some warnings that are noisy about our Expects statements +#pragma warning(disable : 4127) // conditional expression is constant + +// blanket turn off warnings from CppCoreCheck for now +// so people aren't annoyed by them when running the tool. +// more targeted suppressions will be added in a future update to the GSL +#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#define GSL_MSVC_HAS_VARIADIC_CTOR_BUG +#define GSL_MSVC_NO_DEFAULT_MOVE_CTOR +#define GSL_MSVC_NO_CPP14_STD_EQUAL + +// noexcept is not understood +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ +#endif + +#pragma push_macro("alignof") +#define alignof __alignof + +// turn off some misguided warnings +#pragma warning(push) +#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior +#pragma warning(disable : 4512) // warns that assignment op could not be generated + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma push_macro("noexcept") +#endif + +#define noexcept /*noexcept*/ + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +namespace gsl +{ + +// [views.constants], constants +constexpr const std::ptrdiff_t dynamic_extent = -1; + +template <class ElementType, std::ptrdiff_t Extent = dynamic_extent> +class span; + +// implementation details +namespace details +{ + template <class T> + struct is_span_oracle : std::false_type + { + }; + + template <class ElementType, std::ptrdiff_t Extent> + struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type + { + }; + + template <class T> + struct is_span : public is_span_oracle<std::remove_cv_t<T>> + { + }; + + template <class T> + struct is_std_array_oracle : std::false_type + { + }; + + template <class ElementType, size_t Extent> + struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type + { + }; + + template <class T> + struct is_std_array : public is_std_array_oracle<std::remove_cv_t<T>> + { + }; + + template <std::ptrdiff_t From, std::ptrdiff_t To> + struct is_allowed_extent_conversion + : public std::integral_constant<bool, From == To || From == gsl::dynamic_extent || + To == gsl::dynamic_extent> + { + }; + + template <class From, class To> + struct is_allowed_element_type_conversion + : public std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value> + { + }; + + template <class Span, bool IsConst> + class span_iterator + { + public: + using iterator_category = std::random_access_iterator_tag; + using value_type = + std::conditional_t<IsConst, std::add_const_t<typename Span::element_type>, + typename Span::element_type>; + using difference_type = typename Span::index_type; + + using pointer = std::add_pointer_t<value_type>; + using reference = std::add_lvalue_reference_t<value_type>; + + constexpr span_iterator() noexcept : span_iterator(nullptr, 0) {} + + constexpr span_iterator(const Span* span, typename Span::index_type index) + : span_(span), index_(index) + { + Expects(span == nullptr || (index_ >= 0 && index <= span_->length())); + } + + friend class span_iterator<Span, true>; + constexpr span_iterator(const span_iterator<Span, false>& other) noexcept + : span_iterator(other.span_, other.index_) + { + } + + constexpr span_iterator<Span, IsConst>& operator=(const span_iterator<Span, IsConst>&) noexcept = default; + + constexpr reference operator*() const + { + Expects(span_); + return (*span_)[index_]; + } + + constexpr pointer operator->() const + { + Expects(span_); + return &((*span_)[index_]); + } + + constexpr span_iterator& operator++() noexcept + { + Expects(span_ && index_ >= 0 && index_ < span_->length()); + ++index_; + return *this; + } + + constexpr span_iterator operator++(int) noexcept + { + auto ret = *this; + ++(*this); + return ret; + } + + constexpr span_iterator& operator--() noexcept + { + Expects(span_ && index_ > 0 && index_ <= span_->length()); + --index_; + return *this; + } + + constexpr span_iterator operator--(int) noexcept + { + auto ret = *this; + --(*this); + return ret; + } + + constexpr span_iterator operator+(difference_type n) const noexcept + { + auto ret = *this; + return ret += n; + } + + constexpr span_iterator& operator+=(difference_type n) noexcept + { + Expects(span_ && (index_ + n) >= 0 && (index_ + n) <= span_->length()); + index_ += n; + return *this; + } + + constexpr span_iterator operator-(difference_type n) const noexcept + { + auto ret = *this; + return ret -= n; + } + + constexpr span_iterator& operator-=(difference_type n) noexcept { return *this += -n; } + + constexpr difference_type operator-(const span_iterator& rhs) const noexcept + { + Expects(span_ == rhs.span_); + return index_ - rhs.index_; + } + + constexpr reference operator[](difference_type n) const noexcept { return *(*this + n); } + + constexpr friend bool operator==(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_; + } + + constexpr friend bool operator!=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(lhs == rhs); + } + + constexpr friend bool operator<(const span_iterator& lhs, const span_iterator& rhs) noexcept + { + Expects(lhs.span_ == rhs.span_); + return lhs.index_ < rhs.index_; + } + + constexpr friend bool operator<=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(rhs < lhs); + } + + constexpr friend bool operator>(const span_iterator& lhs, const span_iterator& rhs) noexcept + { + return rhs < lhs; + } + + constexpr friend bool operator>=(const span_iterator& lhs, + const span_iterator& rhs) noexcept + { + return !(rhs > lhs); + } + + void swap(span_iterator& rhs) noexcept + { + std::swap(index_, rhs.index_); + std::swap(span_, rhs.span_); + } + + protected: + const Span* span_; + std::ptrdiff_t index_; + }; + + template <class Span, bool IsConst> + constexpr span_iterator<Span, IsConst> + operator+(typename span_iterator<Span, IsConst>::difference_type n, + const span_iterator<Span, IsConst>& rhs) noexcept + { + return rhs + n; + } + + template <class Span, bool IsConst> + constexpr span_iterator<Span, IsConst> + operator-(typename span_iterator<Span, IsConst>::difference_type n, + const span_iterator<Span, IsConst>& rhs) noexcept + { + return rhs - n; + } + + template <std::ptrdiff_t Ext> + class extent_type + { + public: + using index_type = std::ptrdiff_t; + + static_assert(Ext >= 0, "A fixed-size span must be >= 0 in size."); + + constexpr extent_type() noexcept {} + + template <index_type Other> + constexpr extent_type(extent_type<Other> ext) noexcept + { + static_assert(Other == Ext || Other == dynamic_extent, + "Mismatch between fixed-size extent and size of initializing data."); + Expects(ext.size() == Ext); + } + + constexpr extent_type(index_type size) { Expects(size == Ext); } + + constexpr inline index_type size() const noexcept { return Ext; } + }; + + template <> + class extent_type<dynamic_extent> + { + public: + using index_type = std::ptrdiff_t; + + template <index_type Other> + explicit constexpr extent_type(extent_type<Other> ext) : size_(ext.size()) + { + } + + explicit constexpr extent_type(index_type size) : size_(size) { Expects(size >= 0); } + + constexpr inline index_type size() const noexcept { return size_; } + + private: + index_type size_; + }; +} // namespace details + +// [span], class template span +template <class ElementType, std::ptrdiff_t Extent> +class span +{ +public: + // constants and types + using element_type = ElementType; + using index_type = std::ptrdiff_t; + using pointer = element_type*; + using reference = element_type&; + + using iterator = details::span_iterator<span<ElementType, Extent>, false>; + using const_iterator = details::span_iterator<span<ElementType, Extent>, true>; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + + constexpr static const index_type extent = Extent; + + // [span.cons], span constructors, copy, assignment, and destructor + constexpr span() noexcept : storage_(nullptr, details::extent_type<0>()) {} + + constexpr span(std::nullptr_t) noexcept : span() {} + + constexpr span(pointer ptr, index_type count) : storage_(ptr, count) {} + + constexpr span(pointer firstElem, pointer lastElem) + : storage_(firstElem, std::distance(firstElem, lastElem)) + { + } + + template <size_t N> + constexpr span(element_type (&arr)[N]) noexcept : storage_(&arr[0], details::extent_type<N>()) + { + } + + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr span(std::array<ArrayElementType, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) + { + } + + template <size_t N> + constexpr span(const std::array<std::remove_const_t<element_type>, N>& arr) noexcept + : storage_(&arr[0], details::extent_type<N>()) + { + } + + // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement + // on Container to be a contiguous sequence container. + template <class Container, + class = std::enable_if_t< + !details::is_span<Container>::value && !details::is_std_array<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) + { + } + + template <class Container, + class = std::enable_if_t< + std::is_const<element_type>::value && !details::is_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr span(const Container& cont) : span(cont.data(), narrow<index_type>(cont.size())) + { + } + + constexpr span(const span& other) noexcept = default; +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span(span&& other) noexcept = default; +#else + constexpr span(span&& other) noexcept : storage_(std::move(other.storage_)) {} +#endif + + template < + class OtherElementType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t< + details::is_allowed_extent_conversion<OtherExtent, Extent>::value && + details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>> + constexpr span(const span<OtherElementType, OtherExtent>& other) + : storage_(other.data(), details::extent_type<OtherExtent>(other.size())) + { + } + + template < + class OtherElementType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t< + details::is_allowed_extent_conversion<OtherExtent, Extent>::value && + details::is_allowed_element_type_conversion<OtherElementType, element_type>::value>> + constexpr span(span<OtherElementType, OtherExtent>&& other) + : storage_(other.data(), details::extent_type<OtherExtent>(other.size())) + { + } + + ~span() noexcept = default; + constexpr span& operator=(const span& other) noexcept = default; + +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr span& operator=(span&& other) noexcept = default; +#else + constexpr span& operator=(span&& other) noexcept + { + storage_ = std::move(other.storage_); + return *this; + } +#endif + // [span.sub], span subviews + template <std::ptrdiff_t Count> + constexpr span<element_type, Count> first() const + { + Expects(Count >= 0 && Count <= size()); + return {data(), Count}; + } + + template <std::ptrdiff_t Count> + constexpr span<element_type, Count> last() const + { + Expects(Count >= 0 && Count <= size()); + return {data() + (size() - Count), Count}; + } + + template <std::ptrdiff_t Offset, std::ptrdiff_t Count = dynamic_extent> + constexpr span<element_type, Count> subspan() const + { + Expects((Offset == 0 || (Offset > 0 && Offset <= size())) && + (Count == dynamic_extent || (Count >= 0 && Offset + Count <= size()))); + return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count}; + } + + constexpr span<element_type, dynamic_extent> first(index_type count) const + { + Expects(count >= 0 && count <= size()); + return {data(), count}; + } + + constexpr span<element_type, dynamic_extent> last(index_type count) const + { + Expects(count >= 0 && count <= size()); + return {data() + (size() - count), count}; + } + + constexpr span<element_type, dynamic_extent> subspan(index_type offset, + index_type count = dynamic_extent) const + { + Expects((offset == 0 || (offset > 0 && offset <= size())) && + (count == dynamic_extent || (count >= 0 && offset + count <= size()))); + return {data() + offset, count == dynamic_extent ? size() - offset : count}; + } + + // [span.obs], span observers + constexpr index_type length() const noexcept { return size(); } + constexpr index_type size() const noexcept { return storage_.size(); } + constexpr index_type length_bytes() const noexcept { return size_bytes(); } + constexpr index_type size_bytes() const noexcept { return size() * sizeof(element_type); } + constexpr bool empty() const noexcept { return size() == 0; } + + // [span.elem], span element access + constexpr reference operator[](index_type idx) const + { + Expects(idx >= 0 && idx < storage_.size()); + return data()[idx]; + } + + constexpr reference at(index_type idx) const { return this->operator[](idx); } + constexpr reference operator()(index_type idx) const { return this->operator[](idx); } + constexpr pointer data() const noexcept { return storage_.data(); } + + // [span.iter], span iterator support + iterator begin() const noexcept { return {this, 0}; } + iterator end() const noexcept { return {this, length()}; } + + const_iterator cbegin() const noexcept { return {this, 0}; } + const_iterator cend() const noexcept { return {this, length()}; } + + reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } + reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } + + const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; } + const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; } + +private: + // this implementation detail class lets us take advantage of the + // empty base class optimization to pay for only storage of a single + // pointer in the case of fixed-size spans + template <class ExtentType> + class storage_type : public ExtentType + { + public: + template <class OtherExtentType> + constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data) + { + Expects((!data && ExtentType::size() == 0) || (data && ExtentType::size() >= 0)); + } + + constexpr inline pointer data() const noexcept { return data_; } + + private: + pointer data_; + }; + + storage_type<details::extent_type<Extent>> storage_; +}; + +// [span.comparison], span comparison operators +template <class ElementType, std::ptrdiff_t FirstExtent, std::ptrdiff_t SecondExtent> +constexpr bool operator==(const span<ElementType, FirstExtent>& l, + const span<ElementType, SecondExtent>& r) +{ +#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL + return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin()); +#else + return std::equal(l.begin(), l.end(), r.begin(), r.end()); +#endif +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator!=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l == r); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end()); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator<=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l > r); +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return r < l; +} + +template <class ElementType, std::ptrdiff_t Extent> +constexpr bool operator>=(const span<ElementType, Extent>& l, const span<ElementType, Extent>& r) +{ + return !(l < r); +} + +namespace details +{ + // if we only supported compilers with good constexpr support then + // this pair of classes could collapse down to a constexpr function + + // we should use a narrow_cast<> to go to size_t, but older compilers may not see it as + // constexpr + // and so will fail compilation of the template + template <class ElementType, std::ptrdiff_t Extent> + struct calculate_byte_size + : std::integral_constant<std::ptrdiff_t, + static_cast<std::ptrdiff_t>(sizeof(ElementType) * + static_cast<std::size_t>(Extent))> + { + }; + + template <class ElementType> + struct calculate_byte_size<ElementType, dynamic_extent> + : std::integral_constant<std::ptrdiff_t, dynamic_extent> + { + }; +} + +// [span.objectrep], views of object representation +template <class ElementType, std::ptrdiff_t Extent> +span<const byte, details::calculate_byte_size<ElementType, Extent>::value> +as_bytes(span<ElementType, Extent> s) noexcept +{ + return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; +} + +template <class ElementType, std::ptrdiff_t Extent, + class = std::enable_if_t<!std::is_const<ElementType>::value>> +span<byte, details::calculate_byte_size<ElementType, Extent>::value> +as_writeable_bytes(span<ElementType, Extent> s) noexcept +{ + return {reinterpret_cast<byte*>(s.data()), s.size_bytes()}; +} + +// Specialization of gsl::at for span +template <class ElementType, std::ptrdiff_t Extent> +constexpr ElementType& at(const span<ElementType, Extent>& s, size_t index) +{ + // No bounds checking here because it is done in span::operator[] called below + return s[index]; +} + +} // namespace gsl + +#ifdef _MSC_VER + +#undef constexpr +#pragma pop_macro("constexpr") + +#if _MSC_VER <= 1800 +#pragma warning(pop) + +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#undef noexcept +#pragma pop_macro("noexcept") +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#pragma pop_macro("alignof") + +#undef GSL_MSVC_HAS_VARIADIC_CTOR_BUG + +#endif // _MSC_VER <= 1800 + +#endif // _MSC_VER + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#undef noexcept + +#ifdef _MSC_VER +#pragma pop_macro("noexcept") +#endif + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // GSL_SPAN_H diff --git a/gsl/string_span b/gsl/string_span new file mode 100644 index 0000000..703bc01 --- /dev/null +++ b/gsl/string_span @@ -0,0 +1,870 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#pragma once + +#ifndef GSL_STRING_SPAN_H +#define GSL_STRING_SPAN_H + +#include "gsl_assert" +#include "gsl_util" +#include "span" +#include <cstdint> +#include <cstring> +#include <string> + +#ifdef _MSC_VER + +// No MSVC does constexpr fully yet +#pragma push_macro("constexpr") +#define constexpr /*constexpr*/ + +#pragma warning(push) + +// blanket turn off warnings from CppCoreCheck for now +// so people aren't annoyed by them when running the tool. +// more targeted suppressions will be added in a future update to the GSL +#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495) + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#define GSL_MSVC_HAS_TYPE_DEDUCTION_BUG +#define GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE +#define GSL_MSVC_NO_CPP14_STD_EQUAL +#define GSL_MSVC_NO_DEFAULT_MOVE_CTOR + +// noexcept is not understood +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#pragma push_macro("noexcept") +#define noexcept /*noexcept*/ +#endif + +#endif // _MSC_VER <= 1800 +#endif // _MSC_VER + +// In order to test the library, we need it to throw exceptions that we can catch +#ifdef GSL_THROW_ON_CONTRACT_VIOLATION + +#ifdef _MSC_VER +#pragma push_macro("noexcept") +#endif + +#define noexcept /*noexcept*/ + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +namespace gsl +{ +// +// czstring and wzstring +// +// These are "tag" typedef's for C-style strings (i.e. null-terminated character arrays) +// that allow static analysis to help find bugs. +// +// There are no additional features/semantics that we can find a way to add inside the +// type system for these types that will not either incur significant runtime costs or +// (sometimes needlessly) break existing programs when introduced. +// + +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> +using basic_zstring = CharT*; + +template <std::ptrdiff_t Extent = dynamic_extent> +using czstring = basic_zstring<const char, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using cwzstring = basic_zstring<const wchar_t, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using zstring = basic_zstring<char, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using wzstring = basic_zstring<wchar_t, Extent>; + +namespace details +{ + inline std::ptrdiff_t string_length(const char *str, std::ptrdiff_t n) + { + if (str == nullptr || n <= 0) + return 0; + + span<const char> str_span{str, n}; + + std::ptrdiff_t len = 0; + while (len < n && str_span[len]) + len++; + + return len; + } + + inline std::ptrdiff_t wstring_length(const wchar_t *str, std::ptrdiff_t n) + { + if (str == nullptr || n <= 0) + return 0; + + span<const wchar_t> str_span{str, n}; + + std::ptrdiff_t len = 0; + while (len < n && str_span[len]) + len++; + + return len; + } +} + +// +// ensure_sentinel() +// +// Provides a way to obtain an span from a contiguous sequence +// that ends with a (non-inclusive) sentinel value. +// +// Will fail-fast if sentinel cannot be found before max elements are examined. +// +template <typename T, const T Sentinel> +span<T, dynamic_extent> ensure_sentinel(T* seq, std::ptrdiff_t max = PTRDIFF_MAX) +{ + auto cur = seq; + while ((cur - seq) < max && *cur != Sentinel) ++cur; + Ensures(*cur == Sentinel); + return {seq, cur - seq}; +} + +// +// ensure_z - creates a span for a czstring or cwzstring. +// Will fail fast if a null-terminator cannot be found before +// the limit of size_type. +// +template <typename T> +inline span<T, dynamic_extent> ensure_z(T* const& sz, std::ptrdiff_t max = PTRDIFF_MAX) +{ + return ensure_sentinel<T, 0>(sz, max); +} + +// TODO (neilmac) there is probably a better template-magic way to get the const and non-const +// overloads to share an implementation +inline span<char, dynamic_extent> ensure_z(char* const& sz, std::ptrdiff_t max) +{ + auto len = details::string_length(sz, max); + Ensures(sz[len] == 0); + return {sz, len}; +} + +inline span<const char, dynamic_extent> ensure_z(const char* const& sz, std::ptrdiff_t max) +{ + auto len = details::string_length(sz, max); + Ensures(sz[len] == 0); + return {sz, len}; +} + +inline span<wchar_t, dynamic_extent> ensure_z(wchar_t* const& sz, std::ptrdiff_t max) +{ + auto len = details::wstring_length(sz, max); + Ensures(sz[len] == 0); + return {sz, len}; +} + +inline span<const wchar_t, dynamic_extent> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max) +{ + auto len = details::wstring_length(sz, max); + Ensures(sz[len] == 0); + return {sz, len}; +} + +template <typename T, size_t N> +span<T, dynamic_extent> ensure_z(T (&sz)[N]) +{ + return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); +} + +template <class Cont> +span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent> +ensure_z(Cont& cont) +{ + return ensure_z(cont.data(), static_cast<std::ptrdiff_t>(cont.length())); +} + +template <typename CharT, std::ptrdiff_t> +class basic_string_span; + +namespace details +{ + template <typename T> + struct is_basic_string_span_oracle : std::false_type + { + }; + + template <typename CharT, std::ptrdiff_t Extent> + struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type + { + }; + + template <typename T> + struct is_basic_string_span : is_basic_string_span_oracle<std::remove_cv_t<T>> + { + }; + + template <typename T> + struct length_func + { + }; + + template <> + struct length_func<char> + { + std::ptrdiff_t operator()(char* const ptr, std::ptrdiff_t length) noexcept + { + return details::string_length(ptr, length); + } + }; + + template <> + struct length_func<wchar_t> + { + std::ptrdiff_t operator()(wchar_t* const ptr, std::ptrdiff_t length) noexcept + { + return details::wstring_length(ptr, length); + } + }; + + template <> + struct length_func<const char> + { + std::ptrdiff_t operator()(const char* const ptr, std::ptrdiff_t length) noexcept + { + return details::string_length(ptr, length); + } + }; + + template <> + struct length_func<const wchar_t> + { + std::ptrdiff_t operator()(const wchar_t* const ptr, std::ptrdiff_t length) noexcept + { + return details::wstring_length(ptr, length); + } + }; +} + +// +// string_span and relatives +// +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> +class basic_string_span +{ +public: + using element_type = CharT; + using pointer = std::add_pointer_t<element_type>; + using reference = std::add_lvalue_reference_t<element_type>; + using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>; + using impl_type = span<element_type, Extent>; + + using index_type = typename impl_type::index_type; + using iterator = typename impl_type::iterator; + using const_iterator = typename impl_type::const_iterator; + using reverse_iterator = typename impl_type::reverse_iterator; + using const_reverse_iterator = typename impl_type::const_reverse_iterator; + + // default (empty) + constexpr basic_string_span() noexcept = default; + + // copy + constexpr basic_string_span(const basic_string_span& other) noexcept = default; + +// move +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr basic_string_span(basic_string_span&& other) noexcept = default; +#else + constexpr basic_string_span(basic_string_span&& other) : span_(std::move(other.span_)) {} +#endif + + // assign + constexpr basic_string_span& operator=(const basic_string_span& other) noexcept = default; + +// move assign +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr basic_string_span& operator=(basic_string_span&& other) noexcept = default; +#else + constexpr basic_string_span& operator=(basic_string_span&& other) noexcept + { + span_ = std::move(other.span_); + return *this; + } +#endif + + // from nullptr + constexpr basic_string_span(std::nullptr_t ptr) noexcept : span_(ptr) {} + + constexpr basic_string_span(pointer ptr, index_type length) : span_(ptr, length) {} + constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {} + + // From static arrays - if 0-terminated, remove 0 from the view + // All other containers allow 0s within the length, so we do not remove them + template <size_t N> + constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr)) + { + } + + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr) + { + } + + template <size_t N, class ArrayElementType = std::remove_const_t<element_type>> + constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept : span_(arr) + { + } + + // Container signature should work for basic_string after C++17 version exists + template <class Traits, class Allocator> + constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str) + : span_(&str[0], str.length()) + { + } + + template <class Traits, class Allocator> + constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str) + : span_(&str[0], str.length()) + { + } + + // from containers. Containers must have a pointer type and data() function signatures + template <class Container, + class = std::enable_if_t< + !details::is_basic_string_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr basic_string_span(Container& cont) : span_(cont) + { + } + + template <class Container, + class = std::enable_if_t< + !details::is_basic_string_span<Container>::value && + std::is_convertible<typename Container::pointer, pointer>::value && + std::is_convertible<typename Container::pointer, + decltype(std::declval<Container>().data())>::value>> + constexpr basic_string_span(const Container& cont) : span_(cont) + { + } + + // from string_span + template < + class OtherValueType, std::ptrdiff_t OtherExtent, + class = std::enable_if_t<std::is_convertible< + typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>> + constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other) + : span_(other.data(), other.length()) + { + } + + template <index_type Count> + constexpr basic_string_span<element_type, Count> first() const + { + return {span_.template first<Count>()}; + } + + constexpr basic_string_span<element_type, dynamic_extent> first(index_type count) const + { + return {span_.first(count)}; + } + + template <index_type Count> + constexpr basic_string_span<element_type, Count> last() const + { + return {span_.template last<Count>()}; + } + + constexpr basic_string_span<element_type, dynamic_extent> last(index_type count) const + { + return {span_.last(count)}; + } + + template <index_type Offset, index_type Count> + constexpr basic_string_span<element_type, Count> subspan() const + { + return {span_.template subspan<Offset, Count>()}; + } + + constexpr basic_string_span<element_type, dynamic_extent> + subspan(index_type offset, index_type count = dynamic_extent) const + { + return {span_.subspan(offset, count)}; + } + + constexpr reference operator[](index_type idx) const { return span_[idx]; } + constexpr reference operator()(index_type idx) const { return span_[idx]; } + + constexpr pointer data() const { return span_.data(); } + + constexpr index_type length() const noexcept { return span_.size(); } + constexpr index_type size() const noexcept { return span_.size(); } + constexpr index_type size_bytes() const noexcept { return span_.size_bytes(); } + constexpr index_type length_bytes() const noexcept { return span_.length_bytes(); } + constexpr bool empty() const noexcept { return size() == 0; } + + constexpr iterator begin() const noexcept { return span_.begin(); } + constexpr iterator end() const noexcept { return span_.end(); } + + constexpr const_iterator cbegin() const noexcept { return span_.cbegin(); } + constexpr const_iterator cend() const noexcept { return span_.cend(); } + + constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); } + constexpr reverse_iterator rend() const noexcept { return span_.rend(); } + + constexpr const_reverse_iterator crbegin() const noexcept { return span_.crbegin(); } + constexpr const_reverse_iterator crend() const noexcept { return span_.crend(); } + +private: + static impl_type remove_z(pointer const& sz, std::ptrdiff_t max) + { + return {sz, details::length_func<element_type>()(sz, max)}; + } + + template <size_t N> + static impl_type remove_z(element_type (&sz)[N]) + { + return remove_z(&sz[0], narrow_cast<std::ptrdiff_t>(N)); + } + + impl_type span_; +}; + +template <std::ptrdiff_t Extent = dynamic_extent> +using string_span = basic_string_span<char, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using cstring_span = basic_string_span<const char, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using wstring_span = basic_string_span<wchar_t, Extent>; + +template <std::ptrdiff_t Extent = dynamic_extent> +using cwstring_span = basic_string_span<const wchar_t, Extent>; + +// +// to_string() allow (explicit) conversions from string_span to string +// +#ifndef GSL_MSVC_HAS_TYPE_DEDUCTION_BUG + +template <typename CharT, std::ptrdiff_t Extent> +std::basic_string<typename std::remove_const<CharT>::type> +to_string(basic_string_span<CharT, Extent> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +#else + +inline std::string to_string(cstring_span<> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +inline std::string to_string(string_span<> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +inline std::wstring to_string(cwstring_span<> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +inline std::wstring to_string(wstring_span<> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +#endif + +template <typename CharT, + typename Traits = typename std::char_traits<CharT>, + typename Allocator = std::allocator<CharT>, + typename gCharT, + std::ptrdiff_t Extent> +std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view) +{ + return {view.data(), static_cast<size_t>(view.length())}; +} + +// zero-terminated string span, used to convert +// zero-terminated spans to legacy strings +template <typename CharT, std::ptrdiff_t Extent = dynamic_extent> +class basic_zstring_span +{ +public: + using value_type = CharT; + using const_value_type = std::add_const_t<CharT>; + + using pointer = std::add_pointer_t<value_type>; + using const_pointer = std::add_pointer_t<const_value_type>; + + using zstring_type = basic_zstring<value_type, Extent>; + using const_zstring_type = basic_zstring<const_value_type, Extent>; + + using impl_type = span<value_type, Extent>; + using string_span_type = basic_string_span<value_type, Extent>; + + constexpr basic_zstring_span(impl_type s) noexcept : span_(s) + { + // expects a zero-terminated span + Expects(s[s.size() - 1] == '\0'); + } + + // copy + constexpr basic_zstring_span(const basic_zstring_span& other) = default; + +// move +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr basic_zstring_span(basic_zstring_span&& other) = default; +#else + constexpr basic_zstring_span(basic_zstring_span&& other) : span_(std::move(other.span_)) {} +#endif + + // assign + constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default; + +// move assign +#ifndef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default; +#else + constexpr basic_zstring_span& operator=(basic_zstring_span&& other) + { + span_ = std::move(other.span_); + return *this; + } +#endif + + constexpr bool empty() const noexcept { return span_.size() == 0; } + + constexpr string_span_type as_string_span() const noexcept + { + auto sz = span_.size(); + return span_.first(sz <= 0 ? 0 : sz - 1); + } + + constexpr string_span_type ensure_z() const noexcept { return gsl::ensure_z(span_); } + + constexpr const_zstring_type assume_z() const noexcept { return span_.data(); } + +private: + impl_type span_; +}; + +template <std::ptrdiff_t Max = dynamic_extent> +using zstring_span = basic_zstring_span<char, Max>; + +template <std::ptrdiff_t Max = dynamic_extent> +using wzstring_span = basic_zstring_span<wchar_t, Max>; + +template <std::ptrdiff_t Max = dynamic_extent> +using czstring_span = basic_zstring_span<const char, Max>; + +template <std::ptrdiff_t Max = dynamic_extent> +using cwzstring_span = basic_zstring_span<const wchar_t, Max>; + +// operator == +template <class CharT, std::ptrdiff_t Extent, class T, + class = std::enable_if_t< + details::is_basic_string_span<T>::value || + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>> +bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>> tmp(other); +#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL + return (one.size() == tmp.size()) && std::equal(one.begin(), one.end(), tmp.begin()); +#else + return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end()); +#endif +} + +template <class CharT, std::ptrdiff_t Extent, class T, + class = std::enable_if_t< + !details::is_basic_string_span<T>::value && + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>> +bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>> tmp(one); +#ifdef GSL_MSVC_NO_CPP14_STD_EQUAL + return (tmp.size() == other.size()) && std::equal(tmp.begin(), tmp.end(), other.begin()); +#else + return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end()); +#endif +} + +// operator != +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> +bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return !(one == other); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename Dummy = std::enable_if_t< + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> +bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return !(one == other); +} + +// operator< +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> +bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); + return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end()); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename Dummy = std::enable_if_t< + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> +bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); + return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end()); +} + +#ifndef _MSC_VER + +// VS treats temp and const containers as convertible to basic_string_span, +// so the cases below are already covered by the previous operators + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other); + return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end()); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one); + return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end()); +} +#endif + +// operator <= +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> +bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return !(other < one); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename Dummy = std::enable_if_t< + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> +bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return !(other < one); +} + +#ifndef _MSC_VER + +// VS treats temp and const containers as convertible to basic_string_span, +// so the cases below are already covered by the previous operators + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return !(other < one); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return !(other < one); +} +#endif + +// operator> +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> +bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return other < one; +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename Dummy = std::enable_if_t< + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> +bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return other < one; +} + +#ifndef _MSC_VER + +// VS treats temp and const containers as convertible to basic_string_span, +// so the cases below are already covered by the previous operators + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return other < one; +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return other < one; +} +#endif + +// operator >= +template <typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename = std::enable_if_t<std::is_convertible< + T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>> +bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return !(one < other); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename Dummy = std::enable_if_t< + std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value && + !gsl::details::is_basic_string_span<T>::value>> +bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return !(one < other); +} + +#ifndef _MSC_VER + +// VS treats temp and const containers as convertible to basic_string_span, +// so the cases below are already covered by the previous operators + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other) noexcept +{ + return !(one < other); +} + +template < + typename CharT, std::ptrdiff_t Extent = gsl::dynamic_extent, typename T, + typename DataType = typename T::value_type, + typename Dummy = std::enable_if_t< + !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value && + std::is_convertible<DataType*, CharT*>::value && + std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>, + DataType>::value>> +bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other) noexcept +{ + return !(one < other); +} +#endif +} // namespace GSL + +#ifdef _MSC_VER + +#pragma warning(pop) + +#undef constexpr +#pragma pop_macro("constexpr") + +// VS 2013 workarounds +#if _MSC_VER <= 1800 + +#ifndef GSL_THROW_ON_CONTRACT_VIOLATION +#undef noexcept +#pragma pop_macro("noexcept") +#endif // GSL_THROW_ON_CONTRACT_VIOLATION + +#undef GSL_MSVC_HAS_TYPE_DEDUCTION_BUG +#undef GSL_MSVC_HAS_SFINAE_SUBSTITUTION_ICE +#undef GSL_MSVC_NO_CPP14_STD_EQUAL +#undef GSL_MSVC_NO_DEFAULT_MOVE_CTOR + +#endif // _MSC_VER <= 1800 +#endif // _MSC_VER + +#if defined(GSL_THROW_ON_CONTRACT_VIOLATION) + +#undef noexcept + +#ifdef _MSC_VER +#pragma pop_macro("noexcept") +#endif + +#endif // GSL_THROW_ON_CONTRACT_VIOLATION +#endif // GSL_STRING_SPAN_H diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 0000000..44db32d --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,54 @@ +cmake_minimum_required(VERSION 2.8.7) + +project(GSLTests CXX) + +if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/unittest-cpp/tests) + execute_process(COMMAND git submodule update --init WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +endif() + +add_subdirectory(unittest-cpp) + +include_directories( + .. + ./unittest-cpp +) + +add_definitions(-DGSL_THROW_ON_CONTRACT_VIOLATION) + +if(MSVC14 OR MSVC12) # has the support we need + # remove unnecessary warnings about unchecked iterators + add_definitions(-D_SCL_SECURE_NO_WARNINGS) + add_compile_options(/W4) +else() + include(CheckCXXCompilerFlag) + CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14) + CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) + if(COMPILER_SUPPORTS_CXX14) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -std=c++14 -O3 -Wall -Wno-missing-braces") + elseif(COMPILER_SUPPORTS_CXX11) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing -std=c++11 -O3 -Wall -Wno-missing-braces") + else() + message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.") + endif() +endif() + +function(add_gsl_test name) + add_executable(${name} ${name}.cpp ../gsl/gsl ../gsl/gsl_assert ../gsl/gsl_util ../gsl/multi_span ../gsl/span ../gsl/string_span) + target_link_libraries(${name} UnitTest++) + add_test( + ${name} + ${name} + ) +endfunction() + +add_gsl_test(span_tests) +add_gsl_test(multi_span_tests) +add_gsl_test(strided_span_tests) +add_gsl_test(string_span_tests) +add_gsl_test(at_tests) +add_gsl_test(bounds_tests) +add_gsl_test(notnull_tests) +add_gsl_test(assertion_tests) +add_gsl_test(utils_tests) +add_gsl_test(owner_tests) +add_gsl_test(byte_tests) diff --git a/tests/assertion_tests.cpp b/tests/assertion_tests.cpp new file mode 100644 index 0000000..a251200 --- /dev/null +++ b/tests/assertion_tests.cpp @@ -0,0 +1,53 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl> + +using namespace gsl; + +SUITE(assertion_tests) +{ + int f(int i) + { + Expects(i > 0 && i < 10); + return i; + } + + TEST(expects) + { + CHECK(f(2) == 2); + CHECK_THROW(f(10), fail_fast); + } + + int g(int i) + { + i++; + Ensures(i > 0 && i < 10); + return i; + } + + TEST(ensures) + { + CHECK(g(2) == 3); + CHECK_THROW(g(9), fail_fast); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/at_tests.cpp b/tests/at_tests.cpp new file mode 100644 index 0000000..008fddf --- /dev/null +++ b/tests/at_tests.cpp @@ -0,0 +1,71 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl> +#include <vector> +#include <initializer_list> + +using namespace std; +using namespace gsl; + +SUITE(at_tests) +{ + TEST(static_array) + { + int a[] = { 1, 2, 3, 4 }; + + for (int i = 0; i < 4; ++i) + CHECK(at(a, i) == i+1); + + CHECK_THROW(at(a, 4), fail_fast); + } + + TEST(std_array) + { + std::array<int,4> a = { 1, 2, 3, 4 }; + + for (int i = 0; i < 4; ++i) + CHECK(at(a, i) == i+1); + + CHECK_THROW(at(a, 4), fail_fast); + } + + TEST(StdVector) + { + std::vector<int> a = { 1, 2, 3, 4 }; + + for (int i = 0; i < 4; ++i) + CHECK(at(a, i) == i+1); + + CHECK_THROW(at(a, 4), fail_fast); + } + + TEST(InitializerList) + { + std::initializer_list<int> a = { 1, 2, 3, 4 }; + + for (int i = 0; i < 4; ++i) + CHECK(at(a, i) == i+1); + + CHECK_THROW(at(a, 4), fail_fast); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/bounds_tests.cpp b/tests/bounds_tests.cpp new file mode 100644 index 0000000..d10bf6d --- /dev/null +++ b/tests/bounds_tests.cpp @@ -0,0 +1,103 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/multi_span> +#include <vector> + +using namespace std; +using namespace gsl;; + +namespace +{ + void use(std::ptrdiff_t&) {} +} + +SUITE(bounds_test) +{ + TEST(basic_bounds) + { + for (auto point : static_bounds<dynamic_range, 3, 4 > { 2 }) + { + for (decltype(point)::size_type j = 0; + j < static_cast<decltype(point)::size_type>(decltype(point)::rank); + j++) + { + use(j); + use(point[j]); + } + } + } + + TEST(bounds_basic) + { + static_bounds<3, 4, 5> b; + auto a = b.slice(); + (void)a; + static_bounds<4, dynamic_range, 2> x{ 4 }; + x.slice().slice(); + } + + TEST (arrayview_iterator) + { + static_bounds<4, dynamic_range, 2> bounds{ 3 }; + + auto itr = bounds.begin(); + (void)itr; +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 4, dynamic_range, 2> av(nullptr, bounds); + + auto itr2 = av.cbegin(); + + for (auto& v : av) { + v = 4; + } + fill(av.begin(), av.end(), 0); +#endif + } + + TEST (bounds_convertible) + { + static_bounds<7, 4, 2> b1; + static_bounds<7, dynamic_range, 2> b2 = b1; + (void)b2; +#ifdef CONFIRM_COMPILATION_ERRORS + static_bounds<7, dynamic_range, 1> b4 = b2; +#endif + + static_bounds<dynamic_range, dynamic_range, dynamic_range> b3 = b1; + static_bounds<7, 4, 2> b4 = b3; + (void)b4; + + static_bounds<dynamic_range> b11; + + static_bounds<dynamic_range> b5; + static_bounds<34> b6; + + b5 = static_bounds<20>(); + CHECK_THROW(b6 = b5, fail_fast); + b5 = static_bounds<34>(); + b6 = b5; + + CHECK(b5 == b6); + CHECK(b5.size() == b6.size()); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/byte_tests.cpp b/tests/byte_tests.cpp new file mode 100644 index 0000000..8cb0da8 --- /dev/null +++ b/tests/byte_tests.cpp @@ -0,0 +1,135 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl_byte> + +#include <iostream> +#include <list> +#include <map> +#include <memory> +#include <string> +#include <vector> + +using namespace std; +using namespace gsl; + +namespace +{ + +SUITE(byte_tests) +{ + TEST(construction) + { + { + byte b = static_cast<byte>(4); + CHECK(static_cast<unsigned char>(b) == 4); + } + + { + byte b = byte(12); + CHECK(static_cast<unsigned char>(b) == 12); + } + + { + byte b = to_byte<12>(); + CHECK(static_cast<unsigned char>(b) == 12); + } + { + unsigned char uc = 12; + byte b = to_byte(uc); + CHECK(static_cast<unsigned char>(b) == 12); + } + + // waiting for C++17 enum class direct initializer support + //{ + // byte b { 14 }; + // CHECK(static_cast<unsigned char>(b) == 14); + //} + } + + TEST(bitwise_operations) + { + byte b = to_byte<0xFF>(); + + byte a = to_byte<0x00>(); + CHECK((b | a) == to_byte<0xFF>()); + CHECK(a == to_byte<0x00>()); + + a |= b; + CHECK(a == to_byte<0xFF>()); + + a = to_byte<0x01>(); + CHECK((b & a) == to_byte<0x01>()); + + a &= b; + CHECK(a == to_byte<0x01>()); + + CHECK((b ^ a) == to_byte<0xFE>()); + + CHECK(a == to_byte<0x01>()); + a ^= b; + CHECK(a == to_byte<0xFE>()); + + a = to_byte<0x01>(); + CHECK(~a == to_byte<0xFE>()); + + a = to_byte<0xFF>(); + CHECK((a << 4) == to_byte<0xF0>()); + CHECK((a >> 4) == to_byte<0x0F>()); + + a <<= 4; + CHECK(a == to_byte<0xF0>()); + a >>= 4; + CHECK(a == to_byte<0x0F>()); + } + + TEST(to_integer) + { + byte b = to_byte<0x12>(); + + CHECK(0x12 == gsl::to_integer<char>(b)); + CHECK(0x12 == gsl::to_integer<short>(b)); + CHECK(0x12 == gsl::to_integer<long>(b)); + CHECK(0x12 == gsl::to_integer<long long>(b)); + + CHECK(0x12 == gsl::to_integer<unsigned char>(b)); + CHECK(0x12 == gsl::to_integer<unsigned short>(b)); + CHECK(0x12 == gsl::to_integer<unsigned long>(b)); + CHECK(0x12 == gsl::to_integer<unsigned long long>(b)); + +// CHECK(0x12 == gsl::to_integer<float>(b)); // expect compile-time error +// CHECK(0x12 == gsl::to_integer<double>(b)); // expect compile-time error + } + + int modify_both(gsl::byte& b, int& i) + { + i = 10; + b = to_byte<5>(); + return i; + } + + TEST(aliasing) + { + int i{ 0 }; + int res = modify_both(reinterpret_cast<byte&>(i), i); + CHECK(res == i); + } +} + +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/multi_span_tests.cpp b/tests/multi_span_tests.cpp new file mode 100644 index 0000000..c0240ea --- /dev/null +++ b/tests/multi_span_tests.cpp @@ -0,0 +1,1685 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/multi_span> + +#include <iostream> +#include <list> +#include <map> +#include <memory> +#include <string> +#include <vector> + +using namespace std; +using namespace gsl; + +namespace +{ +struct BaseClass +{ +}; +struct DerivedClass : BaseClass +{ +}; +} + +SUITE(multi_span_tests) +{ + + TEST(default_constructor) + { + { + multi_span<int> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + multi_span<int> s{}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_constructor) + { + { + multi_span<int> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s = nullptr; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + multi_span<int> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int*> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int*> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_length_constructor) + { + { + multi_span<int> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + multi_span<int, 0> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int, 0> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 1> s{nullptr, 0}; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + auto workaround_macro = []() { multi_span<int> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { multi_span<const int> cs{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + auto workaround_macro = []() { multi_span<int, 0> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { multi_span<const int, 0> s{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + multi_span<int*> s{nullptr, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + + multi_span<const int*> cs{nullptr, 0}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_element_constructor) + { + int i = 5; + + { + multi_span<int> s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + + multi_span<const int> cs = i; + CHECK(cs.length() == 1 && cs.data() == &i); + CHECK(cs[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + const j = 1; + multi_span<int, 0> s = j; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 0> s = i; + CHECK(s.length() == 0 && s.data() == &i); +#endif + } + + { + multi_span<int, 1> s = i; + CHECK(s.length() == 1 && s.data() == &i); + CHECK(s[0] == 5); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 2> s = i; + CHECK(s.length() == 2 && s.data() == &i); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_a_temp = []() -> int { return 4; }; + auto use_a_span = [](multi_span<int> s) { (void) s; }; + use_a_span(get_a_temp()); +#endif + } + } + + TEST(from_pointer_length_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int, 2> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + int* p = nullptr; + multi_span<int> s{p, 0}; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + { + int* p = nullptr; + auto workaround_macro = [=]() { multi_span<int> s{p, 2}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_pointer_pointer_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int, 2> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + multi_span<int> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + multi_span<int, 0> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + auto workaround_macro = [&]() { multi_span<int> s{&arr[1], &arr[0]}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{p, p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + int* p = nullptr; + auto workaround_macro = [&]() { multi_span<int> s{&arr[0], p}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_array_constructor) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { + multi_span<int, 5> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 6> s{arr}; +#endif + } + + { + multi_span<int, 0> s{arr}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + multi_span<int> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { + multi_span<int, 0> s{arr2d}; + CHECK(s.length() == 0 && s.data() == &arr2d[0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 5> s{arr2d}; +#endif + } + + { + multi_span<int, 6> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 7> s{arr2d}; +#endif + } + + { + multi_span<int[3]> s{arr2d[0]}; + CHECK(s.length() == 1 && s.data() == &arr2d[0]); + } + + { + multi_span<int, 2, 3> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + auto workaround_macro = [&]() { return s[{1, 2}] == 6; }; + CHECK(workaround_macro()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 3, 3> s{arr2d}; +#endif + } + + int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; + + { + multi_span<int> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[11] == 12); + } + + { + multi_span<int, 0> s{arr3d}; + CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 11> s{arr3d}; +#endif + } + + { + multi_span<int, 12> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 13> s{arr3d}; +#endif + } + + { + multi_span<int[3][2]> s{arr3d[0]}; + CHECK(s.length() == 1 && s.data() == &arr3d[0]); + } + + { + multi_span<int, 3, 2, 2> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + auto workaround_macro = [&]() { return s[{2, 1, 0}] == 11; }; + CHECK(workaround_macro()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 3, 3, 3> s{arr3d}; +#endif + } + } + + TEST(from_dynamic_array_constructor) + { + double(*arr)[3][4] = new double[100][3][4]; + + { + multi_span<double, dynamic_range, 3, 4> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + CHECK_THROW(s[10][3][4], fail_fast); + } + + { + multi_span<double, dynamic_range, 4, 3> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + multi_span<double> s(arr, 10); + CHECK(s.length() == 120 && s.data() == &arr[0][0][0]); + } + + { + multi_span<double, dynamic_range, 3, 4> s(arr, 0); + CHECK(s.length() == 0 && s.data() == &arr[0][0][0]); + } + + delete[] arr; + } + + TEST(from_std_array_constructor) + { + std::array<int, 4> arr = {1, 2, 3, 4}; + + { + multi_span<int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + multi_span<const int> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + + { + multi_span<int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + multi_span<const int, 4> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + + { + multi_span<int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + + multi_span<const int, 2> cs{arr}; + CHECK(cs.size() == 2 && cs.data() == arr.data()); + } + + { + multi_span<int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + + multi_span<const int, 0> cs{arr}; + CHECK(cs.size() == 0 && cs.data() == arr.data()); + } + + // TODO This is currently an unsupported scenario. We will come back to it as we revise + // the multidimensional interface and what transformations between dimensionality look like + //{ + // multi_span<int, 2, 2> s{arr}; + // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 5> s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() { return std::array<int, 4>{1, 2, 3, 4}; }; + auto take_a_span = [](multi_span<int> s) { (void) s; }; + // try to take a temporary std::array + take_a_span(get_an_array()); +#endif + } + } + + TEST(from_const_std_array_constructor) + { + const std::array<int, 4> arr = {1, 2, 3, 4}; + + { + multi_span<const int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + multi_span<const int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + multi_span<const int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + multi_span<const int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + } + + // TODO This is currently an unsupported scenario. We will come back to it as we revise + // the multidimensional interface and what transformations between dimensionality look like + //{ + // multi_span<int, 2, 2> s{arr}; + // CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + //} + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<const int, 5> s{arr}; +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; }; + auto take_a_span = [](multi_span<const int> s) { (void) s; }; + // try to take a temporary std::array + take_a_span(get_an_array()); +#endif + } + } + + TEST(from_container_constructor) + { + std::vector<int> v = {1, 2, 3}; + const std::vector<int> cv = v; + + { + multi_span<int> s{v}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()); + + multi_span<const int> cs{v}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data()); + } + + std::string str = "hello"; + const std::string cstr = "hello"; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<char> s{str}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data()); +#endif + multi_span<const char> cs{str}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<char> s{cstr}; +#endif + multi_span<const char> cs{cstr}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) && + cs.data() == cstr.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> std::vector<int> { return {}; }; + auto use_span = [](multi_span<int> s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> std::string { return {}; }; + auto use_span = [](multi_span<char> s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> const std::vector<int> { return {}; }; + auto use_span = [](multi_span<const char> s) { (void) s; }; + use_span(get_temp_vector()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> const std::string { return {}; }; + auto use_span = [](multi_span<const char> s) { (void) s; }; + use_span(get_temp_string()); +#endif + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::map<int, int> m; + multi_span<int> s{m}; +#endif + } + } + + TEST(from_convertible_span_constructor) + { +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<int, 7, 4, 2> av1(nullptr, b1); + + auto f = [&]() { multi_span<int, 7, 4, 2> av1(nullptr); }; + CHECK_THROW(f(), fail_fast); +#endif + +#ifdef CONFIRM_COMPILATION_ERRORS + static_bounds<size_t, 7, dynamic_range, 2> b12(b11); + b12 = b11; + b11 = b12; + + multi_span<int, dynamic_range> av1 = nullptr; + multi_span<int, 7, dynamic_range, 2> av2(av1); + multi_span<int, 7, 4, 2> av2(av1); +#endif + + multi_span<DerivedClass> avd; +#ifdef CONFIRM_COMPILATION_ERRORS + multi_span<BaseClass> avb = avd; +#endif + multi_span<const DerivedClass> avcd = avd; + (void) avcd; + } + + TEST(copy_move_and_assignment) + { + multi_span<int> s1; + CHECK(s1.empty()); + + int arr[] = {3, 4, 5}; + + multi_span<const int> s2 = arr; + CHECK(s2.length() == 3 && s2.data() == &arr[0]); + + s2 = s1; + CHECK(s2.empty()); + + auto get_temp_span = [&]() -> multi_span<int> { return {&arr[1], 2}; }; + auto use_span = [&](multi_span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); }; + use_span(get_temp_span()); + + s1 = get_temp_span(); + CHECK(s1.length() == 2 && s1.data() == &arr[1]); + } + + template <class Bounds> + void fn(const Bounds&) + { + static_assert(Bounds::static_size == 60, "static bounds is wrong size"); + } + TEST(as_multi_span_reshape) + { + int a[3][4][5]; + auto av = as_multi_span(a); + fn(av.bounds()); + auto av2 = as_multi_span(av, dim<60>()); + auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>()); + auto av4 = as_multi_span(av3, dim<4>(), dim(3), dim<5>()); + auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>()); + auto av6 = as_multi_span(av5, dim<12>(), dim(5)); + + fill(av6.begin(), av6.end(), 1); + + auto av7 = as_bytes(av6); + + auto av8 = as_multi_span<int>(av7); + + CHECK(av8.size() == av6.size()); + for (auto i = 0; i < av8.size(); i++) { + CHECK(av8[i] == 1); + } + } + + TEST(first) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.first<2>().bounds() == static_bounds<2>())); + CHECK(av.first<2>().length() == 2); + CHECK(av.first(2).length() == 2); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.first<0>().bounds() == static_bounds<0>())); + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.first<5>().bounds() == static_bounds<5>())); + CHECK(av.first<5>().length() == 5); + CHECK(av.first(5).length() == 5); + } + + { + multi_span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(av.first<6>().bounds() == static_bounds<6>()); + CHECK(av.first<6>().length() == 6); + CHECK(av.first<-1>().length() == -1); +#endif + CHECK_THROW(av.first(6).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.first<0>().bounds() == static_bounds<0>())); + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + } + + TEST(last) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.last<2>().bounds() == static_bounds<2>())); + CHECK(av.last<2>().length() == 2); + CHECK(av.last(2).length() == 2); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.last<0>().bounds() == static_bounds<0>())); + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.last<5>().bounds() == static_bounds<5>())); + CHECK(av.last<5>().length() == 5); + CHECK(av.last(5).length() == 5); + } + + { + multi_span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK((av.last<6>().bounds() == static_bounds<6>())); + CHECK(av.last<6>().length() == 6); +#endif + CHECK_THROW(av.last(6).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.last<0>().bounds() == static_bounds<0>())); + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + } + + TEST(subspan) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<2, 2>().bounds() == static_bounds<2>())); + CHECK((av.subspan<2, 2>().length() == 2)); + CHECK(av.subspan(2, 2).length() == 2); + CHECK(av.subspan(2, 3).length() == 3); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<0, 5>().bounds() == static_bounds<5>())); + CHECK((av.subspan<0, 5>().length() == 5)); + CHECK(av.subspan(0, 5).length() == 5); + CHECK_THROW(av.subspan(0, 6).length(), fail_fast); + CHECK_THROW(av.subspan(1, 5).length(), fail_fast); + } + + { + multi_span<int, 5> av = arr; + CHECK((av.subspan<5, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<5, 0>().length() == 0)); + CHECK(av.subspan(5, 0).length() == 0); + CHECK_THROW(av.subspan(6, 0).length(), fail_fast); + } + + { + multi_span<int, dynamic_range> av; + CHECK((av.subspan<0, 0>().bounds() == static_bounds<0>())); + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + CHECK_THROW((av.subspan<1, 0>().length()), fail_fast); + } + + { + multi_span<int> av; + CHECK(av.subspan(0).length() == 0); + CHECK_THROW(av.subspan(1).length(), fail_fast); + } + + { + multi_span<int> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + + { + multi_span<int, 5> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + } + + TEST(rank) + { + int arr[2] = {1, 2}; + + { + multi_span<int> s; + CHECK(s.rank() == 1); + } + + { + multi_span<int, 2> s = arr; + CHECK(s.rank() == 1); + } + + int arr2d[1][1] = {}; + { + multi_span<int, 1, 1> s = arr2d; + CHECK(s.rank() == 2); + } + } + + TEST(extent) + { + { + multi_span<int> s; + CHECK(s.extent() == 0); + CHECK(s.extent(0) == 0); + CHECK_THROW(s.extent(1), fail_fast); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(s.extent<1>() == 0); +#endif + } + + { + multi_span<int, 0> s; + CHECK(s.extent() == 0); + CHECK(s.extent(0) == 0); + CHECK_THROW(s.extent(1), fail_fast); + } + + { + int arr2d[1][2] = {}; + + multi_span<int, 1, 2> s = arr2d; + CHECK(s.extent() == 1); + CHECK(s.extent<0>() == 1); + CHECK(s.extent<1>() == 2); + CHECK(s.extent(0) == 1); + CHECK(s.extent(1) == 2); + CHECK_THROW(s.extent(3), fail_fast); + } + + { + int arr2d[1][2] = {}; + + multi_span<int, 0, 2> s = arr2d; + CHECK(s.extent() == 0); + CHECK(s.extent<0>() == 0); + CHECK(s.extent<1>() == 2); + CHECK(s.extent(0) == 0); + CHECK(s.extent(1) == 2); + CHECK_THROW(s.extent(3), fail_fast); + } + } + + TEST(operator_function_call) + { + int arr[4] = {1, 2, 3, 4}; + + { + multi_span<int> s = arr; + CHECK(s(0) == 1); + CHECK_THROW(s(5), fail_fast); + } + + int arr2d[2][3] = {1, 2, 3, 4, 5, 6}; + + { + multi_span<int, 2, 3> s = arr2d; + CHECK(s(0, 0) == 1); + CHECK(s(1, 2) == 6); + } + } + + TEST(comparison_operators) + { + { + int arr[10][2]; + auto s1 = as_multi_span(arr); + multi_span<const int, dynamic_range, 2> s2 = s1; + + CHECK(s1 == s2); + + multi_span<int, 20> s3 = as_multi_span(s1, dim(20)); + CHECK(s3 == s2 && s3 == s1); + } + + { + multi_span<int> s1 = nullptr; + multi_span<int> s2 = nullptr; + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {2, 1}; // bigger + + multi_span<int> s1 = nullptr; + multi_span<int> s2 = arr; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; + int arr2[] = {1, 2}; + multi_span<int> s1 = arr1; + multi_span<int> s2 = arr2; + + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {1, 2, 3}; + + multi_span<int> s1 = {&arr[0], 2}; // shorter + multi_span<int> s2 = arr; // longer + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; // smaller + int arr2[] = {2, 1}; // bigger + + multi_span<int> s1 = arr1; + multi_span<int> s2 = arr2; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + } + + TEST(basics) + { + auto ptr = as_multi_span(new int[10], 10); + fill(ptr.begin(), ptr.end(), 99); + for (int num : ptr) { + CHECK(num == 99); + } + + delete[] ptr.data(); + } + + TEST(bounds_checks) + { + int arr[10][2]; + auto av = as_multi_span(arr); + + fill(begin(av), end(av), 0); + + av[2][0] = 1; + av[1][1] = 3; + + // out of bounds + CHECK_THROW(av[1][3] = 3, fail_fast); + CHECK_THROW((av[{1, 3}] = 3), fail_fast); + + CHECK_THROW(av[10][2], fail_fast); + CHECK_THROW((av[{10, 2}]), fail_fast); + + CHECK_THROW(av[-1][0], fail_fast); + CHECK_THROW((av[{-1, 0}]), fail_fast); + + CHECK_THROW(av[0][-1], fail_fast); + CHECK_THROW((av[{0, -1}]), fail_fast); + } + + void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void overloaded_func(multi_span<const char, dynamic_range, 3, 5> exp, char expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + void fixed_func(multi_span<int, 3, 3, 5> exp, int expected_value) + { + for (auto val : exp) { + CHECK(val == expected_value); + } + } + + TEST(span_parameter_test) + { + auto data = new int[4][3][5]; + + auto av = as_multi_span(data, 4); + + CHECK(av.size() == 60); + + fill(av.begin(), av.end(), 34); + + int count = 0; + for_each(av.rbegin(), av.rend(), [&](int val) { count += val; }); + CHECK(count == 34 * 60); + overloaded_func(av, 34); + + overloaded_func(as_multi_span(av, dim(4), dim(3), dim(5)), 34); + + // fixed_func(av, 34); + delete[] data; + } + + TEST(md_access) + { + auto width = 5, height = 20; + + auto imgSize = width * height; + auto image_ptr = new int[imgSize][3]; + + // size check will be done + auto image_view = + as_multi_span(as_multi_span(image_ptr, imgSize), dim(height), dim(width), dim<3>()); + + iota(image_view.begin(), image_view.end(), 1); + + int expected = 0; + for (auto i = 0; i < height; i++) { + for (auto j = 0; j < width; j++) { + CHECK(expected + 1 == image_view[i][j][0]); + CHECK(expected + 2 == image_view[i][j][1]); + CHECK(expected + 3 == image_view[i][j][2]); + + auto val = image_view[{i, j, 0}]; + CHECK(expected + 1 == val); + val = image_view[{i, j, 1}]; + CHECK(expected + 2 == val); + val = image_view[{i, j, 2}]; + CHECK(expected + 3 == val); + + expected += 3; + } + } + } + + TEST(as_multi_span) + { + { + int* arr = new int[150]; + + auto av = as_multi_span(arr, dim<10>(), dim(3), dim<5>()); + + fill(av.begin(), av.end(), 24); + overloaded_func(av, 24); + + delete[] arr; + + array<int, 15> stdarr{0}; + auto av2 = as_multi_span(stdarr); + overloaded_func(as_multi_span(av2, dim(1), dim<3>(), dim<5>()), 0); + + string str = "ttttttttttttttt"; // size = 15 + auto t = str.data(); + (void) t; + auto av3 = as_multi_span(str); + overloaded_func(as_multi_span(av3, dim(1), dim<3>(), dim<5>()), 't'); + } + + { + string str; + multi_span<char> strspan = as_multi_span(str); + (void) strspan; + const string cstr; + multi_span<const char> cstrspan = as_multi_span(cstr); + (void) cstrspan; + } + + { + int a[3][4][5]; + auto av = as_multi_span(a); + const int(*b)[4][5]; + b = a; + auto bv = as_multi_span(b, 3); + + CHECK(av == bv); + + const std::array<double, 3> arr = {0.0, 0.0, 0.0}; + auto cv = as_multi_span(arr); + (void) cv; + + vector<float> vec(3); + auto dv = as_multi_span(vec); + (void) dv; + +#ifdef CONFIRM_COMPILATION_ERRORS + auto dv2 = as_multi_span(std::move(vec)); +#endif + } + } + + TEST(empty_spans) + { + { + multi_span<int, 0> empty_av(nullptr); + + CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK_THROW(empty_av[0], fail_fast); + CHECK_THROW(empty_av.begin()[0], fail_fast); + CHECK_THROW(empty_av.cbegin()[0], fail_fast); + for (auto& v : empty_av) { + (void) v; + CHECK(false); + } + } + + { + multi_span<int> empty_av = {}; + CHECK(empty_av.bounds().index_bounds() == index<1>{0}); + CHECK_THROW(empty_av[0], fail_fast); + CHECK_THROW(empty_av.begin()[0], fail_fast); + CHECK_THROW(empty_av.cbegin()[0], fail_fast); + for (auto& v : empty_av) { + (void) v; + CHECK(false); + } + } + } + + TEST(index_constructor) + { + auto arr = new int[8]; + for (int i = 0; i < 4; ++i) { + arr[2 * i] = 4 + i; + arr[2 * i + 1] = i; + } + + multi_span<int, dynamic_range> av(arr, 8); + + ptrdiff_t a[1] = {0}; + index<1> i = a; + + CHECK(av[i] == 4); + + auto av2 = as_multi_span(av, dim<4>(), dim(2)); + ptrdiff_t a2[2] = {0, 1}; + index<2> i2 = a2; + + CHECK(av2[i2] == 0); + CHECK(av2[0][i] == 4); + + delete[] arr; + } + + TEST(index_constructors) + { + { + // components of the same type + index<3> i1(0, 1, 2); + CHECK(i1[0] == 0); + + // components of different types + size_t c0 = 0; + size_t c1 = 1; + index<3> i2(c0, c1, 2); + CHECK(i2[0] == 0); + + // from array + index<3> i3 = {0, 1, 2}; + CHECK(i3[0] == 0); + + // from other index of the same size type + index<3> i4 = i3; + CHECK(i4[0] == 0); + + // default + index<3> i7; + CHECK(i7[0] == 0); + + // default + index<3> i9 = {}; + CHECK(i9[0] == 0); + } + + { + // components of the same type + index<1> i1(0); + CHECK(i1[0] == 0); + + // components of different types + size_t c0 = 0; + index<1> i2(c0); + CHECK(i2[0] == 0); + + // from array + index<1> i3 = {0}; + CHECK(i3[0] == 0); + + // from int + index<1> i4 = 0; + CHECK(i4[0] == 0); + + // from other index of the same size type + index<1> i5 = i3; + CHECK(i5[0] == 0); + + // default + index<1> i8; + CHECK(i8[0] == 0); + + // default + index<1> i9 = {}; + CHECK(i9[0] == 0); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + index<3> i1(0, 1); + index<3> i2(0, 1, 2, 3); + index<3> i3 = {0}; + index<3> i4 = {0, 1, 2, 3}; + index<1> i5 = {0, 1}; + } +#endif + } + + TEST(index_operations) + { + ptrdiff_t a[3] = {0, 1, 2}; + ptrdiff_t b[3] = {3, 4, 5}; + index<3> i = a; + index<3> j = b; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + + { + index<3> k = i + j; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 3); + CHECK(k[1] == 5); + CHECK(k[2] == 7); + } + + { + index<3> k = i * 3; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 0); + CHECK(k[1] == 3); + CHECK(k[2] == 6); + } + + { + index<3> k = 3 * i; + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 0); + CHECK(k[1] == 3); + CHECK(k[2] == 6); + } + + { + index<2> k = details::shift_left(i); + + CHECK(i[0] == 0); + CHECK(i[1] == 1); + CHECK(i[2] == 2); + CHECK(k[0] == 1); + CHECK(k[1] == 2); + } + } + + void iterate_second_column(multi_span<int, dynamic_range, dynamic_range> av) + { + auto length = av.size() / 2; + + // view to the second column + auto section = av.section({0, 1}, {length, 1}); + + CHECK(section.size() == length); + for (auto i = 0; i < section.size(); ++i) { + CHECK(section[i][0] == av[i][1]); + } + + for (auto i = 0; i < section.size(); ++i) { + auto idx = index<2>{i, 0}; // avoid braces inside the CHECK macro + CHECK(section[idx] == av[i][1]); + } + + CHECK(section.bounds().index_bounds()[0] == length); + CHECK(section.bounds().index_bounds()[1] == 1); + for (auto i = 0; i < section.bounds().index_bounds()[0]; ++i) { + for (auto j = 0; j < section.bounds().index_bounds()[1]; ++j) { + auto idx = index<2>{i, j}; // avoid braces inside the CHECK macro + CHECK(section[idx] == av[i][1]); + } + } + + size_t check_sum = 0; + for (auto i = 0; i < length; ++i) { + check_sum += av[i][1]; + } + + { + auto idx = 0; + size_t sum = 0; + for (auto num : section) { + CHECK(num == av[idx][1]); + sum += num; + idx++; + } + + CHECK(sum == check_sum); + } + { + size_t idx = length - 1; + size_t sum = 0; + for (auto iter = section.rbegin(); iter != section.rend(); ++iter) { + CHECK(*iter == av[idx][1]); + sum += *iter; + idx--; + } + + CHECK(sum == check_sum); + } + } + + TEST(span_section_iteration) + { + int arr[4][2] = {{4, 0}, {5, 1}, {6, 2}, {7, 3}}; + + // static bounds + { + multi_span<int, 4, 2> av = arr; + iterate_second_column(av); + } + // first bound is dynamic + { + multi_span<int, dynamic_range, 2> av = arr; + iterate_second_column(av); + } + // second bound is dynamic + { + multi_span<int, 4, dynamic_range> av = arr; + iterate_second_column(av); + } + // both bounds are dynamic + { + multi_span<int, dynamic_range, dynamic_range> av = arr; + iterate_second_column(av); + } + } + + TEST(dynamic_span_section_iteration) + { + auto height = 4, width = 2; + auto size = height * width; + + auto arr = new int[size]; + for (auto i = 0; i < size; ++i) { + arr[i] = i; + } + + auto av = as_multi_span(arr, size); + + // first bound is dynamic + { + multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim(height), dim(width)); + iterate_second_column(av2); + } + // second bound is dynamic + { + multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim(height), dim(width)); + iterate_second_column(av2); + } + // both bounds are dynamic + { + multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim(height), dim(width)); + iterate_second_column(av2); + } + + delete[] arr; + } + + TEST(span_structure_size) + { + double(*arr)[3][4] = new double[100][3][4]; + multi_span<double, dynamic_range, 3, 4> av1(arr, 10); + + struct EffectiveStructure + { + double* v1; + ptrdiff_t v2; + }; + CHECK(sizeof(av1) == sizeof(EffectiveStructure)); + + CHECK_THROW(av1[10][3][4], fail_fast); + + multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim(5), dim<6>(), dim<4>()); + (void) av2; + } + + TEST(fixed_size_conversions) + { + int arr[] = {1, 2, 3, 4}; + + // converting to an multi_span from an equal size array is ok + multi_span<int, 4> av4 = arr; + CHECK(av4.length() == 4); + + // converting to dynamic_range a_v is always ok + { + multi_span<int, dynamic_range> av = av4; + (void) av; + } + { + multi_span<int, dynamic_range> av = arr; + (void) av; + } + +// initialization or assignment to static multi_span that REDUCES size is NOT ok +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, 2> av2 = arr; + } + { + multi_span<int, 2> av2 = av4; + } +#endif + + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2> av2 = av; + (void) av2; + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2, 1> av2 = av.as_multi_span(dim<2>(), dim<2>()); + } +#endif + + { + multi_span<int, dynamic_range> av = arr; + multi_span<int, 2, 1> av2 = as_multi_span(av, dim(2), dim(2)); + auto workaround_macro = [&]() { return av2[{1, 0}] == 2; }; + CHECK(workaround_macro()); + } + + // but doing so explicitly is ok + + // you can convert statically + { + multi_span<int, 2> av2 = {arr, 2}; + (void) av2; + } + { + multi_span<int, 1> av2 = av4.first<1>(); + (void) av2; + } + + // ...or dynamically + { + // NB: implicit conversion to multi_span<int,2> from multi_span<int,dynamic_range> + multi_span<int, 1> av2 = av4.first(1); + (void) av2; + } + + // initialization or assignment to static multi_span that requires size INCREASE is not ok. + int arr2[2] = {1, 2}; + +#ifdef CONFIRM_COMPILATION_ERRORS + { + multi_span<int, 4> av4 = arr2; + } + { + multi_span<int, 2> av2 = arr2; + multi_span<int, 4> av4 = av2; + } +#endif + { + auto f = [&]() { + multi_span<int, 4> av9 = {arr2, 2}; + (void) av9; + }; + CHECK_THROW(f(), fail_fast); + } + + // this should fail - we are trying to assign a small dynamic a_v to a fixed_size larger one + multi_span<int, dynamic_range> av = arr2; + auto f = [&]() { + multi_span<int, 4> av2 = av; + (void) av2; + }; + CHECK_THROW(f(), fail_fast); + } + + TEST(as_writeable_bytes) + { + int a[] = {1, 2, 3, 4}; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + // you should not be able to get writeable bytes for const objects + multi_span<const int, dynamic_range> av = a; + auto wav = av.as_writeable_bytes(); +#endif + } + + { + multi_span<int, dynamic_range> av; + auto wav = as_writeable_bytes(av); + CHECK(wav.length() == av.length()); + CHECK(wav.length() == 0); + CHECK(wav.size_bytes() == 0); + } + + { + multi_span<int, dynamic_range> av = a; + auto wav = as_writeable_bytes(av); + CHECK(wav.data() == (byte*) &a[0]); + CHECK(wav.length() == sizeof(a)); + } + } + + TEST(iterator) + { + int a[] = {1, 2, 3, 4}; + + { + multi_span<int, dynamic_range> av = a; + auto wav = as_writeable_bytes(av); + for (auto& b : wav) { + b = byte(0); + } + for (size_t i = 0; i < 4; ++i) { + CHECK(a[i] == 0); + } + } + + { + multi_span<int, dynamic_range> av = a; + for (auto& n : av) { + n = 1; + } + for (size_t i = 0; i < 4; ++i) { + CHECK(a[i] == 1); + } + } + } +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/notnull_tests.cpp b/tests/notnull_tests.cpp new file mode 100644 index 0000000..526b074 --- /dev/null +++ b/tests/notnull_tests.cpp @@ -0,0 +1,103 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl> +#include <vector> + +using namespace gsl; + +struct MyBase {}; +struct MyDerived : public MyBase {}; +struct Unrelated {}; + +// stand-in for a user-defined ref-counted class +template<typename T> +struct RefCounted +{ + RefCounted(T* p) : p_(p) {} + operator T*() { return p_; } + T* p_; +}; + +SUITE(NotNullTests) +{ + + bool helper(not_null<int*> p) + { + return *p == 12; + } + + TEST(TestNotNullConstructors) + { +#ifdef CONFIRM_COMPILATION_ERRORS + not_null<int*> p = nullptr; // yay...does not compile! + not_null<std::vector<char>*> p = 0; // yay...does not compile! + not_null<int*> p; // yay...does not compile! + std::unique_ptr<int> up = std::make_unique<int>(120); + not_null<int*> p = up; + + // Forbid non-nullptr assignable types + not_null<std::vector<int>> f(std::vector<int>{1}); + not_null<int> z(10); + not_null<std::vector<int>> y({1,2}); +#endif + int i = 12; + auto rp = RefCounted<int>(&i); + not_null<int*> p(rp); + CHECK(p.get() == &i); + + not_null<std::shared_ptr<int>> x(std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable + } + + TEST(TestNotNullCasting) + { + MyBase base; + MyDerived derived; + Unrelated unrelated; + not_null<Unrelated*> u = &unrelated; + (void)u; + not_null<MyDerived*> p = &derived; + not_null<MyBase*> q = &base; + q = p; // allowed with heterogeneous copy ctor + CHECK(q == p); + +#ifdef CONFIRM_COMPILATION_ERRORS + q = u; // no viable conversion possible between MyBase* and Unrelated* + p = q; // not possible to implicitly convert MyBase* to MyDerived* + + not_null<Unrelated*> r = p; + not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p); +#endif + not_null<Unrelated*> t = reinterpret_cast<Unrelated*>(p.get()); + CHECK((void*)p.get() == (void*)t.get()); + } + + TEST(TestNotNullAssignment) + { + int i = 12; + not_null<int*> p = &i; + CHECK(helper(p)); + + int* q = nullptr; + CHECK_THROW(p = q, fail_fast); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/owner_tests.cpp b/tests/owner_tests.cpp new file mode 100644 index 0000000..6680981 --- /dev/null +++ b/tests/owner_tests.cpp @@ -0,0 +1,43 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl> +#include <functional> + +using namespace gsl; + +SUITE(owner_tests) +{ + void f(int* i) + { + *i += 1; + } + + TEST(basic_test) + { + owner<int*> p = new int(120); + CHECK(*p == 120); + f(p); + CHECK(*p == 121); + delete p; + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp new file mode 100644 index 0000000..35e6b03 --- /dev/null +++ b/tests/span_tests.cpp @@ -0,0 +1,1385 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/span> + +#include <iostream> +#include <list> +#include <map> +#include <memory> +#include <string> +#include <vector> +#include <regex> + +using namespace std; +using namespace gsl; + +namespace +{ +struct BaseClass +{ +}; +struct DerivedClass : BaseClass +{ +}; +} + +SUITE(span_tests) +{ + TEST(default_constructor) + { + { + span<int> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span<int, 0> s; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int, 0> cs; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<int, 1> s; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + span<int> s{}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int> cs{}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(size_optimization) + { + { + span<int> s; + CHECK(sizeof(s) == sizeof(int*) + sizeof(ptrdiff_t)); + } + + { + span<int, 0> s; + CHECK(sizeof(s) == sizeof(int*)); + } + } + + TEST(from_nullptr_constructor) + { + { + span<int> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span<int, 0> s = nullptr; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int, 0> cs = nullptr; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<int, 1> s = nullptr; + CHECK(s.length() == 1 && s.data() == nullptr); // explains why it can't compile +#endif + } + + { + span<int> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span<int*> s{nullptr}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int*> cs{nullptr}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_nullptr_length_constructor) + { + { + span<int> s{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int> cs{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + span<int, 0> s{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int, 0> cs{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + + { + auto workaround_macro = []() { span<int, 1> s{ nullptr, static_cast<span<int>::index_type>(0) }; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + { + auto workaround_macro = []() { span<int> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { span<const int> cs{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + auto workaround_macro = []() { span<int, 0> s{nullptr, 1}; }; + CHECK_THROW(workaround_macro(), fail_fast); + + auto const_workaround_macro = []() { span<const int, 0> s{nullptr, 1}; }; + CHECK_THROW(const_workaround_macro(), fail_fast); + } + + { + span<int*> s{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(s.length() == 0 && s.data() == nullptr); + + span<const int*> cs{nullptr, static_cast<span<int>::index_type>(0)}; + CHECK(cs.length() == 0 && cs.data() == nullptr); + } + } + + TEST(from_pointer_length_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + span<int> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span<int, 2> s{&arr[0], 2}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + int* p = nullptr; + span<int> s{p, static_cast<span<int>::index_type>(0)}; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + { + int* p = nullptr; + auto workaround_macro = [=]() { span<int> s{p, 2}; }; + CHECK_THROW(workaround_macro(), fail_fast); + } + } + + TEST(from_pointer_pointer_constructor) + { + int arr[4] = {1, 2, 3, 4}; + + { + span<int> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span<int, 2> s{&arr[0], &arr[2]}; + CHECK(s.length() == 2 && s.data() == &arr[0]); + CHECK(s[0] == 1 && s[1] == 2); + } + + { + span<int> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + span<int, 0> s{&arr[0], &arr[0]}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} + + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // int* p = nullptr; + // auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} + + { + int* p = nullptr; + span<int> s{ p, p }; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + { + int* p = nullptr; + span<int, 0> s{ p, p }; + CHECK(s.length() == 0 && s.data() == nullptr); + } + + // this will fail the std::distance() precondition, which asserts on MSVC debug builds + //{ + // int* p = nullptr; + // auto workaround_macro = [&]() { span<int> s{&arr[0], p}; }; + // CHECK_THROW(workaround_macro(), fail_fast); + //} + } + + TEST(from_array_constructor) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + span<int> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + { + span<int, 5> s{arr}; + CHECK(s.length() == 5 && s.data() == &arr[0]); + } + + int arr2d[2][3] = { 1, 2, 3, 4, 5, 6 }; + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int, 6> s{arr}; + } + + { + span<int, 0> s{arr}; + CHECK(s.length() == 0 && s.data() == &arr[0]); + } + + { + span<int> s{arr2d}; + CHECK(s.length() == 6 && s.data() == &arr2d[0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } + + { + span<int, 0> s{arr2d}; + CHECK(s.length() == 0 && s.data() == &arr2d[0][0]); + } + + { + span<int, 6> s{ arr2d }; + } +#endif + { + span<int[3]> s{ &(arr2d[0]), 1 }; + CHECK(s.length() == 1 && s.data() == &arr2d[0]); + } + + int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[11] == 12); + } + + { + span<int, 0> s{arr3d}; + CHECK(s.length() == 0 && s.data() == &arr3d[0][0][0]); + } + + { + span<int, 11> s{arr3d}; + } + + { + span<int, 12> s{arr3d}; + CHECK(s.length() == 12 && s.data() == &arr3d[0][0][0]); + CHECK(s[0] == 1 && s[5] == 6); + } +#endif + { + span<int[3][2]> s{&arr3d[0], 1}; + CHECK(s.length() == 1 && s.data() == &arr3d[0]); + } + } + + TEST(from_dynamic_array_constructor) + { + double(*arr)[3][4] = new double[100][3][4]; + + { + span<double> s(&arr[0][0][0], 10); + CHECK(s.length() == 10 && s.data() == &arr[0][0][0]); + } + + delete[] arr; + } + + TEST(from_std_array_constructor) + { + std::array<int, 4> arr = {1, 2, 3, 4}; + + { + span<int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + span<const int> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + + { + span<int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + + span<const int, 4> cs{arr}; + CHECK(cs.size() == narrow_cast<ptrdiff_t>(arr.size()) && cs.data() == arr.data()); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + + span<const int, 2> cs{arr}; + CHECK(cs.size() == 2 && cs.data() == arr.data()); + } + + { + span<int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + + span<const int, 0> cs{arr}; + CHECK(cs.size() == 0 && cs.data() == arr.data()); + } + + { + span<int, 5> s{arr}; + } + + { + auto get_an_array = []()->std::array<int, 4> { return{1, 2, 3, 4}; }; + auto take_a_span = [](span<int> s) { static_cast<void>(s); }; + // try to take a temporary std::array + take_a_span(get_an_array()); + } +#endif + + { + auto get_an_array = []() -> std::array<int, 4> { return { 1, 2, 3, 4 }; }; + auto take_a_span = [](span<const int> s) { static_cast<void>(s); }; + // try to take a temporary std::array + take_a_span(get_an_array()); + } + } + + TEST(from_const_std_array_constructor) + { + const std::array<int, 4> arr = {1, 2, 3, 4}; + + { + span<const int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + span<const int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<const int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + span<const int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + } + + { + span<const int, 5> s{arr}; + } +#endif + + { + auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; }; + auto take_a_span = [](span<const int> s) { static_cast<void>(s); }; + // try to take a temporary std::array + take_a_span(get_an_array()); + } + } + + TEST(from_std_array_const_constructor) + { + std::array<const int, 4> arr = {1, 2, 3, 4}; + + { + span<const int> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + + { + span<const int, 4> s{arr}; + CHECK(s.size() == narrow_cast<ptrdiff_t>(arr.size()) && s.data() == arr.data()); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<const int, 2> s{arr}; + CHECK(s.size() == 2 && s.data() == arr.data()); + } + + { + span<const int, 0> s{arr}; + CHECK(s.size() == 0 && s.data() == arr.data()); + } + + { + span<const int, 5> s{arr}; + } + + { + span<int, 4> s{arr}; + } +#endif + } + + TEST(from_container_constructor) + { + std::vector<int> v = {1, 2, 3}; + const std::vector<int> cv = v; + + { + span<int> s{v}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(v.size()) && s.data() == v.data()); + + span<const int> cs{v}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(v.size()) && cs.data() == v.data()); + } + + std::string str = "hello"; + const std::string cstr = "hello"; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<char> s{str}; + CHECK(s.size() == narrow_cast<std::ptrdiff_t>(str.size()) && s.data() == str.data()); +#endif + span<const char> cs{str}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(str.size()) && cs.data() == str.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<char> s{cstr}; +#endif + span<const char> cs{cstr}; + CHECK(cs.size() == narrow_cast<std::ptrdiff_t>(cstr.size()) && + cs.data() == cstr.data()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> std::vector<int> { return {}; }; + auto use_span = [](span<int> s) { static_cast<void>(s); }; + use_span(get_temp_vector()); +#endif + } + + { + auto get_temp_vector = []() -> std::vector<int> { return{}; }; + auto use_span = [](span<const int> s) { static_cast<void>(s); }; + use_span(get_temp_vector()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_string = []() -> std::string { return{}; }; + auto use_span = [](span<char> s) { static_cast<void>(s); }; + use_span(get_temp_string()); +#endif + } + + { + auto get_temp_string = []() -> std::string { return {}; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; + use_span(get_temp_string()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + auto get_temp_vector = []() -> const std::vector<int> { return {}; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; + use_span(get_temp_vector()); +#endif + } + + { + auto get_temp_string = []() -> const std::string { return {}; }; + auto use_span = [](span<const char> s) { static_cast<void>(s); }; + use_span(get_temp_string()); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::map<int, int> m; + span<int> s{m}; +#endif + } + } + + TEST(from_convertible_span_constructor) + { + { + span<DerivedClass> avd; + span<const DerivedClass> avcd = avd; + static_cast<void>(avcd); + } + + { +#ifdef CONFIRM_COMPILATION_ERRORS + span<DerivedClass> avd; + span<BaseClass> avb = avd; + static_cast<void>(avb); +#endif + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int> s; + span<unsigned int> s2 = s; + static_cast<void>(s2); + } + + { + span<int> s; + span<const unsigned int> s2 = s; + static_cast<void>(s2); + } + + { + span<int> s; + span<short> s2 = s; + static_cast<void>(s2); + } +#endif + } + + TEST(copy_move_and_assignment) + { + span<int> s1; + CHECK(s1.empty()); + + int arr[] = {3, 4, 5}; + + span<const int> s2 = arr; + CHECK(s2.length() == 3 && s2.data() == &arr[0]); + + s2 = s1; + CHECK(s2.empty()); + + auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; }; + auto use_span = [&](span<const int> s) { CHECK(s.length() == 2 && s.data() == &arr[1]); }; + use_span(get_temp_span()); + + s1 = get_temp_span(); + CHECK(s1.length() == 2 && s1.data() == &arr[1]); + } + + TEST(first) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + span<int, 5> av = arr; + CHECK(av.first<2>().length() == 2); + CHECK(av.first(2).length() == 2); + } + + { + span<int, 5> av = arr; + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + + { + span<int, 5> av = arr; + CHECK(av.first<5>().length() == 5); + CHECK(av.first(5).length() == 5); + } + + { + span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(av.first<6>().length() == 6); + CHECK(av.first<-1>().length() == -1); +#endif + CHECK_THROW(av.first(6).length(), fail_fast); + } + + { + span<int> av; + CHECK(av.first<0>().length() == 0); + CHECK(av.first(0).length() == 0); + } + } + + TEST(last) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + span<int, 5> av = arr; + CHECK(av.last<2>().length() == 2); + CHECK(av.last(2).length() == 2); + } + + { + span<int, 5> av = arr; + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + + { + span<int, 5> av = arr; + CHECK(av.last<5>().length() == 5); + CHECK(av.last(5).length() == 5); + } + + { + span<int, 5> av = arr; +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(av.last<6>().length() == 6); +#endif + CHECK_THROW(av.last(6).length(), fail_fast); + } + + { + span<int> av; + CHECK(av.last<0>().length() == 0); + CHECK(av.last(0).length() == 0); + } + } + + TEST(subspan) + { + int arr[5] = {1, 2, 3, 4, 5}; + + { + span<int, 5> av = arr; + CHECK((av.subspan<2, 2>().length() == 2)); + CHECK(av.subspan(2, 2).length() == 2); + CHECK(av.subspan(2, 3).length() == 3); + } + + { + span<int, 5> av = arr; + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + } + + { + span<int, 5> av = arr; + CHECK((av.subspan<0, 5>().length() == 5)); + CHECK(av.subspan(0, 5).length() == 5); + CHECK_THROW(av.subspan(0, 6).length(), fail_fast); + CHECK_THROW(av.subspan(1, 5).length(), fail_fast); + } + + { + span<int, 5> av = arr; + CHECK((av.subspan<4, 0>().length() == 0)); + CHECK(av.subspan(4, 0).length() == 0); + CHECK(av.subspan(5, 0).length() == 0); + CHECK_THROW(av.subspan(6, 0).length(), fail_fast); + } + + { + span<int> av; + CHECK((av.subspan<0, 0>().length() == 0)); + CHECK(av.subspan(0, 0).length() == 0); + CHECK_THROW((av.subspan<1, 0>().length()), fail_fast); + } + + { + span<int> av; + CHECK(av.subspan(0).length() == 0); + CHECK_THROW(av.subspan(1).length(), fail_fast); + } + + { + span<int> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + + { + span<int, 5> av = arr; + CHECK(av.subspan(0).length() == 5); + CHECK(av.subspan(1).length() == 4); + CHECK(av.subspan(4).length() == 1); + CHECK(av.subspan(5).length() == 0); + CHECK_THROW(av.subspan(6).length(), fail_fast); + auto av2 = av.subspan(1); + for (int i = 0; i < 4; ++i) CHECK(av2[i] == i + 2); + } + } + + TEST(at_call) + { + int arr[4] = {1, 2, 3, 4}; + + { + span<int> s = arr; + CHECK(s.at(0) == 1); + CHECK_THROW(s.at(5), fail_fast); + } + + { + int arr2d[2] = {1, 6}; + span<int, 2> s = arr2d; + CHECK(s.at(0) == 1); + CHECK(s.at(1) == 6); + CHECK_THROW(s.at(2) ,fail_fast); + } + } + + TEST(operator_function_call) + { + int arr[4] = {1, 2, 3, 4}; + + { + span<int> s = arr; + CHECK(s(0) == 1); + CHECK_THROW(s(5), fail_fast); + } + + { + int arr2d[2] = {1, 6}; + span<int, 2> s = arr2d; + CHECK(s(0) == 1); + CHECK(s(1) == 6); + CHECK_THROW(s(2) ,fail_fast); + } + } + + TEST(iterator_default_init) + { + span<int>::iterator it1; + span<int>::iterator it2; + CHECK(it1 == it2); + } + + TEST(const_iterator_default_init) + { + span<int>::const_iterator it1; + span<int>::const_iterator it2; + CHECK(it1 == it2); + } + + TEST(iterator_conversions) + { + span<int>::iterator badIt; + span<int>::const_iterator badConstIt; + CHECK(badIt == badConstIt); + + int a[] = { 1, 2, 3, 4 }; + span<int> s = a; + + auto it = s.begin(); + auto cit = s.cbegin(); + + CHECK(it == cit); + CHECK(cit == it); + + span<int>::const_iterator cit2 = it; + CHECK(cit2 == cit); + + span<int>::const_iterator cit3 = it + 4; + CHECK(cit3 == s.cend()); + } + + TEST(iterator_comparisons) + { + int a[] = { 1, 2, 3, 4 }; + { + span<int> s = a; + span<int>::iterator it = s.begin(); + auto it2 = it + 1; + span<int>::const_iterator cit = s.cbegin(); + + CHECK(it == cit); + CHECK(cit == it); + CHECK(it == it); + CHECK(cit == cit); + CHECK(cit == s.begin()); + CHECK(s.begin() == cit); + CHECK(s.cbegin() == cit); + CHECK(it == s.begin()); + CHECK(s.begin() == it); + + CHECK(it != it2); + CHECK(it2 != it); + CHECK(it != s.end()); + CHECK(it2 != s.end()); + CHECK(s.end() != it); + CHECK(it2 != cit); + CHECK(cit != it2); + + CHECK(it < it2); + CHECK(it <= it2); + CHECK(it2 <= s.end()); + CHECK(it < s.end()); + CHECK(it <= cit); + CHECK(cit <= it); + CHECK(cit < it2); + CHECK(cit <= it2); + CHECK(cit < s.end()); + CHECK(cit <= s.end()); + + CHECK(it2 > it); + CHECK(it2 >= it); + CHECK(s.end() > it2); + CHECK(s.end() >= it2); + CHECK(it2 > cit); + CHECK(it2 >= cit); + } + } + + TEST(begin_end) + { + { + int a[] = { 1, 2, 3, 4 }; + span<int> s = a; + + span<int>::iterator it = s.begin(); + span<int>::iterator it2 = std::begin(s); + CHECK(it == it2); + + it = s.end(); + it2 = std::end(s); + CHECK(it == it2); + } + + { + int a[] = { 1, 2, 3, 4 }; + span<int> s = a; + + auto it = s.begin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 1); + + auto beyond = s.end(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 2); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.end()) + { + *it = 5; + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); + + for (auto& n : s) + { + CHECK(n == 5); + } + } + } + + TEST(cbegin_cend) + { + { + int a[] = { 1, 2, 3, 4 }; + span<int> s = a; + + span<int>::const_iterator cit = s.cbegin(); + span<int>::const_iterator cit2 = std::cbegin(s); + CHECK(cit == cit2); + + cit = s.cend(); + cit2 = std::cend(s); + CHECK(cit == cit2); + } + + { + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.cbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 1); + + auto beyond = s.cend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 2); + CHECK(beyond - it == 3); + + int last = 0; + it = first; + CHECK(it == first); + while (it != s.cend()) + { + CHECK(*it == last + 1); + + last = *it; + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); + } + } + + TEST(rbegin_rend) + { + { + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.rbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 4); + + auto beyond = s.rend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 3); + *it = 22; + CHECK(*it == 22); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + while (it != s.rend()) + { + *it = 5; + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); + + for (auto& n : s) + { + CHECK(n == 5); + } + } + } + + TEST(crbegin_crend) + { + { + int a[] = {1, 2, 3, 4}; + span<int> s = a; + + auto it = s.crbegin(); + auto first = it; + CHECK(it == first); + CHECK(*it == 4); + + auto beyond = s.crend(); + CHECK(it != beyond); + CHECK_THROW(*beyond, fail_fast); + + CHECK(beyond - first == 4); + CHECK(first - first == 0); + CHECK(beyond - beyond == 0); + + ++it; + CHECK(it - first == 1); + CHECK(*it == 3); + CHECK(beyond - it == 3); + + it = first; + CHECK(it == first); + int last = 5; + while (it != s.crend()) + { + CHECK(*it == last - 1); + last = *it; + + ++it; + } + + CHECK(it == beyond); + CHECK(it - beyond == 0); + } + } + + TEST(comparison_operators) + { + { + span<int> s1 = nullptr; + span<int> s2 = nullptr; + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {2, 1}; + span<int> s1 = arr; + span<int> s2 = arr; + + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {2, 1}; // bigger + + span<int> s1 = nullptr; + span<int> s2 = arr; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; + int arr2[] = {1, 2}; + span<int> s1 = arr1; + span<int> s2 = arr2; + + CHECK(s1 == s2); + CHECK(!(s1 != s2)); + CHECK(!(s1 < s2)); + CHECK(s1 <= s2); + CHECK(!(s1 > s2)); + CHECK(s1 >= s2); + CHECK(s2 == s1); + CHECK(!(s2 != s1)); + CHECK(!(s2 < s1)); + CHECK(s2 <= s1); + CHECK(!(s2 > s1)); + CHECK(s2 >= s1); + } + + { + int arr[] = {1, 2, 3}; + + span<int> s1 = {&arr[0], 2}; // shorter + span<int> s2 = arr; // longer + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + + { + int arr1[] = {1, 2}; // smaller + int arr2[] = {2, 1}; // bigger + + span<int> s1 = arr1; + span<int> s2 = arr2; + + CHECK(s1 != s2); + CHECK(s2 != s1); + CHECK(!(s1 == s2)); + CHECK(!(s2 == s1)); + CHECK(s1 < s2); + CHECK(!(s2 < s1)); + CHECK(s1 <= s2); + CHECK(!(s2 <= s1)); + CHECK(s2 > s1); + CHECK(!(s1 > s2)); + CHECK(s2 >= s1); + CHECK(!(s1 >= s2)); + } + } + + TEST(as_bytes) + { + int a[] = {1, 2, 3, 4}; + + { + span<const int> s = a; + CHECK(s.length() == 4); + span<const byte> bs = as_bytes(s); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); + } + + { + span<int> s; + auto bs = as_bytes(s); + CHECK(bs.length() == s.length()); + CHECK(bs.length() == 0); + CHECK(bs.size_bytes() == 0); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.data() == nullptr); + } + + { + span<int> s = a; + auto bs = as_bytes(s); + CHECK(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); + } + } + + TEST(as_writeable_bytes) + { + int a[] = {1, 2, 3, 4}; + + { +#ifdef CONFIRM_COMPILATION_ERRORS + // you should not be able to get writeable bytes for const objects + span<const int> s = a; + CHECK(s.length() == 4); + span<const byte> bs = as_writeable_bytes(s); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); +#endif + } + + { + span<int> s; + auto bs = as_writeable_bytes(s); + CHECK(bs.length() == s.length()); + CHECK(bs.length() == 0); + CHECK(bs.size_bytes() == 0); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.data() == nullptr); + } + + { + span<int> s = a; + auto bs = as_writeable_bytes(s); + CHECK(static_cast<void*>(bs.data()) == static_cast<void*>(s.data())); + CHECK(bs.length() == s.length_bytes()); + } + } + + TEST(fixed_size_conversions) + { + int arr[] = {1, 2, 3, 4}; + + // converting to an span from an equal size array is ok + span<int, 4> s4 = arr; + CHECK(s4.length() == 4); + + // converting to dynamic_range is always ok + { + span<int> s = s4; + CHECK(s.length() == s4.length()); + static_cast<void>(s); + } + +// initialization or assignment to static span that REDUCES size is NOT ok +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int, 2> s = arr; + } + { + span<int, 2> s2 = s4; + static_cast<void>(s2); + } +#endif + + // even when done dynamically + { + span<int> s = arr; + auto f = [&]() { + span<int, 2> s2 = s; + static_cast<void>(s2); + }; + CHECK_THROW(f(), fail_fast); + } + + // but doing so explicitly is ok + + // you can convert statically + { + span<int, 2> s2 = {arr, 2}; + static_cast<void>(s2); + } + { + span<int, 1> s1 = s4.first<1>(); + static_cast<void>(s1); + } + + // ...or dynamically + { + // NB: implicit conversion to span<int,1> from span<int> + span<int, 1> s1 = s4.first(1); + static_cast<void>(s1); + } + + // initialization or assignment to static span that requires size INCREASE is not ok. + int arr2[2] = {1, 2}; + +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<int, 4> s3 = arr2; + } + { + span<int, 2> s2 = arr2; + span<int, 4> s4a = s2; + } +#endif + { + auto f = [&]() { + span<int, 4> s4 = {arr2, 2}; + static_cast<void>(s4); + }; + CHECK_THROW(f(), fail_fast); + } + + // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one + span<int> av = arr2; + auto f = [&]() { + span<int, 4> s4 = av; + static_cast<void>(s4); + }; + CHECK_THROW(f(), fail_fast); + } + + TEST(interop_with_std_regex) + { + char lat[] = { '1', '2', '3', '4', '5', '6', 'E', 'F', 'G' }; + span<char> s = lat; + auto f_it = s.begin() + 7; + + std::match_results<span<char>::iterator> match; + + std::regex_match(s.begin(), s.end(), match, std::regex(".*")); + CHECK(match.ready()); + CHECK(!match.empty()); + CHECK(match[0].matched); + CHECK(match[0].first == s.begin()); + CHECK(match[0].second == s.end()); + + std::regex_search(s.begin(), s.end(), match, std::regex("F")); + CHECK(match.ready()); + CHECK(!match.empty()); + CHECK(match[0].matched); + CHECK(match[0].first == f_it); + CHECK(match[0].second == (f_it + 1)); + } + + TEST(interop_with_gsl_at) + { + int arr[5] = {1, 2, 3, 4, 5}; + span<int> s{arr}; + CHECK(at(s,0) == 1 && at(s,1) == 2); + } +} + +int main(int, const char* []) { return UnitTest::RunAllTests(); } diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp new file mode 100644 index 0000000..86666d1 --- /dev/null +++ b/tests/strided_span_tests.cpp @@ -0,0 +1,748 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/multi_span> + +#include <string> +#include <vector> +#include <list> +#include <iostream> +#include <memory> +#include <map> + +using namespace std; +using namespace gsl; + +namespace +{ + struct BaseClass {}; + struct DerivedClass : BaseClass {}; +} + +SUITE(strided_span_tests) +{ + TEST (span_section_test) + { + int a[30][4][5]; + + auto av = as_multi_span(a); + auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2}); + auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1}); + (void)subsub; + } + + TEST(span_section) + { + std::vector<int> data(5 * 10); + std::iota(begin(data), end(data), 0); + const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); + + strided_span<int, 2> av_section_1 = av.section({ 1, 2 }, { 3, 4 }); + CHECK((av_section_1[{0, 0}] == 12)); + CHECK((av_section_1[{0, 1}] == 13)); + CHECK((av_section_1[{1, 0}] == 22)); + CHECK((av_section_1[{2, 3}] == 35)); + + strided_span<int, 2> av_section_2 = av_section_1.section({ 1, 2 }, { 2,2 }); + CHECK((av_section_2[{0, 0}] == 24)); + CHECK((av_section_2[{0, 1}] == 25)); + CHECK((av_section_2[{1, 0}] == 34)); + } + + TEST(strided_span_constructors) + { + // Check stride constructor + { + int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + const int carr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + strided_span<int, 1> sav1{ arr, {{9}, {1}} }; // T -> T + CHECK(sav1.bounds().index_bounds() == index<1>{ 9 }); + CHECK(sav1.bounds().stride() == 1); + CHECK(sav1[0] == 1 && sav1[8] == 9); + + + strided_span<const int, 1> sav2{ carr, {{ 4 }, { 2 }} }; // const T -> const T + CHECK(sav2.bounds().index_bounds() == index<1>{ 4 }); + CHECK(sav2.bounds().strides() == index<1>{2}); + CHECK(sav2[0] == 1 && sav2[3] == 7); + + strided_span<int, 2> sav3{ arr, {{ 2, 2 },{ 6, 2 }} }; // T -> const T + CHECK((sav3.bounds().index_bounds() == index<2>{ 2, 2 })); + CHECK((sav3.bounds().strides() == index<2>{ 6, 2 })); + CHECK((sav3[{0, 0}] == 1 && sav3[{0, 1}] == 3 && sav3[{1, 0}] == 7)); + } + + // Check multi_span constructor + { + int arr[] = { 1, 2 }; + + // From non-cv-qualified source + { + const multi_span<int> src = arr; + + strided_span<int, 1> sav{ src, {2, 1} }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().strides() == index<1>{ 1 }); + CHECK(sav[1] == 2); + +#if _MSC_VER > 1800 + //strided_span<const int, 1> sav_c{ {src}, {2, 1} }; + strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} }; +#else + strided_span<const int, 1> sav_c{ multi_span<const int>{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_c.bounds().strides() == index<1>{ 1 }); + CHECK(sav_c[1] == 2); + +#if _MSC_VER > 1800 + strided_span<volatile int, 1> sav_v{ src, {2, 1} }; +#else + strided_span<volatile int, 1> sav_v{ multi_span<volatile int>{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_v.bounds().strides() == index<1>{ 1 }); + CHECK(sav_v[1] == 2); + +#if _MSC_VER > 1800 + strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; +#else + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From const-qualified source + { + const multi_span<const int> src{ arr }; + + strided_span<const int, 1> sav_c{ src, {2, 1} }; + CHECK(sav_c.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_c.bounds().strides() == index<1>{ 1 }); + CHECK(sav_c[1] == 2); + +#if _MSC_VER > 1800 + strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; +#else + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; +#endif + + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From volatile-qualified source + { + const multi_span<volatile int> src{ arr }; + + strided_span<volatile int, 1> sav_v{ src, {2, 1} }; + CHECK(sav_v.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_v.bounds().strides() == index<1>{ 1 }); + CHECK(sav_v[1] == 2); + +#if _MSC_VER > 1800 + strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; +#else + strided_span<const volatile int, 1> sav_cv{ multi_span<const volatile int>{src}, strided_bounds<1>{2, 1} }; +#endif + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + + // From cv-qualified source + { + const multi_span<const volatile int> src{ arr }; + + strided_span<const volatile int, 1> sav_cv{ src, {2, 1} }; + CHECK(sav_cv.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav_cv.bounds().strides() == index<1>{ 1 }); + CHECK(sav_cv[1] == 2); + } + } + + // Check const-casting constructor + { + int arr[2] = { 4, 5 }; + + const multi_span<int, 2> av(arr, 2); + multi_span<const int, 2> av2{ av }; + CHECK(av2[1] == 5); + + static_assert(std::is_convertible<const multi_span<int, 2>, multi_span<const int, 2>>::value, "ctor is not implicit!"); + + const strided_span<int, 1> src{ arr, {2, 1} }; + strided_span<const int, 1> sav{ src }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().stride() == 1); + CHECK(sav[1] == 5); + + static_assert(std::is_convertible<const strided_span<int, 1>, strided_span<const int, 1>>::value, "ctor is not implicit!"); + } + + // Check copy constructor + { + int arr1[2] = { 3, 4 }; + const strided_span<int, 1> src1{ arr1, {2, 1} }; + strided_span<int, 1> sav1{ src1 }; + + CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav1.bounds().stride() == 1); + CHECK(sav1[0] == 3); + + int arr2[6] = { 1, 2, 3, 4, 5, 6 }; + const strided_span<const int, 2> src2{ arr2, {{ 3, 2 }, { 2, 1 }} }; + strided_span<const int, 2> sav2{ src2 }; + CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); + CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); + CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); + } + + // Check const-casting assignment operator + { + int arr1[2] = { 1, 2 }; + int arr2[6] = { 3, 4, 5, 6, 7, 8 }; + + const strided_span<int, 1> src{ arr1, {{2}, {1}} }; + strided_span<const int, 1> sav{ arr2, {{3}, {2}} }; + strided_span<const int, 1>& sav_ref = (sav = src); + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav.bounds().strides() == index<1>{ 1 }); + CHECK(sav[0] == 1); + CHECK(&sav_ref == &sav); + } + + // Check copy assignment operator + { + int arr1[2] = { 3, 4 }; + int arr1b[1] = { 0 }; + const strided_span<int, 1> src1{ arr1, {2, 1} }; + strided_span<int, 1> sav1{ arr1b, {1, 1} }; + strided_span<int, 1>& sav1_ref = (sav1 = src1); + CHECK(sav1.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav1.bounds().strides() == index<1>{ 1 }); + CHECK(sav1[0] == 3); + CHECK(&sav1_ref == &sav1); + + const int arr2[6] = { 1, 2, 3, 4, 5, 6 }; + const int arr2b[1] = { 0 }; + const strided_span<const int, 2> src2{ arr2, {{ 3, 2 },{ 2, 1 }} }; + strided_span<const int, 2> sav2{ arr2b, {{ 1, 1 },{ 1, 1 }} }; + strided_span<const int, 2>& sav2_ref = (sav2 = src2); + CHECK((sav2.bounds().index_bounds() == index<2>{ 3, 2 })); + CHECK((sav2.bounds().strides() == index<2>{ 2, 1 })); + CHECK((sav2[{0, 0}] == 1 && sav2[{2, 0}] == 5)); + CHECK(&sav2_ref == &sav2); + } + } + + TEST(strided_span_slice) + { + std::vector<int> data(5 * 10); + std::iota(begin(data), end(data), 0); + const multi_span<int, 5, 10> src = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); + + const strided_span<int, 2> sav{ src, {{5, 10}, {10, 1}} }; +#ifdef CONFIRM_COMPILATION_ERRORS + const strided_span<const int, 2> csav{ {src},{ { 5, 10 },{ 10, 1 } } }; +#endif + const strided_span<const int, 2> csav{ multi_span<const int, 5, 10>{ src }, { { 5, 10 },{ 10, 1 } } }; + + strided_span<int, 1> sav_sl = sav[2]; + CHECK(sav_sl[0] == 20); + CHECK(sav_sl[9] == 29); + + strided_span<const int, 1> csav_sl = sav[3]; + CHECK(csav_sl[0] == 30); + CHECK(csav_sl[9] == 39); + + CHECK(sav[4][0] == 40); + CHECK(sav[4][9] == 49); + } + + TEST(strided_span_column_major) + { + // strided_span may be used to accomodate more peculiar + // use cases, such as column-major multidimensional array + // (aka. "FORTRAN" layout). + + int cm_array[3 * 5] = { + 1, 4, 7, 10, 13, + 2, 5, 8, 11, 14, + 3, 6, 9, 12, 15 + }; + strided_span<int, 2> cm_sav{ cm_array, {{ 5, 3 },{ 1, 5 }} }; + + // Accessing elements + CHECK((cm_sav[{0, 0}] == 1)); + CHECK((cm_sav[{0, 1}] == 2)); + CHECK((cm_sav[{1, 0}] == 4)); + CHECK((cm_sav[{4, 2}] == 15)); + + // Slice + strided_span<int, 1> cm_sl = cm_sav[3]; + + CHECK(cm_sl[0] == 10); + CHECK(cm_sl[1] == 11); + CHECK(cm_sl[2] == 12); + + // Section + strided_span<int, 2> cm_sec = cm_sav.section( { 2, 1 }, { 3, 2 }); + + CHECK((cm_sec.bounds().index_bounds() == index<2>{3, 2})); + CHECK((cm_sec[{0, 0}] == 8)); + CHECK((cm_sec[{0, 1}] == 9)); + CHECK((cm_sec[{1, 0}] == 11)); + CHECK((cm_sec[{2, 1}] == 15)); + } + + TEST(strided_span_bounds) + { + int arr[] = { 0, 1, 2, 3 }; + multi_span<int> av(arr); + + { + // incorrect sections + + CHECK_THROW(av.section(0, 0)[0], fail_fast); + CHECK_THROW(av.section(1, 0)[0], fail_fast); + CHECK_THROW(av.section(1, 1)[1], fail_fast); + + CHECK_THROW(av.section(2, 5), fail_fast); + CHECK_THROW(av.section(5, 2), fail_fast); + CHECK_THROW(av.section(5, 0), fail_fast); + CHECK_THROW(av.section(0, 5), fail_fast); + CHECK_THROW(av.section(5, 5), fail_fast); + } + + { + // zero stride + strided_span<int, 1> sav{ av,{ { 4 },{} } }; + CHECK(sav[0] == 0); + CHECK(sav[3] == 0); + CHECK_THROW(sav[4], fail_fast); + } + + { + // zero extent + strided_span<int, 1> sav{ av,{ {},{ 1 } } }; + CHECK_THROW(sav[0], fail_fast); + } + + { + // zero extent and stride + strided_span<int, 1> sav{ av,{ {},{} } }; + CHECK_THROW(sav[0], fail_fast); + } + + { + // strided array ctor with matching strided bounds + strided_span<int, 1> sav{ arr,{ 4, 1 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 4 }); + CHECK(sav[3] == 3); + CHECK_THROW(sav[4], fail_fast); + } + + { + // strided array ctor with smaller strided bounds + strided_span<int, 1> sav{ arr,{ 2, 1 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav[1] == 1); + CHECK_THROW(sav[2], fail_fast); + } + + { + // strided array ctor with fitting irregular bounds + strided_span<int, 1> sav{ arr,{ 2, 3 } }; + CHECK(sav.bounds().index_bounds() == index<1>{ 2 }); + CHECK(sav[0] == 0); + CHECK(sav[1] == 3); + CHECK_THROW(sav[2], fail_fast); + } + + { + // bounds cross data boundaries - from static arrays + CHECK_THROW((strided_span<int, 1> { arr, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { arr, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { arr, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { arr, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { arr, { 5, 5 } }), fail_fast); + } + + { + // bounds cross data boundaries - from array view + CHECK_THROW((strided_span<int, 1> { av, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av, { 5, 5 } }), fail_fast); + } + + { + // bounds cross data boundaries - from dynamic arrays + CHECK_THROW((strided_span<int, 1> { av.data(), 4, { 3, 2 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av.data(), 4, { 3, 3 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av.data(), 4, { 4, 5 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av.data(), 4, { 5, 1 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av.data(), 4, { 5, 5 } }), fail_fast); + CHECK_THROW((strided_span<int, 1> { av.data(), 2, { 2, 2 } }), fail_fast); + } + +#ifdef CONFIRM_COMPILATION_ERRORS + { + strided_span<int, 1> sav0{ av.data(), { 3, 2 } }; + strided_span<int, 1> sav1{ arr, { 1 } }; + strided_span<int, 1> sav2{ arr, { 1,1,1 } }; + strided_span<int, 1> sav3{ av, { 1 } }; + strided_span<int, 1> sav4{ av, { 1,1,1 } }; + strided_span<int, 2> sav5{ av.as_multi_span(dim<2>(), dim<2>()), { 1 } }; + strided_span<int, 2> sav6{ av.as_multi_span(dim<2>(), dim<2>()), { 1,1,1 } }; + strided_span<int, 2> sav7{ av.as_multi_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; + + index<1> index{ 0, 1 }; + strided_span<int, 1> sav8{ arr,{ 1,{ 1,1 } } }; + strided_span<int, 1> sav9{ arr,{ { 1,1 },{ 1,1 } } }; + strided_span<int, 1> sav10{ av,{ 1,{ 1,1 } } }; + strided_span<int, 1> sav11{ av,{ { 1,1 },{ 1,1 } } }; + strided_span<int, 2> sav12{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; + strided_span<int, 2> sav13{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; + strided_span<int, 2> sav14{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; + } +#endif + } + + TEST(strided_span_type_conversion) + { + int arr[] = { 0, 1, 2, 3 }; + multi_span<int> av(arr); + + { + strided_span<int, 1> sav{ av.data(), av.size(), { av.size() / 2, 2 } }; +#ifdef CONFIRM_COMPILATION_ERRORS + strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>(); +#endif + } + { + strided_span<int, 1> sav{ av, { av.size() / 2, 2 } }; +#ifdef CONFIRM_COMPILATION_ERRORS + strided_span<long, 1> lsav1 = sav.as_strided_span<long, 1>(); +#endif + } + + multi_span<const byte, dynamic_range> bytes = as_bytes(av); + + // retype strided array with regular strides - from raw data + { + strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; + strided_span<const byte, 2> sav2{ bytes.data(), bytes.size(), bounds }; + strided_span<const int, 2> sav3 = sav2.as_strided_span<const int>(); + CHECK(sav3[0][0] == 0); + CHECK(sav3[1][0] == 2); + CHECK_THROW(sav3[1][1], fail_fast); + CHECK_THROW(sav3[0][1], fail_fast); + } + + // retype strided array with regular strides - from multi_span + { + strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2)); + strided_span<const byte, 2> sav2{ bytes2, bounds }; + strided_span<int, 2> sav3 = sav2.as_strided_span<int>(); + CHECK(sav3[0][0] == 0); + CHECK(sav3[1][0] == 2); + CHECK_THROW(sav3[1][1], fail_fast); + CHECK_THROW(sav3[0][1], fail_fast); + } + + // retype strided array with not enough elements - last dimension of the array is too small + { + strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } }; + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2)); + strided_span<const byte, 2> sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + + // retype strided array with not enough elements - strides are too small + { + strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } }; + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2)); + strided_span<const byte, 2> sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + + // retype strided array with not enough elements - last dimension does not divide by the new typesize + { + strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } }; + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2)); + strided_span<const byte, 2> sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + + // retype strided array with not enough elements - strides does not divide by the new typesize + { + strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } }; + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim(bytes.size() / 2)); + strided_span<const byte, 2> sav2{ bytes2, bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + + // retype strided array with irregular strides - from raw data + { + strided_bounds<1> bounds{ bytes.size() / 2, 2 }; + strided_span<const byte, 1> sav2{ bytes.data(), bytes.size(), bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + + // retype strided array with irregular strides - from multi_span + { + strided_bounds<1> bounds{ bytes.size() / 2, 2 }; + strided_span<const byte, 1> sav2{ bytes, bounds }; + CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); + } + } + + TEST(empty_strided_spans) + { + { + multi_span<int, 0> empty_av(nullptr); + strided_span<int, 1> empty_sav{ empty_av, { 0, 1 } }; + + CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); + CHECK_THROW(empty_sav[0], fail_fast); + CHECK_THROW(empty_sav.begin()[0], fail_fast); + CHECK_THROW(empty_sav.cbegin()[0], fail_fast); + + for (auto& v : empty_sav) + { + (void)v; + CHECK(false); + } + } + + { + strided_span<int, 1> empty_sav{ nullptr, 0, { 0, 1 } }; + + CHECK(empty_sav.bounds().index_bounds() == index<1>{ 0 }); + CHECK_THROW(empty_sav[0], fail_fast); + CHECK_THROW(empty_sav.begin()[0], fail_fast); + CHECK_THROW(empty_sav.cbegin()[0], fail_fast); + + for (auto& v : empty_sav) + { + (void)v; + CHECK(false); + } + } + } + + void iterate_every_other_element(multi_span<int, dynamic_range> av) + { + // pick every other element + + auto length = av.size() / 2; +#if _MSC_VER > 1800 + auto bounds = strided_bounds<1>({length}, {2}); +#else + auto bounds = strided_bounds<1>(index<1>{ length }, index<1>{ 2 }); +#endif + strided_span<int, 1> strided(&av.data()[1], av.size() - 1, bounds); + + CHECK(strided.size() == length); + CHECK(strided.bounds().index_bounds()[0] == length); + for (auto i = 0; i < strided.size(); ++i) + { + CHECK(strided[i] == av[2 * i + 1]); + } + + int idx = 0; + for (auto num : strided) + { + CHECK(num == av[2 * idx + 1]); + idx++; + } + } + + TEST(strided_span_section_iteration) + { + int arr[8] = {4,0,5,1,6,2,7,3}; + + // static bounds + { + multi_span<int, 8> av(arr, 8); + iterate_every_other_element(av); + } + + // dynamic bounds + { + multi_span<int, dynamic_range> av(arr, 8); + iterate_every_other_element(av); + } + } + + TEST(dynamic_strided_span_section_iteration) + { + auto arr = new int[8]; + for (int i = 0; i < 4; ++i) + { + arr[2 * i] = 4 + i; + arr[2 * i + 1] = i; + } + + auto av = as_multi_span(arr, 8); + iterate_every_other_element(av); + + delete[] arr; + } + + void iterate_second_slice(multi_span<int, dynamic_range, dynamic_range, dynamic_range> av) + { + int expected[6] = {2,3,10,11,18,19}; + auto section = av.section({0,1,0}, {3,1,2}); + + for (auto i = 0; i < section.extent<0>(); ++i) + { + for (auto j = 0; j < section.extent<1>(); ++j) + for (auto k = 0; k < section.extent<2>(); ++k) + { + auto idx = index<3>{i,j,k}; // avoid braces in the CHECK macro + CHECK(section[idx] == expected[2 * i + 2 * j + k]); + } + } + + for (auto i = 0; i < section.extent<0>(); ++i) + { + for (auto j = 0; j < section.extent<1>(); ++j) + for (auto k = 0; k < section.extent<2>(); ++k) + CHECK(section[i][j][k] == expected[2 * i + 2 * j + k]); + } + + int i = 0; + for (auto num : section) + { + CHECK(num == expected[i]); + i++; + } + } + + TEST(strided_span_section_iteration_3d) + { + int arr[3][4][2]; + for (auto i = 0; i < 3; ++i) + { + for (auto j = 0; j < 4; ++j) + for (auto k = 0; k < 2; ++k) + arr[i][j][k] = 8 * i + 2 * j + k; + } + + { + multi_span<int, 3, 4, 2> av = arr; + iterate_second_slice(av); + } + } + + TEST(dynamic_strided_span_section_iteration_3d) + { + auto height = 12, width = 2; + auto size = height * width; + + auto arr = new int[size]; + for (auto i = 0; i < size; ++i) + { + arr[i] = i; + } + + { + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>()); + iterate_second_slice(av); + } + + { + auto av = as_multi_span(as_multi_span(arr, 24), dim(3), dim<4>(), dim<2>()); + iterate_second_slice(av); + } + + { + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim(4), dim<2>()); + iterate_second_slice(av); + } + + { + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim(2)); + iterate_second_slice(av); + } + delete[] arr; + } + + TEST(strided_span_conversion) + { + // get an multi_span of 'c' values from the list of X's + + struct X { int a; int b; int c; }; + + X arr[4] = {{0,1,2},{3,4,5},{6,7,8},{9,10,11}}; + + int s = sizeof(int) / sizeof(byte); + auto d2 = 3 * s; + auto d1 = sizeof(int) * 12 / d2; + + // convert to 4x12 array of bytes + auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim(d1), dim(d2)); + + CHECK(av.bounds().index_bounds()[0] == 4); + CHECK(av.bounds().index_bounds()[1] == 12); + + // get the last 4 columns + auto section = av.section({0, 2 * s}, {4, s}); // { { arr[0].c[0], arr[0].c[1], arr[0].c[2], arr[0].c[3] } , { arr[1].c[0], ... } , ... } + + // convert to array 4x1 array of integers + auto cs = section.as_strided_span<int>(); // { { arr[0].c }, {arr[1].c } , ... } + + CHECK(cs.bounds().index_bounds()[0] == 4); + CHECK(cs.bounds().index_bounds()[1] == 1); + + // transpose to 1x4 array + strided_bounds<2> reverse_bounds{ + {cs.bounds().index_bounds()[1] , cs.bounds().index_bounds()[0]}, + {cs.bounds().strides()[1], cs.bounds().strides()[0]} + }; + + strided_span<int, 2> transposed{cs.data(), cs.bounds().total_size(), reverse_bounds}; + + // slice to get a one-dimensional array of c's + strided_span<int, 1> result = transposed[0]; + + CHECK(result.bounds().index_bounds()[0] == 4); + CHECK_THROW(result.bounds().index_bounds()[1], fail_fast); + + int i = 0; + for (auto& num : result) + { + CHECK(num == arr[i].c); + i++; + } + + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp new file mode 100644 index 0000000..a1cfe79 --- /dev/null +++ b/tests/string_span_tests.cpp @@ -0,0 +1,971 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <cstdlib> +#include <gsl/string_span> +#include <vector> +#include <map> + +using namespace std; +using namespace gsl; + + +SUITE(string_span_tests) +{ + + TEST(TestLiteralConstruction) + { + cwstring_span<> v = ensure_z(L"Hello"); + CHECK(5 == v.length()); + +#ifdef CONFIRM_COMPILATION_ERRORS + wstring_span<> v2 = ensure0(L"Hello"); +#endif + } + + TEST(TestConstructFromStdString) + { + std::string s = "Hello there world"; + cstring_span<> v = s; + CHECK(v.length() == static_cast<cstring_span<>::index_type>(s.length())); + } + + TEST(TestConstructFromStdVector) + { + std::vector<char> vec(5, 'h'); + string_span<> v {vec}; + CHECK(v.length() == static_cast<string_span<>::index_type>(vec.size())); + } + + TEST(TestStackArrayConstruction) + { + wchar_t stack_string[] = L"Hello"; + + { + cwstring_span<> v = ensure_z(stack_string); + CHECK(v.length() == 5); + } + + { + cwstring_span<> v = stack_string; + CHECK(v.length() == 5); + } + + { + wstring_span<> v = ensure_z(stack_string); + CHECK(v.length() == 5); + } + + { + wstring_span<> v = stack_string; + CHECK(v.length() == 5); + } + } + + TEST(TestConstructFromConstCharPointer) + { + const char* s = "Hello"; + cstring_span<> v = ensure_z(s); + CHECK(v.length() == 5); + } + + TEST(TestConversionToConst) + { + char stack_string[] = "Hello"; + string_span<> v = ensure_z(stack_string); + cstring_span<> v2 = v; + CHECK(v.length() == v2.length()); + } + + TEST(TestConversionFromConst) + { + char stack_string[] = "Hello"; + cstring_span<> v = ensure_z(stack_string); + (void)v; +#ifdef CONFIRM_COMPILATION_ERRORS + string_span<> v2 = v; + string_span<> v3 = "Hello"; +#endif + } + + TEST(TestToString) + { + auto s = gsl::to_string(cstring_span<>{}); + CHECK(s.length() == 0); + + char stack_string[] = "Hello"; + cstring_span<> v = ensure_z(stack_string); + auto s2 = gsl::to_string(v); + CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length()); + CHECK(s2.length() == 5); + } + + TEST(TestToBasicString) + { + auto s = gsl::to_basic_string<char,std::char_traits<char>,::std::allocator<char>>(cstring_span<>{}); + CHECK(s.length() == 0); + + char stack_string[] = "Hello"; + cstring_span<> v = ensure_z(stack_string); + auto s2 = gsl::to_basic_string<char,std::char_traits<char>,::std::allocator<char>>(v); + CHECK(static_cast<cstring_span<>::index_type>(s2.length()) == v.length()); + CHECK(s2.length() == 5); + } + + TEST(EqualityAndImplicitConstructors) + { + { + cstring_span<> span = "Hello"; + cstring_span<> span1; + + // comparison to empty span + CHECK(span1 != span); + CHECK(span != span1); + } + + { + cstring_span<> span = "Hello"; + cstring_span<> span1 = "Hello1"; + + // comparison to different span + CHECK(span1 != span); + CHECK(span != span1); + } + + { + cstring_span<> span = "Hello"; + + const char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + const char ar1[] = "Hello"; + const char ar2[10] = "Hello"; + const char* ptr = "Hello"; + const std::string str = "Hello"; + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + gsl::span<const char> sp = ensure_z("Hello"); + + // comparison to literal + CHECK(span == cstring_span<>("Hello")); + + // comparison to static array with no null termination + CHECK(span == cstring_span<>(ar)); + + // comparison to static array with null at the end + CHECK(span == cstring_span<>(ar1)); + + // comparison to static array with null in the middle + CHECK(span == cstring_span<>(ar2)); + + // comparison to null-terminated c string + CHECK(span == cstring_span<>(ptr, 5)); + + // comparison to string + CHECK(span == cstring_span<>(str)); + + // comparison to vector of charaters with no null termination + CHECK(span == cstring_span<>(vec)); + + // comparison to span + CHECK(span == cstring_span<>(sp)); + + // comparison to string_span + CHECK(span == span); + } + + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + + string_span<> span = ar; + + char ar1[] = "Hello"; + char ar2[10] = "Hello"; + char* ptr = ar; + std::string str = "Hello"; + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + gsl::span<char> sp = ensure_z(ar1); + + // comparison to static array with no null termination + CHECK(span == string_span<>(ar)); + + // comparison to static array with null at the end + CHECK(span == string_span<>(ar1)); + + // comparison to static array with null in the middle + CHECK(span == string_span<>(ar2)); + + // comparison to null-terminated c string + CHECK(span == string_span<>(ptr, 5)); + + // comparison to string + CHECK(span == string_span<>(str)); + + // comparison to vector of charaters with no null termination + CHECK(span == string_span<>(vec)); + + // comparison to span + CHECK(span == string_span<>(sp)); + + // comparison to string_span + CHECK(span == span); + } + + + { + const char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + const char ar1[] = "Hello"; + const char ar2[10] = "Hello"; + const std::string str = "Hello"; + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + gsl::span<const char> sp = ensure_z("Hello"); + + cstring_span<> span = "Hello"; + + // const span, const other type + + CHECK(span == "Hello"); + CHECK(span == ar); + CHECK(span == ar1); + CHECK(span == ar2); +#ifdef CONFIRM_COMPILATION_ERRORS + const char* ptr = "Hello"; + CHECK(span == ptr); +#endif + CHECK(span == str); + CHECK(span == vec); + CHECK(span == sp); + + CHECK("Hello" == span); + CHECK(ar == span); + CHECK(ar1 == span); + CHECK(ar2 == span); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(ptr == span); +#endif + CHECK(str == span); + CHECK(vec == span); + CHECK(sp == span); + + // const span, non-const other type + + char _ar[] = { 'H', 'e', 'l', 'l', 'o' }; + char _ar1[] = "Hello"; + char _ar2[10] = "Hello"; + char* _ptr = _ar; + std::string _str = "Hello"; + std::vector<char> _vec = { 'H', 'e', 'l', 'l', 'o' }; + gsl::span<char> _sp{ _ar, 5 }; + + CHECK(span == _ar); + CHECK(span == _ar1); + CHECK(span == _ar2); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(span == _ptr); +#endif + CHECK(span == _str); + CHECK(span == _vec); + CHECK(span == _sp); + + CHECK(_ar == span); + CHECK(_ar1 == span); + CHECK(_ar2 == span); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(_ptr == span); +#endif + CHECK(_str == span); + CHECK(_vec == span); + CHECK(_sp == span); + + string_span<> _span{ _ptr, 5 }; + + // non-const span, non-const other type + + CHECK(_span == _ar); + CHECK(_span == _ar1); + CHECK(_span == _ar2); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(_span == _ptr); +#endif + CHECK(_span == _str); + CHECK(_span == _vec); + CHECK(_span == _sp); + + CHECK(_ar == _span); + CHECK(_ar1 == _span); + CHECK(_ar2 == _span); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(_ptr == _span); +#endif + CHECK(_str == _span); + CHECK(_vec == _span); + CHECK(_sp == _span); + + // non-const span, const other type + + CHECK(_span == "Hello"); + CHECK(_span == ar); + CHECK(_span == ar1); + CHECK(_span == ar2); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(_span == ptr); +#endif + CHECK(_span == str); + CHECK(_span == vec); + CHECK(_span == sp); + + CHECK("Hello" == _span); + CHECK(ar == _span); + CHECK(ar1 == _span); + CHECK(ar2 == _span); +#ifdef CONFIRM_COMPILATION_ERRORS + CHECK(ptr == _span); +#endif + CHECK(str == _span); + CHECK(vec == _span); + CHECK(sp == _span); + + // two spans + + CHECK(_span == span); + CHECK(span == _span); + } + + { + std::vector<char> str1 = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> span1 = str1; + std::vector<char> str2 = std::move(str1); + cstring_span<> span2 = str2; + + // comparison of spans from the same vector before and after move (ok) + CHECK(span1 == span2); + } + } + + TEST(ComparisonAndImplicitConstructors) + { + { + cstring_span<> span = "Hello"; + + const char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + const char ar1[] = "Hello"; + const char ar2[10] = "Hello"; + const char* ptr = "Hello"; + const std::string str = "Hello"; + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + + // comparison to literal + CHECK(span < cstring_span<>("Helloo")); + CHECK(span > cstring_span<>("Hell")); + + // comparison to static array with no null termination + CHECK(span >= cstring_span<>(ar)); + + // comparison to static array with null at the end + CHECK(span <= cstring_span<>(ar1)); + + // comparison to static array with null in the middle + CHECK(span >= cstring_span<>(ar2)); + + // comparison to null-terminated c string + CHECK(span <= cstring_span<>(ptr, 5)); + + // comparison to string + CHECK(span >= cstring_span<>(str)); + + // comparison to vector of charaters with no null termination + CHECK(span <= cstring_span<>(vec)); + } + + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + + string_span<> span = ar; + + char larr[] = "Hell"; + char rarr[] = "Helloo"; + + char ar1[] = "Hello"; + char ar2[10] = "Hello"; + char* ptr = ar; + std::string str = "Hello"; + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + + + // comparison to static array with no null termination + CHECK(span <= string_span<>(ar)); + CHECK(span < string_span<>(rarr)); + CHECK(span > string_span<>(larr)); + + // comparison to static array with null at the end + CHECK(span >= string_span<>(ar1)); + + // comparison to static array with null in the middle + CHECK(span <= string_span<>(ar2)); + + // comparison to null-terminated c string + CHECK(span >= string_span<>(ptr, 5)); + + // comparison to string + CHECK(span <= string_span<>(str)); + + // comparison to vector of charaters with no null termination + CHECK(span >= string_span<>(vec)); + } + } + TEST(ConstrutorsEnsureZ) + { + // remove z from literals + { + cstring_span<> sp = "hello"; + CHECK((sp.length() == 5)); + } + + // take the string as is + { + auto str = std::string("hello"); + cstring_span<> sp = str; + CHECK((sp.length() == 5)); + } + + // ensure z on c strings + { + char* ptr = new char[3]; + + ptr[0] = 'a'; + ptr[1] = 'b'; + ptr[2] = '\0'; + + string_span<> span = ensure_z(ptr); + CHECK(span.length() == 2); + + delete[] ptr; + } + } + + TEST(Constructors) + { + // creating cstring_span + + // from span of a final extent + { + span<const char, 6> sp = "Hello"; + cstring_span<> span = sp; + CHECK(span.length() == 6); + } + + // from const span of a final extent to non-const string_span +#ifdef CONFIRM_COMPILATION_ERRORS + { + span<const char, 6> sp = "Hello"; + string_span<> span = sp; + CHECK(span.length() == 6); + } +#endif + + // from string temporary +#ifdef CONFIRM_COMPILATION_ERRORS + { + cstring_span<> span = std::string("Hello"); + } +#endif + + // default + { + cstring_span<> span; + CHECK(span.length() == 0); + } + + // from nullptr + { + cstring_span<> span(nullptr); + CHECK(span.length() == 0); + } + + // from string literal + { + cstring_span<> span = "Hello"; + CHECK(span.length() == 5); + } + + // from const static array + { + const char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> span = ar; + CHECK(span.length() == 5); + } + + // from non-const static array + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> span = ar; + CHECK(span.length() == 5); + } + + // from const ptr and length + { + const char* ptr = "Hello"; + cstring_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); + } + + // from const ptr and length, include 0 + { + const char* ptr = "Hello"; + cstring_span<> span{ ptr, 6 }; + CHECK(span.length() == 6); + } + + // from const ptr and length, 0 inside + { + const char* ptr = "He\0lo"; + cstring_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); + } + + // from non-const ptr and length + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + char* ptr = ar; + cstring_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); + } + + // from non-const ptr and length, 0 inside + { + char ar[] = { 'H', 'e', '\0', 'l', 'o' }; + char* ptr = ar; + cstring_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); + } + + // from const string + { + const std::string str = "Hello"; + cstring_span<> span = str; + CHECK(span.length() == 5); + } + + // from non-const string + { + std::string str = "Hello"; + cstring_span<> span = str; + CHECK(span.length() == 5); + } + + // from const vector + { + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> span = vec; + CHECK(span.length() == 5); + } + + // from non-const vector + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> span = vec; + CHECK(span.length() == 5); + } + + // from const span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + const span<const char> inner = vec; + cstring_span<> span = inner; + CHECK(span.length() == 5); + } + + // from non-const span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + span<char> inner = vec; + cstring_span<> span = inner; + CHECK(span.length() == 5); + } + + // from const string_span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> tmp = vec; + cstring_span<> span = tmp; + CHECK(span.length() == 5); + } + + // from non-const string_span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> tmp = vec; + cstring_span<> span = tmp; + CHECK(span.length() == 5); + } + + // creating string_span + + // from string literal + { +#ifdef CONFIRM_COMPILATION_ERRORS + string_span<> span = "Hello"; +#endif + } + + // from const static array + { +#ifdef CONFIRM_COMPILATION_ERRORS + const char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = ar; + CHECK(span.length() == 5); +#endif + } + + // from non-const static array + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = ar; + CHECK(span.length() == 5); + } + + // from const ptr and length + { +#ifdef CONFIRM_COMPILATION_ERRORS + const char* ptr = "Hello"; + string_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); +#endif + } + + // from non-const ptr and length + { + char ar[] = { 'H', 'e', 'l', 'l', 'o' }; + char* ptr = ar; + string_span<> span{ ptr, 5 }; + CHECK(span.length() == 5); + } + + // from const string + { +#ifdef CONFIRM_COMPILATION_ERRORS + const std::string str = "Hello"; + string_span<> span = str; + CHECK(span.length() == 5); +#endif + } + + // from non-const string + { + std::string str = "Hello"; + string_span<> span = str; + CHECK(span.length() == 5); + } + + // from const vector + { +#ifdef CONFIRM_COMPILATION_ERRORS + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = vec; + CHECK(span.length() == 5); +#endif + } + + // from non-const vector + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = vec; + CHECK(span.length() == 5); + } + + // from const span + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + const span<const char> inner = vec; + string_span<> span = inner; + CHECK(span.length() == 5); +#endif + } + + // from non-const span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + span<char> inner = vec; + string_span<> span = inner; + CHECK(span.length() == 5); + } + + // from non-const span of non-const data from const vector + { +#ifdef CONFIRM_COMPILATION_ERRORS + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + const span<char> inner = vec; + string_span<> span = inner; + CHECK(span.length() == 5); +#endif + } + + // from const string_span + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + cstring_span<> tmp = vec; + string_span<> span = tmp; + CHECK(span.length() == 5); +#endif + } + + // from non-const string_span + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> tmp = vec; + string_span<> span = tmp; + CHECK(span.length() == 5); + } + + // from non-const string_span from const vector + { +#ifdef CONFIRM_COMPILATION_ERRORS + const std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> tmp = vec; + string_span<> span = tmp; + CHECK(span.length() == 5); +#endif + } + + // from const string_span of non-const data + { + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + const string_span<> tmp = vec; + string_span<> span = tmp; + CHECK(span.length() == 5); + } + } + + template<typename T> + T move_wrapper(T&& t) + { + return std::move(t); + } + + template <class T> + T create() { return T{}; } + + template <class T> + void use(basic_string_span<T, gsl::dynamic_extent> s) {} + + TEST(MoveConstructors) + { + // move string_span + { + cstring_span<> span = "Hello"; + auto span1 = std::move(span); + CHECK(span1.length() == 5); + } + { + cstring_span<> span = "Hello"; + auto span1 = move_wrapper(std::move(span)); + CHECK(span1.length() == 5); + } + { + cstring_span<> span = "Hello"; + auto span1 = move_wrapper(std::move(span)); + CHECK(span1.length() == 5); + } + + // move span + { + span<const char> span = ensure_z("Hello"); + cstring_span<> span1 = std::move(span); + CHECK(span1.length() == 5); + } + { + span<const char> span = ensure_z("Hello"); + cstring_span<> span2 = move_wrapper(std::move(span)); + CHECK(span2.length() == 5); + } + + // move string + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::string str = "Hello"; + string_span<> span = std::move(str); + CHECK(span.length() == 5); +#endif + } + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::string str = "Hello"; + string_span<> span = move_wrapper<std::string>(std::move(str)); + CHECK(span.length() == 5); +#endif + } + { +#ifdef CONFIRM_COMPILATION_ERRORS + use<char>(create<string>()); +#endif + } + + // move container + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = std::move(vec); + CHECK(span.length() == 5); +#endif + } + { +#ifdef CONFIRM_COMPILATION_ERRORS + std::vector<char> vec = { 'H', 'e', 'l', 'l', 'o' }; + string_span<> span = move_wrapper<std::vector<char>>(std::move(vec)); + CHECK(span.length() == 5); +#endif + } + { +#ifdef CONFIRM_COMPILATION_ERRORS + use<char>(create<std::vector<char>>()); +#endif + } + } + + TEST(Conversion) + { +#ifdef CONFIRM_COMPILATION_ERRORS + cstring_span<> span = "Hello"; + cwstring_span<> wspan{ span }; + CHECK(wspan.length() == 5); +#endif + } + + czstring_span<> CreateTempName(string_span<> span) + { + Expects(span.size() > 1); + + int last = 0; + if (span.size() > 4) + { + span[0] = 't'; + span[1] = 'm'; + span[2] = 'p'; + last = 3; + } + span[last] = '\0'; + + auto ret = span.subspan(0, 4); + return{ ret }; + } + + TEST(zstring) + { + + // create zspan from zero terminated string + { + char buf[1]; + buf[0] = '\0'; + + zstring_span<> zspan({ buf, 1 }); + + CHECK(strlen(zspan.assume_z()) == 0); + CHECK(zspan.as_string_span().size() == 0); + CHECK(zspan.ensure_z().size() == 0); + } + + // create zspan from non-zero terminated string + { + char buf[1]; + buf[0] = 'a'; + + auto workaround_macro = [&]() { zstring_span<> zspan({ buf, 1 }); }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + // usage scenario: create zero-terminated temp file name and pass to a legacy API + { + char buf[10]; + + auto name = CreateTempName({ buf, 10 }); + if (!name.empty()) + { + czstring<> str = name.assume_z(); + CHECK(strlen(str) == 3); + CHECK(*(str+3) == '\0'); + } + } + + } + + cwzstring_span<> CreateTempNameW(wstring_span<> span) + { + Expects(span.size() > 1); + + int last = 0; + if (span.size() > 4) + { + span[0] = L't'; + span[1] = L'm'; + span[2] = L'p'; + last = 3; + } + span[last] = L'\0'; + + auto ret = span.subspan(0, 4); + return{ ret }; + } + + TEST(wzstring) + { + + // create zspan from zero terminated string + { + wchar_t buf[1]; + buf[0] = L'\0'; + + wzstring_span<> zspan({ buf, 1 }); + + CHECK(wcsnlen(zspan.assume_z(), 1) == 0); + CHECK(zspan.as_string_span().size() == 0); + CHECK(zspan.ensure_z().size() == 0); + } + + // create zspan from non-zero terminated string + { + wchar_t buf[1]; + buf[0] = L'a'; + + auto workaround_macro = [&]() { wzstring_span<> zspan({ buf, 1 }); }; + CHECK_THROW(workaround_macro(), fail_fast); + } + + // usage scenario: create zero-terminated temp file name and pass to a legacy API + { + wchar_t buf[10]; + + auto name = CreateTempNameW({ buf, 10 }); + if (!name.empty()) + { + cwzstring<> str = name.assume_z(); + CHECK(wcsnlen(str, 10) == 3); + CHECK(*(str + 3) == L'\0'); + } + } + } + + TEST(Issue305) + { + std::map<gsl::cstring_span<>, int> foo = { { "foo", 0 },{ "bar", 1 } }; + CHECK(foo["foo"] == 0); + CHECK(foo["bar"] == 1); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} diff --git a/tests/unittest-cpp b/tests/unittest-cpp new file mode 160000 +Subproject dc6b90838014ab985bf3cd74ac17ad9d00e1fbc diff --git a/tests/utils_tests.cpp b/tests/utils_tests.cpp new file mode 100644 index 0000000..9f4ba02 --- /dev/null +++ b/tests/utils_tests.cpp @@ -0,0 +1,119 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2015 Microsoft Corporation. All rights reserved. +// +// This code is licensed under the MIT License (MIT). +// +// 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#include <UnitTest++/UnitTest++.h> +#include <gsl/gsl> +#include <functional> + +using namespace gsl; + +SUITE(utils_tests) +{ + void f(int& i) + { + i += 1; + } + + TEST(finally_lambda) + { + int i = 0; + { + auto _ = finally([&]() {f(i);}); + CHECK(i == 0); + } + CHECK(i == 1); + } + + TEST(finally_lambda_move) + { + int i = 0; + { + auto _1 = finally([&]() {f(i);}); + { + auto _2 = std::move(_1); + CHECK(i == 0); + } + CHECK(i == 1); + { + auto _2 = std::move(_1); + CHECK(i == 1); + } + CHECK(i == 1); + } + CHECK(i == 1); + } + + TEST(finally_function_with_bind) + { + int i = 0; + { + auto _ = finally(std::bind(&f, std::ref(i))); + CHECK(i == 0); + } + CHECK(i == 1); + } + + int j = 0; + void g() { j += 1; }; + TEST(finally_function_ptr) + { + j = 0; + { + auto _ = finally(&g); + CHECK(j == 0); + } + CHECK(j == 1); + } + + TEST(narrow_cast) + { + int n = 120; + char c = narrow_cast<char>(n); + CHECK(c == 120); + + n = 300; + unsigned char uc = narrow_cast<unsigned char>(n); + CHECK(uc == 44); + } + + TEST(narrow) + { + int n = 120; + char c = narrow<char>(n); + CHECK(c == 120); + + n = 300; + CHECK_THROW(narrow<char>(n), narrowing_error); + + const auto int32_max = std::numeric_limits<int32_t>::max(); + const auto int32_min = std::numeric_limits<int32_t>::min(); + + CHECK(narrow<uint32_t>(int32_t(0)) == 0); + CHECK(narrow<uint32_t>(int32_t(1)) == 1); + CHECK(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max)); + + CHECK_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error); + CHECK_THROW(narrow<uint32_t>(int32_min), narrowing_error); + + n = -42; + CHECK_THROW(narrow<unsigned>(n), narrowing_error); + } +} + +int main(int, const char *[]) +{ + return UnitTest::RunAllTests(); +} |