Merge pull request #941 from JordanMaples/cmake_update

added GSL_ prefix to VS_ADD_NATIVE_VISUALIZERS
Merge pull request #942 from tjs137/patch-1
2026-08-06 13:44:09 +02:00 · 2020-10-26 10:12:40 -07:00 · 2020-10-26 10:06:20 -07:00 · 2020-10-24 19:44:06 -04:00 · 2020-10-22 15:40:27 -07:00 · 2020-10-20 10:55:05 -07:00
14 changed files with 451 additions and 263 deletions
@@ -1,4 +1,4 @@
-name: CI
+name: CI_Android
 on:
  push:
    branches: [ master ]
@@ -6,50 +6,6 @@ on:
    branches: [ master ]

 jobs:
-  iOS:
-    runs-on: macos-latest
-    defaults:
-      run:
-        working-directory: build
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Create build directory
-        run: mkdir -p build
-        working-directory: .
-
-      - name: Configure
-        run: |
-          cmake \
-            -GXcode \
-            -DCMAKE_SYSTEM_NAME=iOS \
-            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
-            -DCMAKE_OSX_DEPLOYMENT_TARGET=8 \
-            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
-            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
-            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.0.1 \
-            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.0.1 \
-            ..
-
-      - name: Build
-        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator
-
-      - name: Start simulator
-        run: |
-          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
-          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
-          xcrun simctl bootstatus $UDID -b
-
-      - name: Test
-        run: |
-          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
-          do
-            xcrun simctl install booted $TEST
-            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
-            xcrun simctl launch --console booted $TEST_ID
-            xcrun simctl uninstall booted $TEST_ID
-          done
-
  Android:
    runs-on: macos-latest
    defaults:
@@ -0,0 +1,51 @@
+name: CI_iOS
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  iOS:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Configure
+        run: |
+          cmake \
+            -GXcode \
+            -DCMAKE_SYSTEM_NAME=iOS \
+            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
+            -DCMAKE_OSX_DEPLOYMENT_TARGET=8 \
+            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
+            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.0.1 \
+            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.0.1 \
+            ..
+
+      - name: Build
+        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator
+
+      - name: Start simulator
+        run: |
+          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
+          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
+          xcrun simctl bootstatus $UDID -b
+
+      - name: Test
+        run: |
+          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
+          do
+            xcrun simctl install booted $TEST
+            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
+            xcrun simctl launch --console booted $TEST_ID
+            xcrun simctl uninstall booted $TEST_ID
+          done
@@ -70,13 +70,13 @@ endif()

 if (CMAKE_VERSION VERSION_GREATER 3.7.8)
    if (MSVC_IDE)
-        option(VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
+        option(GSL_VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
    else()
-        set(VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
+        set(GSL_VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
    endif()

    # add natvis file to the library so it will automatically be loaded into Visual Studio
-    if(VS_ADD_NATIVE_VISUALIZERS)
+    if(GSL_VS_ADD_NATIVE_VISUALIZERS)
        target_sources(GSL INTERFACE
            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/GSL.natvis>
        )
@@ -97,10 +97,18 @@ export(TARGETS GSL NAMESPACE Microsoft.GSL:: FILE Microsoft.GSLConfig.cmake)
 # last project() command. The version's compatibility is set between all
 # minor versions (as it was in prev. GSL releases).
 include(CMakePackageConfigHelpers)
-write_basic_package_version_file(
-    ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
-    COMPATIBILITY SameMajorVersion
-)
+if(${CMAKE_VERSION} VERSION_LESS "3.14.0")
+    write_basic_package_version_file(
+        ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+        COMPATIBILITY SameMajorVersion
+    )
+else()
+    write_basic_package_version_file(
+        ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+        COMPATIBILITY SameMajorVersion
+        ARCH_INDEPENDENT
+    )
+endif()
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)

 # Add Microsoft.GSL::GSL alias for GSL so that dependents can be agnostic about
@@ -5,9 +5,7 @@ The Guidelines Support Library (GSL) contains functions and types that are sugge
 [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](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support. There are specific workarounds to support MSVC 2015.
+The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support.

 While some types have been broken out into their own headers (e.g. [gsl/span](./include/gsl/span)),
 it is simplest to just include [gsl/gsl](./include/gsl/gsl) and gain access to the entire library.
@@ -21,6 +19,71 @@ This project has adopted the [Microsoft Open Source Code of Conduct](https://ope
 # Usage of Third Party Libraries
 This project makes use of the [Google Test](https://github.com/google/googletest) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Google Test.

+# Supported features
+## Microsoft GSL implements the following from the C++ Core Guidelines:
+
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+[**1. Views**][cg-views]           |            |
+owner                              | &#x2611;   | an alias for a raw pointer
+not_null                           | &#x2611;   | restricts a pointer / smart pointer to hold non-null values
+span                               | &#x2611;   | a view over a contiguous sequence of memory. Based on the standardized verison of `std::span`, however `gsl::span` enforces bounds checking. See the [wiki](https://github.com/microsoft/GSL/wiki/gsl::span-and-std::span) for additional information.
+span_p                             | &#x2610;   | spans a range starting from a pointer to the first place for which the predicate is true
+[**2. Owners**][cg-owners]         |            |
+unique_ptr                         | &#x2611;   | an alias to `std::unique_ptr`
+shared_ptr                         | &#x2611;   | an alias to `std::shared_ptr`
+stack_array                        | &#x2610;   | a stack-allocated array
+dyn_array                          | &#x2610;   | a heap-allocated array
+[**3. Assertions**][cg-assertions] |            |
+Expects                            | &#x2611;   | a precondition assertion; on failure it terminates
+Ensures                            | &#x2611;   | a postcondition assertion; on failure it terminates
+[**4. Utilities**][cg-utilities]   |            |
+move_owner                         | &#x2610;   | a helper function that moves one `owner` to the other
+byte                               | &#x2611;   | either an alias to std::byte or a byte type
+final_action                       | &#x2611;   | a RAII style class that invokes a functor on its destruction
+finally                            | &#x2611;   | a helper function instantiating `final_action`
+GSL_SUPPRESS                       | &#x2611;   | a macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]`
+[[implicit]]                       | &#x2610;   | a "marker" to put on single-argument constructors to explicitly make them non-explicit
+index                              | &#x2611;   | a type to use for all container and array indexing (currently an alias for std::ptrdiff_t)
+joining_thread                     | &#x2610;   | a RAII style version of `std::thread` that joins
+narrow                             | &#x2611;   | a checked version of narrow_cast; it can throw `narrowing_error`
+narrow_cast                        | &#x2611;   | a narrowing cast for values and a synonym for static_cast
+narrowing_error                    | &#x2611;   | a custom exception type thrown by `narrow()`
+[**5. Concepts**][cg-concepts]     | &#x2610;   |
+
+## The following features do not exist in or have been removed from the C++ Core Guidelines:
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+strict_not_null                    | &#x2611;   | A stricter version of `not_null` with explicit constructors
+multi_span                         | &#x2610;   | Deprecated. Multi-dimensional span.
+strided_span                       | &#x2610;   | Deprecated. Support for this type has been discontinued.
+basic_zstring                      | &#x2610;   | Deprecated. A pointer to a C-string (zero-terminated array) with a templated char type
+zstring                            | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char
+czstring                           | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char
+wzstring                           | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of wchar_t
+cwzstring                          | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const wchar_t
+u16zstring                         | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char16_t
+cu16zstring                        | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char16_t
+u32zstring                         | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char32_t
+cu32zstring                        | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char32_t
+basic_string_span                  | &#x2610;   | Deprecated. Like `span` but for strings with a templated char type
+string_span                        | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char
+cstring_span                       | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char
+wstring_span                       | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of wchar_t
+cwstring_span                      | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const wchar_t
+u16string_span                     | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char16_t
+cu16string_span                    | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char16_t
+u32string_span                     | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char32_t
+cu32string_span                    | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char32_t
+
+This is based on [CppCoreGuidelines semi-specification](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guidelines-support-library).
+
+[cg-views]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views
+[cg-owners]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslowner-ownership-pointers
+[cg-assertions]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslassert-assertions
+[cg-utilities]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslutil-utilities
+[cg-concepts]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslconcept-concepts
+
 # Quick Start
 ## Supported Compilers
 The GSL officially supports the current and previous major release of MSVC, GCC, Clang, and XCode's Apple-Clang.
@@ -45,8 +108,8 @@ If you successfully port GSL to another platform, we would love to hear from you

 Target | CI/CD Status
 :------- | -----------:
-iOS | ![CI](https://github.com/microsoft/GSL/workflows/CI/badge.svg)
-Android | ![CI](https://github.com/microsoft/GSL/workflows/CI/badge.svg)
+iOS | ![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg)
+Android | ![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg)

 Note: These CI/CD steps are run with each pull request, however failures in them are non-blocking.

@@ -65,7 +128,7 @@ These steps assume the source code of this repository has been cloned into a dir

 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
+        cmake -G "Visual Studio 15 2017" c:\GSL

 3. Build the test suite (in this case, in the Debug configuration, Release is another good choice).

@@ -45,7 +45,7 @@
 #if defined(__clang__)
 #define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
 #else
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && ! defined(__INTEL_COMPILER)
 #define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
 #else
 #define GSL_SUPPRESS(x)
@@ -24,7 +24,7 @@
 #if defined(__clang__)
 #define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
 #else
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && ! defined(__INTEL_COMPILER)
 #define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
 #else
 #define GSL_SUPPRESS(x)
@@ -59,8 +59,8 @@

 #ifndef GSL_USE_STD_BYTE
 #include <cstddef> /* __cpp_lib_byte */
-// this tests if we are under GCC or Clang with enough -std:c++1z power to get us std::byte
-// also check if libc++ version is sufficient (> 5.0) or libstc++ actually contains std::byte
+// this tests if we are under GCC or Clang with enough -std=c++1z power to get us std::byte
+// also check if libc++ version is sufficient (> 5.0) or libstdc++ actually contains std::byte
 #if defined(__cplusplus) && (__cplusplus >= 201703L) && \
  (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  || \
   defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_NARROW_H
+#define GSL_NARROW_H
+#include <gsl/gsl_assert> // for Expects
+#include <gsl/gsl_util> // for narrow_cast
+namespace gsl
+{
+struct narrowing_error : public std::exception
+{
+    const char* what() const noexcept override
+    {
+        return "narrowing_error";
+    }
+};
+
+// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
+template <class T, class U>
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+constexpr
+T narrow(U u) noexcept(false)
+{
+    constexpr const bool is_different_signedness = (std::is_signed<T>::value != std::is_signed<U>::value);
+
+    const T t = narrow_cast<T>(u);
+
+    if (static_cast<U>(t) != u
+        || (is_different_signedness
+            && ((t < T{}) != (u < U{}))))
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+}
+#endif // GSL_NARROW_H
@@ -32,6 +32,12 @@

 #endif            // _MSC_VER

+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+#define GSL_NODISCARD [[nodiscard]]
+#else
+#define GSL_NODISCARD
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
+
 namespace gsl
 {
 //
@@ -46,6 +52,8 @@ template <class F>
 class final_action
 {
 public:
+    static_assert(!std::is_reference<F>::value && !std::is_const<F>::value && !std::is_volatile<F>::value, "Final_action should store its callable by value");
+
    explicit final_action(F f) noexcept : f_(std::move(f)) {}

    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false)) {}
@@ -67,15 +75,9 @@ private:

 // finally() - convenience function to generate a final_action
 template <class F>
-final_action<F> finally(const F& f) noexcept
+GSL_NODISCARD final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type> finally(F&& f) noexcept
 {
-    return final_action<F>(f);
-}
-
-template <class F>
-final_action<F> finally(F&& f) noexcept
-{
-    return final_action<F>(std::forward<F>(f));
+    return final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>(std::forward<F>(f));
 }

 // narrow_cast(): a searchable way to do narrowing casts of values
@@ -86,33 +88,6 @@ constexpr T narrow_cast(U&& u) noexcept
    return static_cast<T>(std::forward<U>(u));
 }

-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>
-    {
-    };
-} // namespace details
-
-// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-template <class T, class U>
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
-constexpr
-T narrow(U u) noexcept(false)
-{
-    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 builtin arrays, std::array, std::vector
 //
@@ -50,11 +50,6 @@
 #pragma warning(disable : 26465) // TODO: bug - suppression does not work on template functions
 #pragma warning(disable : 4996)  // use of function or classes marked [[deprecated]]

-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif // _MSC_VER < 1910
 #endif // _MSC_VER

 #if defined(__GNUC__) || defined(__clang__)
@@ -2252,11 +2247,6 @@ general_span_iterator<Span> operator+(typename general_span_iterator<Span>::diff
 } // namespace gsl

 #if defined(_MSC_VER) && !defined(__clang__)
-#if _MSC_VER < 1910
-
-#undef constexpr
-#pragma pop_macro("constexpr")
-#endif // _MSC_VER < 1910

 #pragma warning(pop)

@@ -25,12 +25,6 @@
 #include <system_error> // for hash
 #include <type_traits>  // for enable_if_t, is_convertible, is_assignable

-#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif                          // defined(_MSC_VER) && _MSC_VER < 1910
-
 namespace gsl
 {

@@ -69,7 +63,7 @@ template <class T>
 class not_null
 {
 public:
-    static_assert(std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr.");
+    static_assert(std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value, "T cannot be compared to nullptr.");

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
@@ -78,7 +72,7 @@ public:
    }

    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr not_null(T u) : ptr_(u)
+    constexpr not_null(T u) : ptr_(std::move(u))
    {
        Expects(ptr_ != nullptr);
    }
@@ -90,15 +84,14 @@ public:

    not_null(const not_null& other) = default;
    not_null& operator=(const not_null& other) = default;
-
-    constexpr T get() const
+    constexpr std::conditional_t<std::is_copy_constructible<T>::value, T, const T&> get() const
    {
        Ensures(ptr_ != nullptr);
        return ptr_;
    }

    constexpr operator T() const { return get(); }
-    constexpr T operator->() const { return get(); }
+    constexpr decltype(auto) operator->() const { return get(); }
    constexpr decltype(auto) operator*() const { return *get(); }

    // prevents compilation when someone attempts to assign a null pointer constant
@@ -119,7 +112,7 @@ private:
 };

 template <class T>
-auto make_not_null(T&& t) {
+auto make_not_null(T&& t) noexcept {
    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }

@@ -131,37 +124,37 @@ std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
 }

 template <class T, class U>
-auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() == rhs.get())
+auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get())) -> decltype(lhs.get() == rhs.get())
 {
    return lhs.get() == rhs.get();
 }

 template <class T, class U>
-auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() != rhs.get())
+auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get())) -> decltype(lhs.get() != rhs.get())
 {
    return lhs.get() != rhs.get();
 }

 template <class T, class U>
-auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() < rhs.get())
+auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get())) -> decltype(lhs.get() < rhs.get())
 {
    return lhs.get() < rhs.get();
 }

 template <class T, class U>
-auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() <= rhs.get())
+auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get())) -> decltype(lhs.get() <= rhs.get())
 {
    return lhs.get() <= rhs.get();
 }

 template <class T, class U>
-auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() > rhs.get())
+auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get())) -> decltype(lhs.get() > rhs.get())
 {
    return lhs.get() > rhs.get();
 }

 template <class T, class U>
-auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) -> decltype(lhs.get() >= rhs.get())
+auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get())) -> decltype(lhs.get() >= rhs.get())
 {
    return lhs.get() >= rhs.get();
 }
@@ -183,7 +176,7 @@ namespace std
 template <class T>
 struct hash<gsl::not_null<T>>
 {
-    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value); }
+    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value.get()); }
 };

 } // namespace std
@@ -267,7 +260,7 @@ template <class T>
 strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;

 template <class T>
-auto make_strict_not_null(T&& t) {
+auto make_strict_not_null(T&& t) noexcept {
    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }

@@ -286,16 +279,9 @@ namespace std
 template <class T>
 struct hash<gsl::strict_not_null<T>>
 {
-    std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value); }
+    std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value.get()); }
 };

 } // namespace std

-#if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // defined(_MSC_VER) && _MSC_VER < 1910 && !defined(__clang__)
-
 #endif // GSL_POINTERS_H
@@ -19,6 +19,7 @@

 #include <gsl/gsl_assert> // for Expects
 #include <gsl/gsl_byte>   // for byte
+#include <gsl/gsl_util>   // for narrow_cast

 #include <array>       // for array
 #include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
@@ -60,7 +61,7 @@ namespace gsl
 {

 // [views.constants], constants
-constexpr const std::size_t dynamic_extent = static_cast<std::size_t>(-1);
+constexpr const std::size_t dynamic_extent = narrow_cast<std::size_t>(-1);

 template <class ElementType, std::size_t Extent = dynamic_extent>
 class span;
@@ -100,7 +101,7 @@ namespace details

    template <std::size_t From, std::size_t To>
    struct is_allowed_extent_conversion
-        : std::integral_constant<bool, From == To || To == gsl::dynamic_extent>
+        : std::integral_constant<bool, From == To || To == dynamic_extent>
    {
    };

@@ -421,26 +422,26 @@ public:
    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
    {}

-    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != gsl::dynamic_extent, int> = 0>
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
    {
        Expects(count == Extent);
    }

-    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == gsl::dynamic_extent, int> = 0>
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
    {}

-    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != gsl::dynamic_extent, int> = 0>
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
-        : storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
    {
        Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
    }

-    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == gsl::dynamic_extent, int> = 0>
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
    constexpr span(pointer firstElem, pointer lastElem) noexcept
-        : storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
    {}

    template <std::size_t N,
@@ -19,14 +19,14 @@

 #include <gsl/gsl_assert> // for Ensures, Expects
 #include <gsl/gsl_util>   // for narrow_cast
-#include <gsl/span_ext>       // for operator!=, operator==, dynamic_extent
+#include <gsl/span_ext>   // for operator!=, operator==, dynamic_extent

 #include <algorithm> // for equal, lexicographical_compare
 #include <array>     // for array
 #include <cstddef>   // for size_t, nullptr_t
 #include <cstdint>   // for PTRDIFF_MAX
 #include <cstring>
-#include <string>    // for basic_string, allocator, char_traits
+#include <string>      // for basic_string, allocator, char_traits
 #include <type_traits> // for declval, is_convertible, enable_if_t, add_...

 #if defined(_MSC_VER) && !defined(__clang__)
@@ -35,8 +35,13 @@
 // Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
 #pragma warning(disable : 26446) // TODO: bug in parser - attributes and templates
 #pragma warning(disable : 26481) // TODO: suppress does not work inside templates sometimes
+#pragma warning(disable : 4996)  // use of functions & classes marked [[deprecated]]
+#endif                           // _MSC_VER

-#endif // _MSC_VER
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif

 namespace gsl
 {
@@ -52,36 +57,55 @@ namespace gsl
 //

 template <typename CharT, std::size_t Extent = dynamic_extent>
-using basic_zstring = CharT*;
+using basic_zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] = CharT*;

 template <std::size_t Extent = dynamic_extent>
-using czstring = basic_zstring<const char, Extent>;
+using czstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                            "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cwzstring = basic_zstring<const wchar_t, Extent>;
+using cwzstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                             "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu16zstring = basic_zstring<const char16_t, Extent>;
+using cu16zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu32zstring = basic_zstring<const char32_t, Extent>;
+using cu32zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char32_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using zstring = basic_zstring<char, Extent>;
+using zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                           "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using wzstring = basic_zstring<wchar_t, Extent>;
+using wzstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                            "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u16zstring = basic_zstring<char16_t, Extent>;
+using u16zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                              "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u32zstring = basic_zstring<char32_t, Extent>;
+using u32zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                              "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char32_t, Extent>;

 namespace details
 {
    template <class CharT>
-    std::size_t string_length(const CharT* str, std::size_t n)
+    [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+                 "isocpp/CppCoreGuidelines PR#1680")]] constexpr std::size_t
+    string_length(const CharT* str, std::size_t n)
    {
        if (str == nullptr || n == dynamic_extent) return 0;

@@ -103,73 +127,87 @@ namespace details
 // 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::size_t max = static_cast<std::size_t>(-1))
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<T, dynamic_extent>
+ensure_sentinel(T* seq, std::size_t max = static_cast<std::size_t>(-1))
 {
    Ensures(seq != nullptr);

-    GSL_SUPPRESS(
-        f.23) // NO-FORMAT: attribute // TODO: false positive // TODO: suppress does not work
+    // clang-format off
+    GSL_SUPPRESS(f.23) // TODO: false positive // TODO: suppress does not work
+    // clang-format on
    auto cur = seq;
    Ensures(cur != nullptr); // workaround for removing the warning

-    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute // TODO: suppress does not work
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // TODO: suppress does not work
+    // clang-format on
    while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;
    Ensures(*cur == Sentinel);
    return {seq, static_cast<std::size_t>(cur - seq)};
 }

 //
-// ensure_z - creates a span for a zero terminated strings.
-// Will fail fast if a null-terminator cannot be found before
-// the limit of size_type.
+// ensure_z - creates a span for a zero terminated strings. The span will not contain the zero
+// termination. Will fail fast if a null-terminator cannot be found before the limit of size_type.
 //
 template <typename CharT>
-span<CharT, dynamic_extent> ensure_z(CharT* const& sz,
-                                     std::size_t max = static_cast<std::size_t>(-1))
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<CharT, dynamic_extent>
+ensure_z(CharT* const& sz, std::size_t max = static_cast<std::size_t>(-1))
 {
    return ensure_sentinel<CharT, CharT(0)>(sz, max);
 }

 template <typename CharT, std::size_t N>
-span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
+constexpr span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
 {
    return ensure_z(&sz[0], N);
 }

 template <class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
+[[deprecated(
+    "string_span was removed from the C++ Core Guidelines. For more information, see "
+    "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<typename std::
+                                                             remove_pointer<
+                                                                 typename Cont::pointer>::type,
+                                                         dynamic_extent>
 ensure_z(Cont& cont)
 {
    return ensure_z(cont.data(), cont.size());
 }

 template <typename CharT, std::size_t>
-class basic_string_span;
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span;

 namespace details
 {
    template <typename T>
-    struct is_basic_string_span_oracle : std::false_type
-    {
-    };
+    struct [
+        [deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                    "see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle
+        : std::false_type{};

    template <typename CharT, std::size_t Extent>
-    struct is_basic_string_span_oracle<basic_string_span<CharT, Extent>> : std::true_type
-    {
-    };
+    struct [[deprecated(
+        "string_span was removed from the C++ Core Guidelines. For more information, see "
+        "isocpp/CppCoreGuidelines PR#1680")]] 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>>
-    {
-    };
+    struct [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                        "information, see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span
+        : is_basic_string_span_oracle<std::remove_cv_t<T>>{};
 } // namespace details

 //
 // string_span and relatives
 //
 template <typename CharT, std::size_t Extent = dynamic_extent>
-class basic_string_span
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span
 {
 public:
    using element_type = CharT;
@@ -198,11 +236,11 @@ public:
    // 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 <std::size_t N>
-    constexpr basic_string_span(element_type (&arr)[N]) : span_(remove_z(arr))
+    constexpr basic_string_span(element_type(&arr)[N]) : span_(remove_z(arr))
    {}

    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
-    constexpr basic_string_span(std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
+    constexpr basic_string_span(std::array<ArrayElementType, N> & arr) noexcept : span_(arr)
    {}

    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
@@ -211,8 +249,8 @@ public:

    // Container signature should work for basic_string after C++17 version exists
    template <class Traits, class Allocator>
-    // GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute // TODO: parser bug
-    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator>& str)
+    // GSL_SUPPRESS(bounds.4) // TODO: parser bug
+    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator> & str)
        : span_(&str[0], str.length())
    {}

@@ -228,7 +266,7 @@ public:
                  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)
+    constexpr basic_string_span(Container & cont) : span_(cont)
    {}

    template <class Container,
@@ -277,8 +315,8 @@ public:
        return {span_.template subspan<Offset, Count>()};
    }

-    constexpr basic_string_span<element_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const
+    constexpr basic_string_span<element_type, dynamic_extent> subspan(
+        size_type offset, size_type count = dynamic_extent) const
    {
        return {span_.subspan(offset, count)};
    }
@@ -301,13 +339,13 @@ public:
    constexpr reverse_iterator rend() const noexcept { return span_.rend(); }

 private:
-    static impl_type remove_z(pointer const& sz, std::size_t max)
+    static constexpr impl_type remove_z(pointer const& sz, std::size_t max)
    {
        return impl_type(sz, details::string_length(sz, max));
    }

    template <std::size_t N>
-    static impl_type remove_z(element_type (&sz)[N])
+    static constexpr impl_type remove_z(element_type(&sz)[N])
    {
        return remove_z(&sz[0], N);
    }
@@ -316,35 +354,51 @@ private:
 };

 template <std::size_t Extent = dynamic_extent>
-using string_span = basic_string_span<char, Extent>;
+using string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cstring_span = basic_string_span<const char, Extent>;
+using cstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using wstring_span = basic_string_span<wchar_t, Extent>;
+using wstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cwstring_span = basic_string_span<const wchar_t, Extent>;
+using cwstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u16string_span = basic_string_span<char16_t, Extent>;
+using u16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu16string_span = basic_string_span<const char16_t, Extent>;
+using cu16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u32string_span = basic_string_span<char32_t, Extent>;
+using u32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char32_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu32string_span = basic_string_span<const char32_t, Extent>;
+using cu32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char32_t, Extent>;

 //
 // to_string() allow (explicit) conversions from string_span to string
 //

 template <typename CharT, std::size_t Extent>
-std::basic_string<typename std::remove_const<CharT>::type>
+constexpr std::basic_string<typename std::remove_const<CharT>::type>
 to_string(basic_string_span<CharT, Extent> view)
 {
    return {view.data(), narrow_cast<std::size_t>(view.length())};
@@ -352,32 +406,38 @@ to_string(basic_string_span<CharT, Extent> view)

 template <typename CharT, typename Traits = typename std::char_traits<CharT>,
          typename Allocator = std::allocator<CharT>, typename gCharT, std::size_t Extent>
-std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view)
+constexpr std::basic_string<CharT, Traits, Allocator>
+to_basic_string(basic_string_span<gCharT, Extent> view)
 {
    return {view.data(), narrow_cast<std::size_t>(view.length())};
 }

 template <class ElementType, std::size_t Extent>
-basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
-    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }

 template <class ElementType, std::size_t Extent,
          class = std::enable_if_t<!std::is_const<ElementType>::value>>
-basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writable_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
-    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
 }

 // zero-terminated string span, used to convert
 // zero-terminated spans to legacy strings
 template <typename CharT, std::size_t Extent = dynamic_extent>
-class basic_zstring_span
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_zstring_span
 {
 public:
    using value_type = CharT;
@@ -395,14 +455,15 @@ public:
    constexpr basic_zstring_span(impl_type s) : span_(s)
    {
        // expects a zero-terminated span
-        Expects(s[s.size() - 1] == '\0');
+        Expects(s.size() > 0);
+        Expects(s[s.size() - 1] == value_type{});
    }

    // copy
    constexpr basic_zstring_span(const basic_zstring_span& other) = default;

    // move
-    constexpr basic_zstring_span(basic_zstring_span&& other) = default;
+    constexpr basic_zstring_span(basic_zstring_span && other) = default;

    // assign
    constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;
@@ -410,12 +471,11 @@ public:
    // move assign
    constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;

-    constexpr bool empty() const noexcept { return span_.size() == 0; }
+    constexpr bool empty() const noexcept { return false; }

    constexpr string_span_type as_string_span() const noexcept
    {
-        const auto sz = span_.size();
-        return {span_.data(), sz > 1 ? sz - 1 : 0};
+        return {span_.data(), span_.size() - 1};
    }
    constexpr string_span_type ensure_z() const { return gsl::ensure_z(span_); }

@@ -426,28 +486,44 @@ private:
 };

 template <std::size_t Max = dynamic_extent>
-using zstring_span = basic_zstring_span<char, Max>;
+using zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char, Max>;

 template <std::size_t Max = dynamic_extent>
-using wzstring_span = basic_zstring_span<wchar_t, Max>;
+using wzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<wchar_t, Max>;

 template <std::size_t Max = dynamic_extent>
-using u16zstring_span = basic_zstring_span<char16_t, Max>;
+using u16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char16_t, Max>;

 template <std::size_t Max = dynamic_extent>
-using u32zstring_span = basic_zstring_span<char32_t, Max>;
+using u32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char32_t, Max>;

 template <std::size_t Max = dynamic_extent>
-using czstring_span = basic_zstring_span<const char, Max>;
+using czstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char, Max>;

 template <std::size_t Max = dynamic_extent>
-using cwzstring_span = basic_zstring_span<const wchar_t, Max>;
+using cwzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const wchar_t, Max>;

 template <std::size_t Max = dynamic_extent>
-using cu16zstring_span = basic_zstring_span<const char16_t, Max>;
+using cu16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char16_t, Max>;

 template <std::size_t Max = dynamic_extent>
-using cu32zstring_span = basic_zstring_span<const char32_t, Max>;
+using cu32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char32_t, Max>;

 // operator ==
 template <class CharT, std::size_t Extent, class T,
@@ -471,7 +547,7 @@ bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other
 }

 // operator !=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = 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)
@@ -480,7 +556,7 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename = 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>>
@@ -490,7 +566,7 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 }

 // operator<
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = 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)
@@ -500,7 +576,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename = 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>>
@@ -516,7 +592,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -530,7 +606,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -545,7 +621,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif

 // operator <=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = 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)
@@ -554,7 +630,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename = 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>>
@@ -569,7 +645,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -582,7 +658,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -596,7 +672,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif

 // operator>
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = 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)
@@ -605,7 +681,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename = 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>>
@@ -620,7 +696,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -633,7 +709,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -647,7 +723,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif

 // operator >=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = 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)
@@ -656,7 +732,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename = 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>>
@@ -671,7 +747,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -684,7 +760,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }

 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
    typename DataType = typename T::value_type,
    typename = std::enable_if_t<
        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -703,4 +779,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)

 #endif // _MSC_VER

+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
 #endif // GSL_STRING_SPAN_H
@@ -1,37 +1,42 @@
 cmake_minimum_required(VERSION 3.0.2)

 project(GSLTests CXX)
+include(FindPkgConfig)

 # will make visual studio generated project group files
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)

-configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
-execute_process(
-    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
-)
-if(result)
-    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+pkg_search_module(GTestMain gtest_main)
+if (NOT GTestMain_FOUND)
+    configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} --build .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    set(GTestMain_LIBRARIES gtest_main)
+
+    add_subdirectory(
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+        EXCLUDE_FROM_ALL
+    )
 endif()

-execute_process(
-    COMMAND ${CMAKE_COMMAND} --build .
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
-)
-if(result)
-    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-endif()
-
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
-add_subdirectory(
-    ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
-    EXCLUDE_FROM_ALL
-)
-
 if (MSVC AND (GSL_CXX_STANDARD EQUAL 17))
    set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
 endif()
@@ -149,7 +154,7 @@ function(add_gsl_test name)
    target_link_libraries(${name}
        GSL
        gsl_tests_config
-        gtest_main
+        ${GTestMain_LIBRARIES}
    )
    add_test(
        ${name}
@@ -254,7 +259,7 @@ function(add_gsl_test_noexcept name)
    target_link_libraries(${name}
        GSL
        gsl_tests_config_noexcept
-        gtest_main
+        ${GTestMain_LIBRARIES}
    )
    add_test(
      ${name}
@@ -16,8 +16,8 @@

 #include <gtest/gtest.h>

-#include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...
-
+#include <gsl/gsl_util>     // finally, narrow_cast
+#include <gsl/gsl_narrow>   // for narrow, narrowing_error
 #include <algorithm>   // for move
 #include <functional>  // for reference_wrapper, _Bind_helper<>::type
 #include <limits>      // for numeric_limits
@@ -70,6 +70,28 @@ TEST(utils_tests, finally_lambda_move)
    EXPECT_TRUE(i == 1);
 }

+TEST(utils_tests, finally_const_lvalue_lambda)
+{
+    int i = 0;
+    {
+        const auto const_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(const_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_mutable_lvalue_lambda)
+{
+    int i = 0;
+    {
+        auto mutable_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(mutable_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
 TEST(utils_tests, finally_function_with_bind)
 {
    int i = 0;
Author	SHA1	Message	Date
Jordan Maples [MSFT]	6f4529395c	Merge pull request #941 from JordanMaples/cmake_update added GSL_ prefix to VS_ADD_NATIVE_VISUALIZERS	2020-10-26 10:12:40 -07:00
Jordan Maples [MSFT]	9fa2c5d5b9	Merge pull request #942 from tjs137/patch-1 use `narrow_cast`	2020-10-26 10:06:20 -07:00
tjs137	8009a703c2	use `narrow_cast`	2020-10-24 19:44:06 -04:00
Jordan Maples	cfb4db0c1e	added GSL_ prefix to VS_ADD_NATIVE_VISUALIZERS	2020-10-22 15:40:27 -07:00
Jordan Maples [MSFT]	6432f920ea	Merge pull request #937 from beinhaerter/cast_warning eliminate warning, use narrow_cast instead of static_cast	2020-10-20 10:55:05 -07:00
beinhaerter	2af9b11fe9	Update include/gsl/span Co-authored-by: Jordan Maples [MSFT] <49793787+JordanMaples@users.noreply.github.com>	2020-10-20 00:44:11 +02:00
beinhaerter	dc6fdff4c0	Update include/gsl/span Co-authored-by: Jordan Maples [MSFT] <49793787+JordanMaples@users.noreply.github.com>	2020-10-20 00:44:02 +02:00
Werner Henze	2ccf36b4b9	eliminate warning, use narrow_cast instead of static_cast	2020-10-14 15:04:50 +02:00
Jordan Maples [MSFT]	bd23bdc0ad	Merge pull request #931 from JordanMaples/deprecate-string_span Deprecate string_span	2020-10-02 12:36:09 -07:00
Jordan Maples	1665f07cf6	updating readme to reflect the deprecation of string_span	2020-10-01 14:38:41 -07:00
Jordan Maples	3f68a0034a	fixed botched formatting	2020-10-01 14:16:01 -07:00
Jordan Maples	7721de88f3	ran clang-format over string_span	2020-10-01 14:08:01 -07:00
Jordan Maples	a64c489c78	added deprecation message	2020-10-01 14:04:04 -07:00
Jordan Maples	5e773556fe	initial deprecation of all types in string_span	2020-09-30 16:39:33 -07:00
Jordan Maples [MSFT]	5de956aaf0	Merge pull request #929 from JordanMaples/yml_experiment split GitHub action into multiple files.	2020-09-23 14:23:52 -07:00
Jordan Maples [MSFT]	bd803cc7cf	Merge pull request #928 from JordanMaples/narrowing_error-add-what add what to narrowing_error	2020-09-14 16:51:38 -07:00
Jordan Maples	e7e3bf4f5f	add what to narrowing_error	2020-09-14 15:50:46 -07:00
Jordan Maples [MSFT]	21b69e5cce	Updating span section of Supported Features table. Added a link to the span section to point to the "gsl::span and std::span" page in the wiki.	2020-08-28 10:53:19 -07:00
Jordan Maples [MSFT]	d58e50c6f4	Merge pull request #922 from JordanMaples/constexpr-string_span constexpr string_span	2020-08-27 14:29:30 -07:00
Jordan Maples	5fb0c8611e	constexpr string_span stuff	2020-08-27 13:21:35 -07:00
Jordan Maples [MSFT]	6c518638ac	Merge pull request #921 from JordanMaples/not_null-changes not_null improvements	2020-08-26 17:48:26 -07:00
Jordan Maples	4a4bb3c13a	adding changes suggested by Jonathan Wakely	2020-08-26 16:51:58 -07:00
Jordan Maples [MSFT]	b6451c5db0	Merge pull request #920 from macjohnny/patch-1 fix typo in readme	2020-08-24 09:27:02 -07:00
Esteban Gehring	81957f6f91	fix typo in readme	2020-08-24 15:17:30 +02:00
Jordan Maples [MSFT]	6aa755e9ce	Merge pull request #913 from jwakely/notnull_hash Pass correct value to std::hash	2020-08-20 15:32:22 -07:00
Jordan Maples [MSFT]	e426750695	Merge pull request #720 from menuet/fix-finally Fix finally when passing a non const lvalue invokable thing	2020-08-17 09:10:50 -07:00
Pascal Menuet	c25a7544b8	Fix finally with mutable lvalue invokable	2020-08-14 16:24:10 +02:00
Jordan Maples [MSFT]	06c46195ee	Merge pull request #910 from JordanMaples/exception_fix_new_file exception free - Version 2	2020-08-13 16:35:04 -07:00
Jordan Maples [MSFT]	83ce710d6c	Merge pull request #807 from kuzkry/implemented_features Add a table of features	2020-08-13 09:34:31 -07:00
Jordan Maples [MSFT]	ec471abe44	Merge pull request #912 from jwakely/patch-1 Fix comment typos	2020-08-13 09:30:31 -07:00
Jordan Maples	dad3d80c25	Update README.md Rearranged and updated the table. Added a second table of concepts that exist in the Microsoft GSL that do not exist in the C++ Core Guidelines	2020-08-13 15:35:46 +02:00
Krystian Kuzniarek	a9ffcf7f65	add a table of features	2020-08-13 15:35:45 +02:00
Jonathan Wakely	e09326eefd	Pass correct value to std::hash	2020-08-13 12:59:01 +01:00
Jonathan Wakely	d09f1544fd	Fix comment typos	2020-08-13 10:46:39 +01:00
Jordan Maples	74968d3ef8	Merge branch 'master' into exception_fix_new_file	2020-08-12 17:14:13 -07:00
Jordan Maples [MSFT]	0c80f51f7c	Merge pull request #908 from JordanMaples/fix_nodiscard_in_finally_macro Finally [[nodiscard]] - Version 2	2020-08-12 15:49:55 -07:00
Jordan Maples [MSFT]	ef714fa49e	Merge pull request #676 from ericLemanissier/patch-3 fix requirement on not_null template	2020-08-12 15:28:25 -07:00
Jordan Maples [MSFT]	9355982fc5	Merge pull request #868 from mymedia2/master Search for GoogleTest via pkg-config first	2020-08-12 15:08:54 -07:00
Jordan Maples	4da6a264c4	forgot newline at eof.	2020-08-12 13:22:33 -07:00
Jordan Maples	2469db7a5a	add copyright header	2020-08-12 13:14:53 -07:00
Jordan Maples	afe824490e	change macro test to use __cplusplus instead of __has_cpp_attribute	2020-08-12 12:13:19 -07:00
Jordan Maples	72ddfb7a40	created new file for gsl_narrow, might want to rename if we go this approach to have all exception prone logic to live here	2020-08-11 17:11:14 -07:00
Jordan Maples	bf0697be71	update readme to have the correct asset badges. This will render correctly when it's merged into the main repo	2020-08-11 16:46:41 -07:00
Jordan Maples	97cb97c685	readme update for the updated badges	2020-08-11 16:30:48 -07:00
Jordan Maples	13f57a1e70	update ci names	2020-08-11 16:28:37 -07:00
Jordan Maples	c482c82d3a	experimenting with splitting the yml files into their own runs	2020-08-11 16:08:16 -07:00
Jordan Maples	01eaf5bef1	macro version	2020-08-10 16:45:47 -07:00
Jordan Maples [MSFT]	63379b7935	Merge pull request #850 from beinhaerter/zstring_ctor zstring_span: fix for Expects, simplify functions	2020-08-06 10:28:02 -07:00
Werner Henze	2231d733c6	zstring_span: fix for Expects, simplify functions - `s[s.size() - 1]` is wrong for empty `s`, so `Expects(s.size() > 0)` - no hard coded `'\0'`but `value_type{}` - hard code `empty()` to return `false` - simplify `as_string_span`: can never be `empty` - clarify comment on `ensure_z`	2020-08-06 11:25:29 +02:00
Jordan Maples [MSFT]	f8d9f2e2e3	Merge pull request #906 from TManhente/intel_suppress_fix Fix GSL_SUPPRESS definition on Intel C++ Compiler	2020-08-05 15:35:26 -07:00
Jordan Maples [MSFT]	552eedb390	Merge pull request #881 from robert-andrzejuk/patch-1 Refactor `narrow`.	2020-08-05 15:16:25 -07:00
Thiago M. de C. Marques	ca3bf7710f	Fix GSL_SUPPRESS definition on Intel C++ Compiler Intel C++ Compiler defines the `_MSC_VER` macro, but it doesn't support `[[gsl::*]]` attributes.	2020-08-05 18:30:24 -03:00
Jordan Maples [MSFT]	559f8cfaae	Merge pull request #899 from JordanMaples/dev/jomaples/cleanup_namespaces cleanup gsl namespace qualification for dynamic_extent.	2020-07-15 14:56:54 -07:00
Jordan Maples [MSFT]	f79ed1bb5c	Merge pull request #876 from beinhaerter/make_notnull_noexcept noexcept for make_(strict_)not_null and not_null comparisons	2020-07-15 14:36:17 -07:00
Jordan Maples [MSFT]	bf6e103dfd	Merge pull request #898 from JordanMaples/dev/jomaples/remove_pragma_push_pop Remove msvc < 1910 checks.	2020-07-15 14:00:29 -07:00
Jordan Maples	4c66cea06c	remove gsl namespace qualification within the gsl namespace	2020-07-15 13:11:57 -07:00
Jordan Maples	478d876951	remove pragma pop for constexpr macro	2020-07-15 11:43:29 -07:00
Jordan Maples	853b061141	remove msvc < 1910 checks as those versions are no longer supported.	2020-07-15 11:38:41 -07:00
Jordan Maples [MSFT]	301030310e	Merge pull request #897 from microsoft/JordanMaples-patch-1 Update README.md	2020-07-07 10:58:04 -07:00
Jordan Maples [MSFT]	be3bc0e754	Update README.md Removed the line saying that specific workarounds exist for MSVC 2015 as they were removed in #886 when support for MSVC 2015 was dropped.	2020-07-06 08:22:35 -07:00
Jordan Maples [MSFT]	98002ab601	Merge pull request #893 from xvitaly/fix-noarch Added ARCH_INDEPENDENT parameter to write_basic_package_version_file()	2020-06-10 11:09:31 -07:00
Vitaly Zaitsev	cfe9baf02e	Added ARCH_INDEPENDENT parameter to write_basic_package_version_file(). Signed-off-by: Vitaly Zaitsev <vitaly@easycoding.org>	2020-06-07 16:02:27 +02:00
Robert Andrzejuk	84847041ee	In `narrow` refactor `!is_same_signedness` to `is_different_signedness`	2020-04-29 20:39:44 +02:00
Robert Andrzejuk	1e5f44d3ea	Refactor `narrow` - simplify & move `is_same_signedness` into function, remove uneeded `detail` namespace. Merge 2 `if`'s with a `\|\|`.	2020-04-29 20:11:44 +02:00
Werner Henze	29297e7dac	noexcept for make_(strict_)not_null and not_null comparisons	2020-04-27 14:42:56 +02:00
Nicholas Guriev	f5cf01083b	Search for GoogleTest via pkg-config first	2020-04-18 13:30:17 +03:00
ericLemanissier	423841e965	fix requirement on not_null template it should be comparable to nullptr, it does not have to be assignable	2018-05-03 08:08:41 +02:00