para/GSL
1
0
Fork 0
mirror of https://github.com/microsoft/GSL.git synced 2024-11-03 17:56:43 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Partway through removing configurable SizeType.

Browse Source
This commit is contained in:
Neil MacIntosh 2015-10-15 14:29:35 -07:00
parent e0d10d1d1c
commit f45fedbec2
4 changed files with 411 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

702
include/array_view.h
View File

File diff suppressed because it is too large Load Diff

39
include/string_view.h
View File

@ -34,16 +34,16 @@ namespace gsl
// type system for these types that will not either incur significant runtime costs or // type system for these types that will not either incur significant runtime costs or
// (sometimes needlessly) break existing programs when introduced. // (sometimes needlessly) break existing programs when introduced.
// //
template<size_t Max = dynamic_range> template<std::ptrdiff_t Max = dynamic_range>
using czstring = const char*; using czstring = const char*;
template<size_t Max = dynamic_range> template<std::ptrdiff_t Max = dynamic_range>
using cwzstring = const wchar_t*; using cwzstring = const wchar_t*;
template<size_t Max = dynamic_range> template<std::ptrdiff_t Max = dynamic_range>
using zstring = char*; using zstring = char*;
template<size_t Max = dynamic_range> template<std::ptrdiff_t Max = dynamic_range>
using wzstring = wchar_t*; using wzstring = wchar_t*;
// //
@ -54,19 +54,19 @@ using wzstring = wchar_t*;
// //
// TODO (neilmac) once array_view regains configurable size_type, update these typedef's // TODO (neilmac) once array_view regains configurable size_type, update these typedef's
// //
template <class CharT, size_t Extent = dynamic_range> template <class CharT, std::ptrdiff_t Extent = dynamic_range>
using basic_string_view = array_view<CharT, Extent>; using basic_string_view = array_view<CharT, Extent>;
template<size_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using string_view = basic_string_view<char, Extent>; using string_view = basic_string_view<char, Extent>;
template<size_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using cstring_view = basic_string_view<const char, Extent>; using cstring_view = basic_string_view<const char, Extent>;
template<size_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using wstring_view = basic_string_view<wchar_t, Extent>; using wstring_view = basic_string_view<wchar_t, Extent>;
template<size_t Extent = dynamic_range> template<std::ptrdiff_t Extent = dynamic_range>
using cwstring_view = basic_string_view<const wchar_t, Extent>; using cwstring_view = basic_string_view<const wchar_t, Extent>;
@ -94,38 +94,39 @@ array_view<T, dynamic_range> ensure_sentinel(const T* seq, SizeType max = std::n
// the limit of size_type. // the limit of size_type.
// //
template<class T> template<class T>
inline basic_string_view<T, dynamic_range> ensure_z(T* const & sz, size_t max = std::numeric_limits<size_t>::max()) inline basic_string_view<T, dynamic_range> ensure_z(T* const & sz, std::ptrdiff_t max = PTRDIFF_MAX)
{ {
return ensure_sentinel<0>(sz, max); return ensure_sentinel<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 // TODO (neilmac) there is probably a better template-magic way to get the const and non-const overloads to share an implementation
inline basic_string_view<char, dynamic_range> ensure_z(char* const & sz, size_t max) inline basic_string_view<char, dynamic_range> ensure_z(char* const& sz, std::ptrdiff_t max)
{ {
auto len = strnlen(sz, max); auto len = strnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, len }; fail_fast_assert(sz[len] == 0);
return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<const char, dynamic_range> ensure_z(const char* const& sz, size_t max) inline basic_string_view<const char, dynamic_range> ensure_z(const char* const& sz, std::ptrdiff_t max)
{ {
auto len = strnlen(sz, max); auto len = strnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, len }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<wchar_t, dynamic_range> ensure_z(wchar_t* const & sz, size_t max) inline basic_string_view<wchar_t, dynamic_range> ensure_z(wchar_t* const& sz, std::ptrdiff_t max)
{ {
auto len = wcsnlen(sz, max); auto len = wcsnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, len }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
inline basic_string_view<const wchar_t, dynamic_range> ensure_z(const wchar_t* const & sz, size_t max) inline basic_string_view<const wchar_t, dynamic_range> ensure_z(const wchar_t* const& sz, std::ptrdiff_t max)
{ {
auto len = wcsnlen(sz, max); auto len = wcsnlen(sz, max);
fail_fast_assert(sz[len] == 0); return{ sz, len }; fail_fast_assert(sz[len] == 0); return{ sz, static_cast<std::ptrdiff_t>(len) };
} }
template<class T, size_t N> template<class T, size_t N>
basic_string_view<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], N); } basic_string_view<T, dynamic_range> ensure_z(T(&sz)[N]) { return ensure_z(&sz[0], static_cast<std::ptrdiff_t>(N)); }
template<class Cont> template<class Cont>
basic_string_view<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont) basic_string_view<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_range> ensure_z(Cont& cont)

12
tests/array_view_tests.cpp
View File

@ -50,7 +50,7 @@ SUITE(array_view_tests)
delete[] ptr.data(); delete[] ptr.data();
static_bounds<size_t, 4, dynamic_range, 2> bounds{ 3 }; static_bounds<4, dynamic_range, 2> bounds{ 3 };
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
array_view<int, 4, dynamic_range, 2> av(nullptr, bounds); array_view<int, 4, dynamic_range, 2> av(nullptr, bounds);
@ -151,9 +151,9 @@ SUITE(array_view_tests)
TEST(md_access) TEST(md_access)
{ {
unsigned int width = 5, height = 20; auto width = 5, height = 20;
unsigned int imgSize = width * height; auto imgSize = width * height;
auto image_ptr = new int[imgSize][3]; auto image_ptr = new int[imgSize][3];
// size check will be done // size check will be done
@ -162,9 +162,9 @@ SUITE(array_view_tests)
iota(image_view.begin(), image_view.end(), 1); iota(image_view.begin(), image_view.end(), 1);
int expected = 0; int expected = 0;
for (unsigned int i = 0; i < height; i++) for (auto i = 0; i < height; i++)
{ {
for (unsigned int j = 0; j < width; j++) for (auto j = 0; j < width; j++)
{ {
CHECK(expected + 1 == image_view[i][j][0]); CHECK(expected + 1 == image_view[i][j][0]);
CHECK(expected + 2 == image_view[i][j][1]); CHECK(expected + 2 == image_view[i][j][1]);
@ -244,7 +244,7 @@ SUITE(array_view_tests)
auto av8 = av7.as_array_view<int>(); auto av8 = av7.as_array_view<int>();
CHECK(av8.size() == av6.size()); CHECK(av8.size() == av6.size());
for (size_t i = 0; i < av8.size(); i++) for (auto i = 0; i < av8.size(); i++)
{ {
CHECK(av8[i] == 1); CHECK(av8[i] == 1);
} }

36
tests/bounds_tests.cpp
View File

@ -23,16 +23,16 @@ using namespace gsl;;
namespace namespace
{ {
void use(unsigned int&) {} void use(std::ptrdiff_t&) {}
} }
SUITE(bounds_test) SUITE(bounds_test)
{ {
TEST(basic_bounds) TEST(basic_bounds)
{ {
for (auto point : static_bounds <unsigned int, dynamic_range, 3, 4 > { 2 }) for (auto point : static_bounds<dynamic_range, 3, 4 > { 2 })
{ {
for (unsigned int j = 0; j < decltype(point)::rank; j++) for (decltype(point)::size_type j = 0; j < decltype(point)::rank; j++)
{ {
use(j); use(j);
use(point[j]); use(point[j]);
@ -42,24 +42,24 @@ SUITE(bounds_test)
TEST(bounds_basic) TEST(bounds_basic)
{ {
static_bounds<size_t, 3, 4, 5> b; static_bounds<3, 4, 5> b;
auto a = b.slice(); auto a = b.slice();
static_bounds<size_t, 4, dynamic_range, 2> x{ 4 }; static_bounds<4, dynamic_range, 2> x{ 4 };
x.slice().slice(); x.slice().slice();
} }
TEST (arrayview_iterator) TEST (arrayview_iterator)
{ {
static_bounds<size_t, 4, dynamic_range, 2> bounds{ 3 }; static_bounds<4, dynamic_range, 2> bounds{ 3 };
auto itr = bounds.begin(); auto itr = bounds.begin();
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
array_view< int, 4, dynamic_range, 2> av(nullptr, bounds); array_view<int, 4, dynamic_range, 2> av(nullptr, bounds);
auto itr2 = av.cbegin(); auto itr2 = av.cbegin();
for (auto & v : av) { for (auto& v : av) {
v = 4; v = 4;
} }
fill(av.begin(), av.end(), 0); fill(av.begin(), av.end(), 0);
@ -68,24 +68,24 @@ SUITE(bounds_test)
TEST (bounds_convertible) TEST (bounds_convertible)
{ {
static_bounds<size_t, 7, 4, 2> b1; static_bounds<7, 4, 2> b1;
static_bounds<size_t, 7, dynamic_range, 2> b2 = b1; static_bounds<7, dynamic_range, 2> b2 = b1;
#ifdef CONFIRM_COMPILATION_ERRORS #ifdef CONFIRM_COMPILATION_ERRORS
static_bounds<size_t, 7, dynamic_range, 1> b4 = b2; static_bounds<7, dynamic_range, 1> b4 = b2;
#endif #endif
static_bounds<size_t, dynamic_range, dynamic_range, dynamic_range> b3 = b1; static_bounds<dynamic_range, dynamic_range, dynamic_range> b3 = b1;
static_bounds<int, 7, 4, 2> b4 = b3; static_bounds<7, 4, 2> b4 = b3;
static_bounds<size_t, dynamic_range> b11; static_bounds<dynamic_range> b11;
static_bounds<size_t, dynamic_range> b5; static_bounds<dynamic_range> b5;
static_bounds<size_t, 34> b6; static_bounds<34> b6;
b5 = static_bounds<size_t, 20>(); b5 = static_bounds<20>();
CHECK_THROW(b6 = b5, fail_fast); CHECK_THROW(b6 = b5, fail_fast);
b5 = static_bounds<size_t, 34>(); b5 = static_bounds<34>();
b6 = b5; b6 = b5;
CHECK(b5 == b6); CHECK(b5 == b6);