SERVER-40356 Make ConstDataRange constructable from any byte-like type

39 files changed, 369 insertions, 271 deletions

diff --git a/buildscripts/idl/idl/cpp_types.py b/buildscripts/idl/idl/cpp_types.py
index 98e5cc83dc0..4cd5489409e 100644
--- a/buildscripts/idl/idl/cpp_types.py
+++ b/buildscripts/idl/idl/cpp_types.py
@@ -338,9 +338,8 @@ class _CppTypeVector(CppTypeBase):
 
     def get_getter_body(self, member_name):
         # type: (unicode) -> unicode
-        return common.template_args(
-            'return ConstDataRange(reinterpret_cast<const char*>(${member_name}.data()), ${member_name}.size());',
-            member_name=member_name)
+        return common.template_args('return ConstDataRange(${member_name});',
+                                    member_name=member_name)
 
     def get_setter_body(self, member_name, validator_method_name):
         # type: (unicode, unicode) -> unicode
@@ -352,7 +351,7 @@ class _CppTypeVector(CppTypeBase):
 
     def get_transform_to_getter_type(self, expression):
         # type: (unicode) -> Optional[unicode]
-        return common.template_args('makeCDR(${expression});', expression=expression)
+        return common.template_args('ConstDataRange(${expression});', expression=expression)
 
     def get_transform_to_storage_type(self, expression):
         # type: (unicode) -> Optional[unicode]
@@ -681,7 +680,7 @@ class _BinDataBsonCppTypeBase(BsonCppTypeBase):
                                      expression=expression, method_name=method_name))
         else:
             indented_writer.write_line(
-                common.template_args('ConstDataRange tempCDR = makeCDR(${expression});',
+                common.template_args('ConstDataRange tempCDR(${expression});',
                                      expression=expression))
 
         return common.template_args(
diff --git a/src/mongo/base/data_builder.h b/src/mongo/base/data_builder.h
index 00292c92a99..92a0ba73d0a 100644
--- a/src/mongo/base/data_builder.h
+++ b/src/mongo/base/data_builder.h
@@ -95,11 +95,11 @@ public:
     Status write(const T& value, std::size_t offset = 0) {
         _ensureStorage();
 
-        auto status = _unwrittenSpaceCursor.write(value, offset);
+        auto status = _unwrittenSpaceCursor.writeNoThrow(value, offset);
 
         if (!status.isOK()) {
             reserve(_getSerializedSize(value));
-            status = _unwrittenSpaceCursor.write(value, offset);
+            status = _unwrittenSpaceCursor.writeNoThrow(value, offset);
         }
 
         return status;
@@ -117,11 +117,11 @@ public:
         // 1. A way to check if the type has a constant size
         // 2. A way to perform a runtime write which can fail with "too little
         //    size" without status generation
-        auto status = _unwrittenSpaceCursor.writeAndAdvance(value);
+        auto status = _unwrittenSpaceCursor.writeAndAdvanceNoThrow(value);
 
         if (!status.isOK()) {
             reserve(_getSerializedSize(value));
-            status = _unwrittenSpaceCursor.writeAndAdvance(value);
+            status = _unwrittenSpaceCursor.writeAndAdvanceNoThrow(value);
         }
 
         return status;
diff --git a/src/mongo/base/data_builder_test.cpp b/src/mongo/base/data_builder_test.cpp
index 91adfabe25b..ed001bd31b1 100644
--- a/src/mongo/base/data_builder_test.cpp
+++ b/src/mongo/base/data_builder_test.cpp
@@ -67,11 +67,10 @@ TEST(DataBuilder, Basic) {
 
     ConstDataRangeCursor cdrc = db.getCursor();
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
-    ASSERT_EQUALS(static_cast<uint32_t>(2),
-                  cdrc.readAndAdvance<LittleEndian<uint32_t>>().getValue());
-    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>().getValue());
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
+    ASSERT_EQUALS(static_cast<uint32_t>(2), cdrc.readAndAdvance<LittleEndian<uint32_t>>());
+    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>());
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 }
 
 TEST(DataBuilder, ResizeDown) {
@@ -86,8 +85,8 @@ TEST(DataBuilder, ResizeDown) {
 
     ConstDataRangeCursor cdrc = db.getCursor();
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 }
 
 TEST(DataBuilder, ResizeUp) {
@@ -102,9 +101,9 @@ TEST(DataBuilder, ResizeUp) {
 
     ConstDataRangeCursor cdrc = db.getCursor();
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
-    ASSERT_EQUALS(static_cast<uint64_t>(2), cdrc.readAndAdvance<uint64_t>().getValue());
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
+    ASSERT_EQUALS(static_cast<uint64_t>(2), cdrc.readAndAdvance<uint64_t>());
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 }
 
 TEST(DataBuilder, Reserve) {
@@ -148,7 +147,7 @@ TEST(DataBuilder, Clear) {
     ASSERT_EQUALS(0u, db.size());
 
     ConstDataRangeCursor cdrc = db.getCursor();
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 }
 
 TEST(DataBuilder, Move) {
@@ -160,7 +159,7 @@ TEST(DataBuilder, Move) {
 
     ConstDataRangeCursor cdrc = db2.getCursor();
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
     ASSERT_EQUALS(2u, db2.capacity());
     ASSERT_EQUALS(2u, db2.size());
 
diff --git a/src/mongo/base/data_range.h b/src/mongo/base/data_range.h
index 9830b515091..eb53af9719a 100644
--- a/src/mongo/base/data_range.h
+++ b/src/mongo/base/data_range.h
@@ -40,9 +40,40 @@
 #include "mongo/util/mongoutils/str.h"
 
 namespace mongo {
-
 class ConstDataRange {
+protected:
+    // These are helper types to make ConstDataRange's and friends constructable either from
+    // a range of byte-like pointers or from a container of byte-like values.
+    template <typename T>
+    constexpr static auto isByteV = ((std::is_integral_v<T> && sizeof(T) == 1) ||
+                                     std::is_same_v<T, std::byte>);
+
+    template <typename T, typename = void>
+    struct HasDataSize : std::false_type {};
+
+    template <typename T>
+    struct HasDataSize<
+        T,
+        std::enable_if_t<std::is_void_v<
+            std::void_t<decltype(std::declval<T>().data()), decltype(std::declval<T>().size())>>>>
+        : std::true_type {};
+
+    template <typename T, typename = void>
+    struct ContiguousContainerOfByteLike : std::false_type {};
+
+    template <typename T>
+    struct ContiguousContainerOfByteLike<
+        T,
+        std::void_t<decltype(std::declval<T>().data()),
+                    std::enable_if_t<isByteV<typename T::value_type> && HasDataSize<T>::value>>>
+        : std::true_type {};
+
 public:
+    using byte_type = char;
+
+    // You can construct a ConstDataRange from any byte-like sequence. Byte-like means an
+    // integral type with a size of one.
+    //
     // begin and end should point to the first and one past last bytes in
     // the range you wish to view.
     //
@@ -51,28 +82,54 @@ public:
     // to a non-zero value, you'll change the Status messages that are
     // returned on failure to be offset by the amount passed to this
     // constructor.
-    ConstDataRange(const char* begin, const char* end, std::ptrdiff_t debug_offset = 0)
-        : _begin(begin), _end(end), _debug_offset(debug_offset) {
+    template <typename ByteLike, typename std::enable_if_t<isByteV<ByteLike>, int> = 0>
+    ConstDataRange(const ByteLike* begin, const ByteLike* end, std::ptrdiff_t debug_offset = 0)
+        : _begin(reinterpret_cast<const byte_type*>(begin)),
+          _end(reinterpret_cast<const byte_type*>(end)),
+          _debug_offset(debug_offset) {
         invariant(end >= begin);
     }
 
-    ConstDataRange(const char* begin, std::size_t length, std::ptrdiff_t debug_offset = 0)
-        : ConstDataRange(begin, begin + length, debug_offset) {}
-
-    const char* data() const {
+    // Constructing from nullptr, nullptr initializes an empty ConstDataRange.
+    ConstDataRange(std::nullptr_t, std::nullptr_t, std::ptrdiff_t debug_offset = 0)
+        : _begin(nullptr), _end(nullptr), _debug_offset(debug_offset) {}
+
+    // You can also construct from a pointer to a byte-like type and a size.
+    template <typename ByteLike, typename std::enable_if_t<isByteV<ByteLike>, int> = 0>
+    ConstDataRange(const ByteLike* begin, std::size_t length, std::ptrdiff_t debug_offset = 0)
+        : _begin(reinterpret_cast<const byte_type*>(begin)),
+          _end(reinterpret_cast<const byte_type*>(_begin + length)),
+          _debug_offset(debug_offset) {}
+
+    // ConstDataRange can also act as a view of a container of byte-like values, such as a
+    // std::vector<uint8_t> or a std::array<char, size>. The requirements are that the
+    // value_type of the container is byte-like and that the values be contiguous - the container
+    // must have a data() function that returns a pointer to the front and a size() function
+    // that returns the number of elements.
+    template <typename Container,
+              typename std::enable_if_t<ContiguousContainerOfByteLike<Container>::value, int> = 0>
+    ConstDataRange(const Container& container, std::ptrdiff_t debug_offset = 0)
+        : ConstDataRange(container.data(), container.size(), debug_offset) {}
+
+    // You can also construct from a C-style array, including string literals.
+    template <typename ByteLike, size_t N, typename std::enable_if_t<isByteV<ByteLike>, int> = 0>
+    ConstDataRange(const ByteLike (&arr)[N], std::ptrdiff_t debug_offset = 0)
+        : ConstDataRange(arr, N, debug_offset) {}
+
+    const byte_type* data() const noexcept {
         return _begin;
     }
 
-    size_t length() const {
+    size_t length() const noexcept {
         return _end - _begin;
     }
 
-    bool empty() const {
+    bool empty() const noexcept {
         return length() == 0;
     }
 
     template <typename T>
-    Status readInto(T* t, size_t offset = 0) const {
+    Status readIntoNoThrow(T* t, size_t offset = 0) const noexcept {
         if (offset > length()) {
             return makeOffsetStatus(offset);
         }
@@ -82,9 +139,14 @@ public:
     }
 
     template <typename T>
-    StatusWith<T> read(std::size_t offset = 0) const {
+    void readInto(T* t, size_t offset = 0) const {
+        uassertStatusOK(readIntoNoThrow(t, offset));
+    }
+
+    template <typename T>
+    StatusWith<T> readNoThrow(std::size_t offset = 0) const noexcept {
         T t(DataType::defaultConstruct<T>());
-        Status s = readInto(&t, offset);
+        Status s = readIntoNoThrow(&t, offset);
 
         if (s.isOK()) {
             return StatusWith<T>(std::move(t));
@@ -93,6 +155,11 @@ public:
         }
     }
 
+    template <typename T>
+    T read(std::size_t offset = 0) const {
+        return uassertStatusOK(readNoThrow<T>(offset));
+    }
+
     friend bool operator==(const ConstDataRange& lhs, const ConstDataRange& rhs) {
         return std::tie(lhs._begin, lhs._end) == std::tie(rhs._begin, rhs._end);
     }
@@ -103,8 +170,8 @@ public:
 
 
 protected:
-    const char* _begin;
-    const char* _end;
+    const byte_type* _begin;
+    const byte_type* _end;
     std::ptrdiff_t _debug_offset;
 
     Status makeOffsetStatus(size_t offset) const;
@@ -112,16 +179,56 @@ protected:
 
 class DataRange : public ConstDataRange {
 public:
-    typedef char* bytes_type;
-
-    DataRange(bytes_type begin, bytes_type end, std::ptrdiff_t debug_offset = 0)
+    // You can construct a DataRange from all the same types as ConstDataRange, except that the
+    // arguments may not be const (since this is the mutable version of ConstDataRange).
+    template <typename ByteLike>
+    DataRange(ByteLike* begin, ByteLike* end, std::ptrdiff_t debug_offset = 0)
         : ConstDataRange(begin, end, debug_offset) {}
 
-    DataRange(bytes_type begin, std::size_t length, std::ptrdiff_t debug_offset = 0)
+    template <typename ByteLike>
+    DataRange(const ByteLike*, const ByteLike* end, std::ptrdiff_t debug_offset) = delete;
+
+    template <typename ByteLike>
+    DataRange(const ByteLike*, const ByteLike* end) = delete;
+
+    template <typename ByteLike>
+    DataRange(ByteLike* begin, std::size_t length, std::ptrdiff_t debug_offset = 0)
         : ConstDataRange(begin, length, debug_offset) {}
 
+    template <typename ByteLike>
+    DataRange(const ByteLike*, size_t, std::ptrdiff_t debug_offset) = delete;
+
+    template <typename ByteLike>
+    DataRange(const ByteLike*, size_t) = delete;
+
+    DataRange(std::nullptr_t, std::nullptr_t, std::ptrdiff_t debug_offset = 0)
+        : ConstDataRange(nullptr, nullptr, debug_offset) {}
+
+    template <typename Container,
+              typename std::enable_if_t<ContiguousContainerOfByteLike<Container>::value, int> = 0>
+    DataRange(Container& container, std::ptrdiff_t debug_offset = 0)
+        : ConstDataRange(std::forward<Container>(container), debug_offset) {}
+
+    template <typename Container,
+              typename std::enable_if_t<ContiguousContainerOfByteLike<Container>::value, int> = 0>
+    DataRange(const Container&, std::ptrdiff_t) = delete;
+
+    template <typename Container,
+              typename std::enable_if_t<ContiguousContainerOfByteLike<Container>::value, int> = 0>
+    DataRange(const Container&) = delete;
+
+    template <typename ByteLike, size_t N>
+    DataRange(ByteLike (&arr)[N], std::ptrdiff_t debug_offset = 0)
+        : ConstDataRange(arr, N, debug_offset) {}
+
+    template <typename ByteLike, size_t N>
+    DataRange(const ByteLike (&arr)[N], std::ptrdiff_t) = delete;
+
+    template <typename ByteLike, size_t N>
+    DataRange(const ByteLike (&arr)[N]) = delete;
+
     template <typename T>
-    Status write(const T& value, std::size_t offset = 0) {
+    Status writeNoThrow(const T& value, std::size_t offset = 0) noexcept {
         if (offset > length()) {
             return makeOffsetStatus(offset);
         }
@@ -132,6 +239,11 @@ public:
                                nullptr,
                                offset + _debug_offset);
     }
+
+    template <typename T>
+    void write(const T& value, std::size_t offset = 0) {
+        uassertStatusOK(writeNoThrow(value, offset));
+    }
 };
 
 struct DataRangeTypeHelper {
diff --git a/src/mongo/base/data_range_cursor.h b/src/mongo/base/data_range_cursor.h
index f4056e60573..13f0fdae4d3 100644
--- a/src/mongo/base/data_range_cursor.h
+++ b/src/mongo/base/data_range_cursor.h
@@ -42,12 +42,10 @@ namespace mongo {
 
 class ConstDataRangeCursor : public ConstDataRange {
 public:
-    ConstDataRangeCursor(const char* begin, const char* end, std::ptrdiff_t debug_offset = 0)
-        : ConstDataRange(begin, end, debug_offset) {}
-
+    using ConstDataRange::ConstDataRange;
     ConstDataRangeCursor(ConstDataRange cdr) : ConstDataRange(cdr) {}
 
-    Status advance(size_t advance) {
+    Status advanceNoThrow(size_t advance) noexcept try {
         if (advance > length()) {
             return makeAdvanceStatus(advance);
         }
@@ -56,10 +54,16 @@ public:
         _debug_offset += advance;
 
         return Status::OK();
+    } catch (const DBException& e) {
+        return e.toStatus();
+    }
+
+    void advance(size_t advance) {
+        uassertStatusOK(advanceNoThrow(advance));
     }
 
     template <typename T>
-    Status skip() {
+    Status skipNoThrow() noexcept {
         size_t advanced = 0;
 
         Status x = DataType::load<T>(nullptr, _begin, _end - _begin, &advanced, _debug_offset);
@@ -73,7 +77,12 @@ public:
     }
 
     template <typename T>
-    Status readAndAdvance(T* t) {
+    void skip() {
+        uassertStatusOK(skipNoThrow<T>());
+    }
+
+    template <typename T>
+    Status readAndAdvanceNoThrow(T* t) noexcept {
         size_t advanced = 0;
 
         Status x = DataType::load(t, _begin, _end - _begin, &advanced, _debug_offset);
@@ -87,9 +96,14 @@ public:
     }
 
     template <typename T>
-    StatusWith<T> readAndAdvance() {
+    void readAndAdvance(T* t) {
+        return uassertStatusOK(readAndAdvanceNoThrow(t));
+    }
+
+    template <typename T>
+    StatusWith<T> readAndAdvanceNoThrow() noexcept {
         T out(DataType::defaultConstruct<T>());
-        Status x = readAndAdvance(&out);
+        Status x = readAndAdvanceNoThrow(&out);
 
         if (x.isOK()) {
             return StatusWith<T>(std::move(out));
@@ -98,22 +112,25 @@ public:
         }
     }
 
+    template <typename T>
+    T readAndAdvance() {
+        return uassertStatusOK(readAndAdvanceNoThrow<T>());
+    }
+
 private:
     Status makeAdvanceStatus(size_t advance) const;
 };
 
 class DataRangeCursor : public DataRange {
 public:
-    DataRangeCursor(char* begin, char* end, std::ptrdiff_t debug_offset = 0)
-        : DataRange(begin, end, debug_offset) {}
-
+    using DataRange::DataRange;
     DataRangeCursor(DataRange range) : DataRange(range) {}
 
     operator ConstDataRangeCursor() const {
         return ConstDataRangeCursor(ConstDataRange(_begin, _end, _debug_offset));
     }
 
-    Status advance(size_t advance) {
+    Status advanceNoThrow(size_t advance) noexcept {
         if (advance > length()) {
             return makeAdvanceStatus(advance);
         }
@@ -124,8 +141,12 @@ public:
         return Status::OK();
     }
 
+    void advance(size_t advance) {
+        uassertStatusOK(advanceNoThrow(advance));
+    }
+
     template <typename T>
-    Status skip() {
+    Status skipNoThrow() noexcept {
         size_t advanced = 0;
 
         Status x = DataType::load<T>(nullptr, _begin, _end - _begin, &advanced, _debug_offset);
@@ -139,7 +160,12 @@ public:
     }
 
     template <typename T>
-    Status readAndAdvance(T* t) {
+    void skip() {
+        uassertStatusOK(skipNoThrow<T>());
+    }
+
+    template <typename T>
+    Status readAndAdvanceNoThrow(T* t) noexcept {
         size_t advanced = 0;
 
         Status x = DataType::load(t, _begin, _end - _begin, &advanced, _debug_offset);
@@ -153,9 +179,14 @@ public:
     }
 
     template <typename T>
-    StatusWith<T> readAndAdvance() {
+    void readAndAdvance(T* t) {
+        uassertStatusOK(readAndAdvanceNoThrow(t));
+    }
+
+    template <typename T>
+    StatusWith<T> readAndAdvanceNoThrow() noexcept {
         T out(DataType::defaultConstruct<T>());
-        Status x = readAndAdvance(&out);
+        Status x = readAndAdvanceNoThrow(&out);
 
         if (x.isOK()) {
             return StatusWith<T>(std::move(out));
@@ -165,7 +196,12 @@ public:
     }
 
     template <typename T>
-    Status writeAndAdvance(const T& value) {
+    T readAndAdvance() {
+        return uassertStatusOK(readAndAdvanceNoThrow<T>());
+    }
+
+    template <typename T>
+    Status writeAndAdvanceNoThrow(const T& value) noexcept {
         size_t advanced = 0;
 
         Status x = DataType::store(
@@ -179,6 +215,11 @@ public:
         return x;
     }
 
+    template <typename T>
+    void writeAndAdvance(const T& value) {
+        uassertStatusOK(writeAndAdvanceNoThrow(value));
+    }
+
 private:
     Status makeAdvanceStatus(size_t advance) const;
 };
diff --git a/src/mongo/base/data_range_cursor_test.cpp b/src/mongo/base/data_range_cursor_test.cpp
index afd91e478a5..60543c6af6a 100644
--- a/src/mongo/base/data_range_cursor_test.cpp
+++ b/src/mongo/base/data_range_cursor_test.cpp
@@ -45,18 +45,16 @@ TEST(DataRangeCursor, ConstDataRangeCursor) {
     ConstDataRangeCursor cdrc(buf, buf + sizeof(buf));
     ConstDataRangeCursor backup(cdrc);
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
-    ASSERT_EQUALS(static_cast<uint32_t>(2),
-                  cdrc.readAndAdvance<LittleEndian<uint32_t>>().getValue());
-    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>().getValue());
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
+    ASSERT_EQUALS(static_cast<uint32_t>(2), cdrc.readAndAdvance<LittleEndian<uint32_t>>());
+    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>());
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 
     // test skip()
     cdrc = backup;
-    ASSERT_EQUALS(true, cdrc.skip<uint32_t>().isOK());
-    ;
-    ASSERT_EQUALS(true, cdrc.advance(10).isOK());
-    ASSERT_EQUALS(false, cdrc.readAndAdvance<char>().isOK());
+    ASSERT_OK(cdrc.skipNoThrow<uint32_t>());
+    ASSERT_OK(cdrc.advanceNoThrow(10));
+    ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow<char>());
 }
 
 TEST(DataRangeCursor, ConstDataRangeCursorType) {
@@ -66,9 +64,7 @@ TEST(DataRangeCursor, ConstDataRangeCursorType) {
 
     ConstDataRangeCursor out(nullptr, nullptr);
 
-    auto inner = cdrc.readInto(&out);
-
-    ASSERT_OK(inner);
+    ASSERT_OK(cdrc.readIntoNoThrow(&out));
     ASSERT_EQUALS(buf, out.data());
 }
 
@@ -77,18 +73,17 @@ TEST(DataRangeCursor, DataRangeCursor) {
 
     DataRangeCursor dc(buf, buf + 14);
 
-    ASSERT_EQUALS(true, dc.writeAndAdvance<uint16_t>(1).isOK());
-    ASSERT_EQUALS(true, dc.writeAndAdvance<LittleEndian<uint32_t>>(2).isOK());
-    ASSERT_EQUALS(true, dc.writeAndAdvance<BigEndian<uint64_t>>(3).isOK());
-    ASSERT_EQUALS(false, dc.writeAndAdvance<char>(1).isOK());
+    ASSERT_OK(dc.writeAndAdvanceNoThrow<uint16_t>(1));
+    ASSERT_OK(dc.writeAndAdvanceNoThrow<LittleEndian<uint32_t>>(2));
+    ASSERT_OK(dc.writeAndAdvanceNoThrow<BigEndian<uint64_t>>(3));
+    ASSERT_NOT_OK(dc.writeAndAdvanceNoThrow<char>(1));
 
     ConstDataRangeCursor cdrc(buf, buf + sizeof(buf));
 
-    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>().getValue());
-    ASSERT_EQUALS(static_cast<uint32_t>(2),
-                  cdrc.readAndAdvance<LittleEndian<uint32_t>>().getValue());
-    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>().getValue());
-    ASSERT_EQUALS(static_cast<char>(0), cdrc.readAndAdvance<char>().getValue());
+    ASSERT_EQUALS(static_cast<uint16_t>(1), cdrc.readAndAdvance<uint16_t>());
+    ASSERT_EQUALS(static_cast<uint32_t>(2), cdrc.readAndAdvance<LittleEndian<uint32_t>>());
+    ASSERT_EQUALS(static_cast<uint64_t>(3), cdrc.readAndAdvance<BigEndian<uint64_t>>());
+    ASSERT_EQUALS(static_cast<char>(0), cdrc.readAndAdvance<char>());
 }
 
 TEST(DataRangeCursor, DataRangeCursorType) {
@@ -99,15 +94,12 @@ TEST(DataRangeCursor, DataRangeCursorType) {
 
     DataRangeCursor out(nullptr, nullptr);
 
-    Status status = drc.readInto(&out);
-
-    ASSERT_OK(status);
+    ASSERT_OK(drc.readIntoNoThrow(&out));
     ASSERT_EQUALS(buf, out.data());
 
     drc = DataRangeCursor(buf2, buf2 + sizeof(buf2) + -1);
-    status = drc.write(out);
+    ASSERT_OK(drc.writeNoThrow(out));
 
-    ASSERT_OK(status);
     ASSERT_EQUALS(std::string("fooZ"), buf2);
 }
 }  // namespace mongo
diff --git a/src/mongo/base/data_range_test.cpp b/src/mongo/base/data_range_test.cpp
index 9c374768f2d..f45c6e26bbf 100644
--- a/src/mongo/base/data_range_test.cpp
+++ b/src/mongo/base/data_range_test.cpp
@@ -38,7 +38,7 @@
 namespace mongo {
 
 TEST(DataRange, ConstDataRange) {
-    char buf[sizeof(uint32_t) * 3];
+    unsigned char buf[sizeof(uint32_t) * 3];
     uint32_t native = 1234;
     uint32_t le = endian::nativeToLittle(native);
     uint32_t be = endian::nativeToBig(native);
@@ -49,11 +49,11 @@ TEST(DataRange, ConstDataRange) {
 
     ConstDataRange cdv(buf, buf + sizeof(buf));
 
-    ASSERT_EQUALS(native, cdv.read<uint32_t>().getValue());
-    ASSERT_EQUALS(native, cdv.read<LittleEndian<uint32_t>>(sizeof(uint32_t)).getValue());
-    ASSERT_EQUALS(native, cdv.read<BigEndian<uint32_t>>(sizeof(uint32_t) * 2).getValue());
+    ASSERT_EQUALS(native, cdv.read<uint32_t>());
+    ASSERT_EQUALS(native, cdv.read<LittleEndian<uint32_t>>(sizeof(uint32_t)));
+    ASSERT_EQUALS(native, cdv.read<BigEndian<uint32_t>>(sizeof(uint32_t) * 2));
 
-    auto result = cdv.read<uint32_t>(sizeof(uint32_t) * 3);
+    auto result = cdv.readNoThrow<uint32_t>(sizeof(uint32_t) * 3);
     ASSERT_EQUALS(false, result.isOK());
     ASSERT_EQUALS(ErrorCodes::Overflow, result.getStatus().code());
 }
@@ -65,31 +65,31 @@ TEST(DataRange, ConstDataRangeType) {
 
     ConstDataRange out(nullptr, nullptr);
 
-    auto inner = cdr.readInto(&out);
+    auto inner = cdr.readIntoNoThrow(&out);
 
     ASSERT_OK(inner);
     ASSERT_EQUALS(buf, out.data());
 }
 
 TEST(DataRange, DataRange) {
-    char buf[sizeof(uint32_t) * 3];
+    uint8_t buf[sizeof(uint32_t) * 3];
     uint32_t native = 1234;
 
     DataRange dv(buf, buf + sizeof(buf));
 
-    ASSERT_EQUALS(true, dv.write(native).isOK());
-    ASSERT_EQUALS(true, dv.write(LittleEndian<uint32_t>(native), sizeof(uint32_t)).isOK());
-    ASSERT_EQUALS(true, dv.write(BigEndian<uint32_t>(native), sizeof(uint32_t) * 2).isOK());
+    ASSERT_OK(dv.writeNoThrow(native));
+    ASSERT_OK(dv.writeNoThrow(LittleEndian<uint32_t>(native), sizeof(uint32_t)));
+    ASSERT_OK(dv.writeNoThrow(BigEndian<uint32_t>(native), sizeof(uint32_t) * 2));
 
-    auto result = dv.write(native, sizeof(uint32_t) * 3);
-    ASSERT_EQUALS(false, result.isOK());
+    auto result = dv.writeNoThrow(native, sizeof(uint32_t) * 3);
+    ASSERT_NOT_OK(result);
     ASSERT_EQUALS(ErrorCodes::Overflow, result.code());
 
-    ASSERT_EQUALS(native, dv.read<uint32_t>().getValue());
-    ASSERT_EQUALS(native, dv.read<LittleEndian<uint32_t>>(sizeof(uint32_t)).getValue());
-    ASSERT_EQUALS(native, dv.read<BigEndian<uint32_t>>(sizeof(uint32_t) * 2).getValue());
+    ASSERT_EQUALS(native, dv.read<uint32_t>());
+    ASSERT_EQUALS(native, dv.read<LittleEndian<uint32_t>>(sizeof(uint32_t)));
+    ASSERT_EQUALS(native, dv.read<BigEndian<uint32_t>>(sizeof(uint32_t) * 2));
 
-    ASSERT_EQUALS(false, dv.read<uint32_t>(sizeof(uint32_t) * 3).isOK());
+    ASSERT_NOT_OK(dv.readNoThrow<uint32_t>(sizeof(uint32_t) * 3));
 }
 
 TEST(DataRange, DataRangeType) {
@@ -100,16 +100,32 @@ TEST(DataRange, DataRangeType) {
 
     DataRange out(nullptr, nullptr);
 
-    Status status = dr.readInto(&out);
+    Status status = dr.readIntoNoThrow(&out);
 
     ASSERT_OK(status);
     ASSERT_EQUALS(buf, out.data());
 
     dr = DataRange(buf2, buf2 + sizeof(buf2) + -1);
-    status = dr.write(out);
+    status = dr.writeNoThrow(out);
 
     ASSERT_OK(status);
     ASSERT_EQUALS(std::string("fooZ"), buf2);
 }
 
+TEST(DataRange, InitFromContainer) {
+    std::vector<uint8_t> vec(20);
+    ConstDataRange dr(vec);
+    DataRange out(nullptr, nullptr);
+
+    ASSERT_OK(dr.readIntoNoThrow(&out));
+
+    DataRange mutableDr(vec);
+    ASSERT_OK(mutableDr.writeNoThrow<int>(6));
+
+    std::array<char, 5> array;
+    DataRange arrDR(array);
+    auto status = arrDR.writeNoThrow<uint64_t>(std::numeric_limits<uint64_t>::max());
+    ASSERT_EQUALS(status, ErrorCodes::Overflow);
+}
+
 }  // namespace mongo
diff --git a/src/mongo/base/data_type_string_data_test.cpp b/src/mongo/base/data_type_string_data_test.cpp
index f88a581e6a2..b2fb8b29a50 100644
--- a/src/mongo/base/data_type_string_data_test.cpp
+++ b/src/mongo/base/data_type_string_data_test.cpp
@@ -45,9 +45,9 @@ TEST(DataTypeStringData, Basic) {
     {
         DataRangeCursor drc(buf, buf + sizeof(buf));
 
-        ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(a)));
-        ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(b)));
-        ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(c)));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(Terminated<'\0', StringData>(a)));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(Terminated<'\0', StringData>(b)));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(Terminated<'\0', StringData>(c)));
 
         ASSERT_EQUALS(1 + 2 + 3 + 3, drc.data() - buf);
     }
@@ -57,13 +57,13 @@ TEST(DataTypeStringData, Basic) {
 
         Terminated<'\0', StringData> tsd;
 
-        ASSERT_OK(cdrc.readAndAdvance(&tsd));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&tsd));
         ASSERT_EQUALS(a, tsd.value);
 
-        ASSERT_OK(cdrc.readAndAdvance(&tsd));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&tsd));
         ASSERT_EQUALS(b, tsd.value);
 
-        ASSERT_OK(cdrc.readAndAdvance(&tsd));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&tsd));
         ASSERT_EQUALS(c, tsd.value);
     }
 }
diff --git a/src/mongo/base/data_type_terminated_test.cpp b/src/mongo/base/data_type_terminated_test.cpp
index d5cf8d7967a..45635760c6e 100644
--- a/src/mongo/base/data_type_terminated_test.cpp
+++ b/src/mongo/base/data_type_terminated_test.cpp
@@ -229,7 +229,7 @@ TEST(DataTypeTerminated, ThroughDataRangeCursor) {
         auto buf_writer = DataRangeCursor(buf, buf + sizeof(buf));
         for (const std::string& s : parts) {
             Terminated<'\0', ConstDataRange> tcdr(ConstDataRange(s.data(), s.data() + s.size()));
-            ASSERT_OK(buf_writer.writeAndAdvance(tcdr));
+            ASSERT_OK(buf_writer.writeAndAdvanceNoThrow(tcdr));
         }
         const auto written = std::string(static_cast<const char*>(buf), buf_writer.data());
         ASSERT_EQUALS(written, serialized);
@@ -238,7 +238,7 @@ TEST(DataTypeTerminated, ThroughDataRangeCursor) {
         auto buf_source = ConstDataRangeCursor(buf, buf + sizeof(buf));
         for (const std::string& s : parts) {
             Terminated<'\0', ConstDataRange> tcdr;
-            ASSERT_OK(buf_source.readAndAdvance(&tcdr));
+            ASSERT_OK(buf_source.readAndAdvanceNoThrow(&tcdr));
             std::string read(tcdr.value.data(), tcdr.value.data() + tcdr.value.length());
             ASSERT_EQUALS(s, read);
         }
diff --git a/src/mongo/base/data_type_validated_test.cpp b/src/mongo/base/data_type_validated_test.cpp
index 4ae8f4a58d4..e6e63f4592a 100644
--- a/src/mongo/base/data_type_validated_test.cpp
+++ b/src/mongo/base/data_type_validated_test.cpp
@@ -69,13 +69,13 @@ TEST(DataTypeValidated, SuccessfulValidation) {
 
     {
         DataRangeCursor drc(begin(buf), end(buf));
-        ASSERT_OK(drc.writeAndAdvance(Validated<char>(0xFU)));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(Validated<char>(0xFU)));
     }
 
     {
         Validated<char> valid;
         ConstDataRangeCursor cdrc(begin(buf), end(buf));
-        ASSERT_OK(cdrc.readAndAdvance(&valid));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&valid));
         ASSERT_EQUALS(valid.val, char{0xFU});
     }
 }
@@ -85,7 +85,7 @@ TEST(DataTypeValidated, FailedValidation) {
 
     {
         DataRangeCursor drc(begin(buf), end(buf));
-        ASSERT_NOT_OK(drc.writeAndAdvance(Validated<char>(0x01)));
+        ASSERT_NOT_OK(drc.writeAndAdvanceNoThrow(Validated<char>(0x01)));
     }
 
     buf[0] = char{0x01};
@@ -93,7 +93,7 @@ TEST(DataTypeValidated, FailedValidation) {
     {
         Validated<char> valid;
         ConstDataRangeCursor cdrc(begin(buf), end(buf));
-        ASSERT_NOT_OK(cdrc.readAndAdvance(&valid));
+        ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow(&valid));
     }
 }
 
diff --git a/src/mongo/bson/bson_obj_data_type_test.cpp b/src/mongo/bson/bson_obj_data_type_test.cpp
index e69d4bf3a6a..d0073d58f62 100644
--- a/src/mongo/bson/bson_obj_data_type_test.cpp
+++ b/src/mongo/bson/bson_obj_data_type_test.cpp
@@ -45,26 +45,26 @@ TEST(BSONObjDataType, ConstDataTypeRangeBSON) {
         BSONObjBuilder b;
         b.append("a", 1);
 
-        ASSERT_OK(drc.writeAndAdvance(b.obj()));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(b.obj()));
     }
     {
         BSONObjBuilder b;
         b.append("b", "fooo");
 
-        ASSERT_OK(drc.writeAndAdvance(b.obj()));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(b.obj()));
     }
     {
         BSONObjBuilder b;
         b.append("c", 3);
 
-        ASSERT_OK(drc.writeAndAdvance(b.obj()));
+        ASSERT_OK(drc.writeAndAdvanceNoThrow(b.obj()));
     }
 
     ConstDataRangeCursor cdrc(buf, buf + sizeof(buf));
 
-    ASSERT_EQUALS(1, cdrc.readAndAdvance<BSONObj>().getValue().getField("a").numberInt());
-    ASSERT_EQUALS("fooo", cdrc.readAndAdvance<BSONObj>().getValue().getField("b").str());
-    ASSERT_EQUALS(3, cdrc.readAndAdvance<BSONObj>().getValue().getField("c").numberInt());
+    ASSERT_EQUALS(1, cdrc.readAndAdvance<BSONObj>().getField("a").numberInt());
+    ASSERT_EQUALS("fooo", cdrc.readAndAdvance<BSONObj>().getField("b").str());
+    ASSERT_EQUALS(3, cdrc.readAndAdvance<BSONObj>().getField("c").numberInt());
 }
 
 }  // namespace mongo
diff --git a/src/mongo/bson/bson_obj_test.cpp b/src/mongo/bson/bson_obj_test.cpp
index a061d67f67b..e966af9d559 100644
--- a/src/mongo/bson/bson_obj_test.cpp
+++ b/src/mongo/bson/bson_obj_test.cpp
@@ -689,7 +689,7 @@ TEST(BSONObj, sizeChecks) {
     auto generateBuffer = [](std::int32_t size) {
         std::vector<char> buffer(size);
         DataRange bufferRange(&buffer.front(), &buffer.back());
-        ASSERT_OK(bufferRange.write(LittleEndian<int32_t>(size)));
+        ASSERT_OK(bufferRange.writeNoThrow(LittleEndian<int32_t>(size)));
 
         return buffer;
     };
diff --git a/src/mongo/bson/bsonelement_test.cpp b/src/mongo/bson/bsonelement_test.cpp
index d8f311450fd..8901ab4339a 100644
--- a/src/mongo/bson/bsonelement_test.cpp
+++ b/src/mongo/bson/bsonelement_test.cpp
@@ -113,7 +113,7 @@ TEST(BSONElement, ExtractLargeSubObject) {
     std::int32_t size = 17 * 1024 * 1024;
     std::vector<char> buffer(size);
     DataRange bufferRange(&buffer.front(), &buffer.back());
-    ASSERT_OK(bufferRange.write(LittleEndian<int32_t>(size)));
+    ASSERT_OK(bufferRange.writeNoThrow(LittleEndian<int32_t>(size)));
 
     BSONObj obj(buffer.data(), BSONObj::LargeSizeTrait{});
 
diff --git a/src/mongo/bson/bsonobjbuilder_test.cpp b/src/mongo/bson/bsonobjbuilder_test.cpp
index e174a337a27..a2522d04b58 100644
--- a/src/mongo/bson/bsonobjbuilder_test.cpp
+++ b/src/mongo/bson/bsonobjbuilder_test.cpp
@@ -451,7 +451,7 @@ TEST(BSONObjBuilderTest, SizeChecks) {
     auto generateBuffer = [](std::int32_t size) {
         std::vector<char> buffer(size);
         DataRange bufferRange(&buffer.front(), &buffer.back());
-        ASSERT_OK(bufferRange.write(LittleEndian<int32_t>(size)));
+        ASSERT_OK(bufferRange.writeNoThrow(LittleEndian<int32_t>(size)));
 
         return buffer;
     };
diff --git a/src/mongo/bson/oid.h b/src/mongo/bson/oid.h
index 2c9da565fa1..d5df0c90ee9 100644
--- a/src/mongo/bson/oid.h
+++ b/src/mongo/bson/oid.h
@@ -226,7 +226,7 @@ public:
     }
 
     ConstDataRange toCDR() const {
-        return ConstDataRange(_data, kOIDSize);
+        return ConstDataRange(_data);
     }
 
 private:
diff --git a/src/mongo/crypto/sha_block.h b/src/mongo/crypto/sha_block.h
index e9a0ce338b9..2d2c3684e07 100644
--- a/src/mongo/crypto/sha_block.h
+++ b/src/mongo/crypto/sha_block.h
@@ -88,7 +88,7 @@ public:
      * Computes a hash of 'input' from one buffer.
      */
     static SHABlock computeHash(const uint8_t* input, size_t inputLen) {
-        return computeHash({ConstDataRange(reinterpret_cast<const char*>(input), inputLen)});
+        return computeHash({ConstDataRange(input, inputLen)});
     }
 
     /**
@@ -99,8 +99,7 @@ public:
                                 const uint8_t* input,
                                 size_t inputLen) {
         SHABlock output;
-        SHABlock::computeHmac(
-            key, keyLen, {ConstDataRange(reinterpret_cast<const char*>(input), inputLen)}, &output);
+        SHABlock::computeHmac(key, keyLen, {ConstDataRange(input, inputLen)}, &output);
         return output;
     }
 
@@ -113,8 +112,7 @@ public:
                             const uint8_t* input,
                             size_t inputLen,
                             SHABlock* const output) {
-        SHABlock::computeHmac(
-            key, keyLen, {ConstDataRange(reinterpret_cast<const char*>(input), inputLen)}, output);
+        SHABlock::computeHmac(key, keyLen, {ConstDataRange(input, inputLen)}, output);
     }
 
     static SHABlock computeHmac(const uint8_t* key,
diff --git a/src/mongo/db/free_mon/free_mon_controller_test.cpp b/src/mongo/db/free_mon/free_mon_controller_test.cpp
index 30473d27be4..892fbb7afa2 100644
--- a/src/mongo/db/free_mon/free_mon_controller_test.cpp
+++ b/src/mongo/db/free_mon/free_mon_controller_test.cpp
@@ -141,7 +141,7 @@ BSONArray decompressMetrics(ConstDataRange cdr) {
     snappy::Uncompress(cdr.data(), cdr.length(), &outBuffer);
 
     ConstDataRange raw(outBuffer.data(), outBuffer.data() + outBuffer.size());
-    auto swObj = raw.read<Validated<BSONObj>>();
+    auto swObj = raw.readNoThrow<Validated<BSONObj>>();
     ASSERT_OK(swObj.getStatus());
 
     return BSONArray(swObj.getValue().val["data"].Obj().getOwned());
diff --git a/src/mongo/db/free_mon/free_mon_mongod.cpp b/src/mongo/db/free_mon/free_mon_mongod.cpp
index b8988ad53ea..9b86d33258f 100644
--- a/src/mongo/db/free_mon/free_mon_mongod.cpp
+++ b/src/mongo/db/free_mon/free_mon_mongod.cpp
@@ -113,10 +113,7 @@ public:
             auto blobSize = blob.size();
             auto blobData = blob.release();
             ConstDataRange cdr(blobData.get(), blobSize);
-            auto swDoc = cdr.read<Validated<BSONObj>>();
-            uassertStatusOK(swDoc.getStatus());
-
-            BSONObj respObj(swDoc.getValue());
+            BSONObj respObj = cdr.read<Validated<BSONObj>>();
 
             auto resp =
                 FreeMonRegistrationResponse::parse(IDLParserErrorContext("response"), respObj);
@@ -140,10 +137,7 @@ public:
             auto blobData = blob.release();
             ConstDataRange cdr(blobData.get(), blobSize);
 
-            auto swDoc = cdr.read<Validated<BSONObj>>();
-            uassertStatusOK(swDoc.getStatus());
-
-            BSONObj respObj(swDoc.getValue());
+            BSONObj respObj = cdr.read<Validated<BSONObj>>();
 
             auto resp = FreeMonMetricsResponse::parse(IDLParserErrorContext("response"), respObj);
 
@@ -160,7 +154,7 @@ private:
         auto status = _executor->scheduleWork(
             [ promise = std::move(pf.promise), url = std::move(url), data = std::move(data), this ](
                 const executor::TaskExecutor::CallbackArgs& cbArgs) mutable {
-                ConstDataRange cdr(reinterpret_cast<char*>(data->data()), data->size());
+                ConstDataRange cdr(data->data(), data->size());
                 try {
                     auto result = this->_client->post(url, cdr);
                     promise.emplaceValue(std::move(result));
diff --git a/src/mongo/db/ftdc/block_compressor.cpp b/src/mongo/db/ftdc/block_compressor.cpp
index c128dcf115e..ed7b80d5e4b 100644
--- a/src/mongo/db/ftdc/block_compressor.cpp
+++ b/src/mongo/db/ftdc/block_compressor.cpp
@@ -74,7 +74,7 @@ StatusWith<ConstDataRange> BlockCompressor::compress(ConstDataRange source) {
         return {ErrorCodes::ZLibError, str::stream() << "deflateEnd failed with " << err};
     }
 
-    return ConstDataRange(reinterpret_cast<char*>(_buffer.data()), stream.total_out);
+    return ConstDataRange(_buffer.data(), stream.total_out);
 }
 
 StatusWith<ConstDataRange> BlockCompressor::uncompress(ConstDataRange source,
@@ -112,7 +112,7 @@ StatusWith<ConstDataRange> BlockCompressor::uncompress(ConstDataRange source,
         return {ErrorCodes::ZLibError, str::stream() << "inflateEnd failed with " << err};
     }
 
-    return ConstDataRange(reinterpret_cast<char*>(_buffer.data()), stream.total_out);
+    return ConstDataRange(_buffer.data(), stream.total_out);
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/ftdc/decompressor.cpp b/src/mongo/db/ftdc/decompressor.cpp
index 3bba4db89e4..363064df5e6 100644
--- a/src/mongo/db/ftdc/decompressor.cpp
+++ b/src/mongo/db/ftdc/decompressor.cpp
@@ -42,19 +42,14 @@
 
 namespace mongo {
 
-StatusWith<std::vector<BSONObj>> FTDCDecompressor::uncompress(ConstDataRange buf) {
+StatusWith<std::vector<BSONObj>> FTDCDecompressor::uncompress(ConstDataRange buf) try {
     ConstDataRangeCursor compressedDataRange(buf);
 
     // Read the length of the uncompressed buffer
-    auto swUncompressedLength = compressedDataRange.readAndAdvance<LittleEndian<std::uint32_t>>();
-    if (!swUncompressedLength.isOK()) {
-        return {swUncompressedLength.getStatus()};
-    }
+    auto uncompressedLength = compressedDataRange.readAndAdvance<LittleEndian<std::uint32_t>>();
 
     // Now uncompress the data
     // Limit size of the buffer we need zlib
-    auto uncompressedLength = swUncompressedLength.getValue();
-
     if (uncompressedLength > 10000000) {
         return Status(ErrorCodes::InvalidLength, "Metrics chunk has exceeded the allowable size.");
     }
@@ -68,28 +63,13 @@ StatusWith<std::vector<BSONObj>> FTDCDecompressor::uncompress(ConstDataRange buf
     ConstDataRangeCursor cdc = statusUncompress.getValue();
 
     // The document is not part of any checksum so we must validate it is correct
-    auto swRef = cdc.readAndAdvance<Validated<BSONObj>>();
-    if (!swRef.isOK()) {
-        return {swRef.getStatus()};
-    }
-
-    BSONObj ref = swRef.getValue();
+    BSONObj ref = cdc.readAndAdvance<Validated<BSONObj>>();
 
     // Read count of metrics
-    auto swMetricsCount = cdc.readAndAdvance<LittleEndian<std::uint32_t>>();
-    if (!swMetricsCount.isOK()) {
-        return {swMetricsCount.getStatus()};
-    }
-
-    std::uint32_t metricsCount = swMetricsCount.getValue();
+    auto metricsCount = cdc.readAndAdvance<LittleEndian<std::uint32_t>>();
 
     // Read count of samples
-    auto swSampleCount = cdc.readAndAdvance<LittleEndian<std::uint32_t>>();
-    if (!swSampleCount.isOK()) {
-        return {swSampleCount.getStatus()};
-    }
-
-    std::uint32_t sampleCount = swSampleCount.getValue();
+    auto sampleCount = cdc.readAndAdvance<LittleEndian<std::uint32_t>>();
 
     // Limit size of the buffer we need for metrics and samples
     if (metricsCount * sampleCount > 1000000) {
@@ -138,23 +118,13 @@ StatusWith<std::vector<BSONObj>> FTDCDecompressor::uncompress(ConstDataRange buf
                 continue;
             }
 
-            auto swDelta = cdrc.readAndAdvance<FTDCVarInt>();
-
-            if (!swDelta.isOK()) {
-                return swDelta.getStatus();
-            }
-
-            if (swDelta.getValue() == 0) {
-                auto swZero = cdrc.readAndAdvance<FTDCVarInt>();
-
-                if (!swZero.isOK()) {
-                    return swDelta.getStatus();
-                }
-
-                zeroesCount = swZero.getValue();
+            auto delta = cdrc.readAndAdvance<FTDCVarInt>();
+            if (delta == 0) {
+                auto zero = cdrc.readAndAdvance<FTDCVarInt>();
+                zeroesCount = zero;
             }
 
-            deltas[FTDCCompressor::getArrayOffset(sampleCount, j, i)] = swDelta.getValue();
+            deltas[FTDCCompressor::getArrayOffset(sampleCount, j, i)] = delta;
         }
     }
 
@@ -179,6 +149,8 @@ StatusWith<std::vector<BSONObj>> FTDCDecompressor::uncompress(ConstDataRange buf
     }
 
     return {docs};
+} catch (const DBException& e) {
+    return e.toStatus();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/ftdc/file_reader.cpp b/src/mongo/db/ftdc/file_reader.cpp
index 9a1ada5628a..a5851680a49 100644
--- a/src/mongo/db/ftdc/file_reader.cpp
+++ b/src/mongo/db/ftdc/file_reader.cpp
@@ -202,7 +202,7 @@ StatusWith<BSONObj> FTDCFileReader::readDocument() {
     ConstDataRange cdr(_buffer.data(), _buffer.data() + bsonLength);
 
     // TODO: Validated only validates objects based on a flag which is the default at the moment
-    auto swl = cdr.read<Validated<BSONObj>>();
+    auto swl = cdr.readNoThrow<Validated<BSONObj>>();
     if (!swl.isOK()) {
         return swl.getStatus();
     }
diff --git a/src/mongo/db/logical_session_id_test.cpp b/src/mongo/db/logical_session_id_test.cpp
index ad74f23d15c..d994458332f 100644
--- a/src/mongo/db/logical_session_id_test.cpp
+++ b/src/mongo/db/logical_session_id_test.cpp
@@ -381,7 +381,7 @@ TEST_F(LogicalSessionIdTest, InitializeOperationSessionInfo_VerifyUIDEvenIfDoNot
     LogicalSessionFromClient lsid;
     lsid.setId(UUID::gen());
 
-    auto invalidDigest = SHA256Block::computeHash({ConstDataRange("hacker", 6)});
+    auto invalidDigest = SHA256Block::computeHash({ConstDataRange("hacker")});
     lsid.setUid(invalidDigest);
 
     ASSERT_THROWS_CODE(initializeOperationSessionInfo(
diff --git a/src/mongo/db/storage/storage_engine_metadata.cpp b/src/mongo/db/storage/storage_engine_metadata.cpp
index c461ca7a9a4..d48eb365625 100644
--- a/src/mongo/db/storage/storage_engine_metadata.cpp
+++ b/src/mongo/db/storage/storage_engine_metadata.cpp
@@ -176,7 +176,7 @@ Status StorageEngineMetadata::read() {
     }
 
     ConstDataRange cdr(&buffer[0], buffer.size());
-    auto swObj = cdr.read<Validated<BSONObj>>();
+    auto swObj = cdr.readNoThrow<Validated<BSONObj>>();
     if (!swObj.isOK()) {
         return swObj.getStatus();
     }
diff --git a/src/mongo/db/traffic_reader.cpp b/src/mongo/db/traffic_reader.cpp
index 2b2dcc9a732..7ce7ddcb112 100644
--- a/src/mongo/db/traffic_reader.cpp
+++ b/src/mongo/db/traffic_reader.cpp
@@ -122,12 +122,12 @@ boost::optional<TrafficReaderPacket> readPacket(char* buf, int fd) {
     ConstDataRangeCursor cdr(buf, buf + len);
 
     // Read the packet
-    uassertStatusOK(cdr.skip<LittleEndian<uint32_t>>());
-    uint64_t id = uassertStatusOK(cdr.readAndAdvance<LittleEndian<uint64_t>>());
-    StringData local = uassertStatusOK(cdr.readAndAdvance<Terminated<'\0', StringData>>());
-    StringData remote = uassertStatusOK(cdr.readAndAdvance<Terminated<'\0', StringData>>());
-    uint64_t date = uassertStatusOK(cdr.readAndAdvance<LittleEndian<uint64_t>>());
-    uint64_t order = uassertStatusOK(cdr.readAndAdvance<LittleEndian<uint64_t>>());
+    cdr.skip<LittleEndian<uint32_t>>();
+    uint64_t id = cdr.readAndAdvance<LittleEndian<uint64_t>>();
+    StringData local = cdr.readAndAdvance<Terminated<'\0', StringData>>();
+    StringData remote = cdr.readAndAdvance<Terminated<'\0', StringData>>();
+    uint64_t date = cdr.readAndAdvance<LittleEndian<uint64_t>>();
+    uint64_t order = cdr.readAndAdvance<LittleEndian<uint64_t>>();
     MsgData::ConstView message(cdr.data());
 
     return TrafficReaderPacket{
diff --git a/src/mongo/db/traffic_recorder.cpp b/src/mongo/db/traffic_recorder.cpp
index 8e73b91d37a..320f1f2b6ff 100644
--- a/src/mongo/db/traffic_recorder.cpp
+++ b/src/mongo/db/traffic_recorder.cpp
@@ -130,7 +130,7 @@ public:
                         uassertStatusOK(db.writeAndAdvance<LittleEndian<uint64_t>>(packet.order));
 
                         auto size = db.size() + toWrite.size();
-                        uassertStatusOK(db.getCursor().write<LittleEndian<uint32_t>>(size));
+                        db.getCursor().write<LittleEndian<uint32_t>>(size);
 
                         {
                             stdx::lock_guard<stdx::mutex> lk(_mutex);
diff --git a/src/mongo/idl/idl_parser.cpp b/src/mongo/idl/idl_parser.cpp
index bd189ee3631..a55de9283f6 100644
--- a/src/mongo/idl/idl_parser.cpp
+++ b/src/mongo/idl/idl_parser.cpp
@@ -297,7 +297,7 @@ std::vector<ConstDataRange> transformVector(const std::vector<std::vector<std::u
     output.reserve(input.size());
 
     std::transform(begin(input), end(input), std::back_inserter(output), [](auto&& vec) {
-        return makeCDR(vec);
+        return ConstDataRange(vec);
     });
 
     return output;
diff --git a/src/mongo/idl/idl_parser.h b/src/mongo/idl/idl_parser.h
index b250c22f551..32a3f83b1af 100644
--- a/src/mongo/idl/idl_parser.h
+++ b/src/mongo/idl/idl_parser.h
@@ -239,15 +239,4 @@ std::vector<std::string> transformVector(const std::vector<StringData>& input);
 std::vector<ConstDataRange> transformVector(const std::vector<std::vector<std::uint8_t>>& input);
 std::vector<std::vector<std::uint8_t>> transformVector(const std::vector<ConstDataRange>& input);
 
-/**
- * Get a ConstDataRange from a vector or an array of bytes.
- */
-inline ConstDataRange makeCDR(const std::vector<uint8_t>& value) {
-    return ConstDataRange(reinterpret_cast<const char*>(value.data()), value.size());
-}
-
-inline ConstDataRange makeCDR(const std::array<uint8_t, 16>& value) {
-    return ConstDataRange(reinterpret_cast<const char*>(value.data()), value.size());
-}
-
 }  // namespace mongo
diff --git a/src/mongo/idl/idl_test.cpp b/src/mongo/idl/idl_test.cpp
index 3663d2b137c..ab998137bf5 100644
--- a/src/mongo/idl/idl_test.cpp
+++ b/src/mongo/idl/idl_test.cpp
@@ -45,7 +45,7 @@ namespace mongo {
 namespace {
 
 bool isEquals(ConstDataRange left, const std::vector<uint8_t>& right) {
-    auto rightCDR = makeCDR(right);
+    ConstDataRange rightCDR(right);
     return std::equal(left.data(),
                       left.data() + left.length(),
                       rightCDR.data(),
@@ -1157,7 +1157,7 @@ void TestBinDataVector() {
     {
         BSONObjBuilder builder;
         ParserT one_new;
-        one_new.setValue(makeCDR(expected));
+        one_new.setValue(expected);
         testStruct.serialize(&builder);
 
         auto serializedDoc = builder.obj();
diff --git a/src/mongo/idl/idl_test_types.h b/src/mongo/idl/idl_test_types.h
index 48a41e4383d..990d3d64406 100644
--- a/src/mongo/idl/idl_test_types.h
+++ b/src/mongo/idl/idl_test_types.h
@@ -103,7 +103,7 @@ public:
     }
 
     ConstDataRange serializeToBSON() const {
-        return makeCDR(_vec);
+        return ConstDataRange(_vec);
     }
 
     const std::vector<std::uint8_t>& getVector() const {
diff --git a/src/mongo/rpc/object_check_test.cpp b/src/mongo/rpc/object_check_test.cpp
index ee187286a20..4006db63bc1 100644
--- a/src/mongo/rpc/object_check_test.cpp
+++ b/src/mongo/rpc/object_check_test.cpp
@@ -62,22 +62,22 @@ TEST(DataTypeValidated, BSONValidationEnabled) {
     {
         Validated<BSONObj> v;
         ConstDataRangeCursor cdrc(begin(buf), end(buf));
-        ASSERT_OK(cdrc.readAndAdvance(&v));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&v));
     }
 
     {
         // mess up the data
         DataRangeCursor drc(begin(buf), end(buf));
         // skip past size so we don't trip any sanity checks.
-        drc.advance(4).transitional_ignore();  // skip size
-        while (drc.writeAndAdvance(0xFF).isOK())
+        drc.advanceNoThrow(4).transitional_ignore();  // skip size
+        while (drc.writeAndAdvanceNoThrow(0xFF).isOK())
             ;
     }
 
     {
         Validated<BSONObj> v;
         ConstDataRangeCursor cdrc(begin(buf), end(buf));
-        ASSERT_NOT_OK(cdrc.readAndAdvance(&v));
+        ASSERT_NOT_OK(cdrc.readAndAdvanceNoThrow(&v));
     }
 
     {
@@ -85,7 +85,7 @@ TEST(DataTypeValidated, BSONValidationEnabled) {
         setValidation(false);
         Validated<BSONObj> v;
         ConstDataRangeCursor cdrc(begin(buf), end(buf));
-        ASSERT_OK(cdrc.readAndAdvance(&v));
+        ASSERT_OK(cdrc.readAndAdvanceNoThrow(&v));
     }
 }
 }
diff --git a/src/mongo/transport/asio_utils.h b/src/mongo/transport/asio_utils.h
index e44a43438cd..4bfbaee7e59 100644
--- a/src/mongo/transport/asio_utils.h
+++ b/src/mongo/transport/asio_utils.h
@@ -236,32 +236,33 @@ boost::optional<std::array<std::uint8_t, 7>> checkTLSRequest(const Buffer& buffe
 
     // Parse the record header.
     // Extract the ContentType from the header, and ensure it is a handshake.
-    StatusWith<std::uint8_t> record_ContentType = cdr.readAndAdvance<std::uint8_t>();
+    StatusWith<std::uint8_t> record_ContentType = cdr.readAndAdvanceNoThrow<std::uint8_t>();
     if (!record_ContentType.isOK() || record_ContentType.getValue() != ContentType_handshake) {
         return boost::none;
     }
     // Skip the record's ProtocolVersion. Clients tend to send TLS 1.0 in
     // the record, but then their real protocol version in the enclosed ClientHello.
-    StatusWith<ProtocolVersion> record_protocol_version = cdr.readAndAdvance<ProtocolVersion>();
+    StatusWith<ProtocolVersion> record_protocol_version =
+        cdr.readAndAdvanceNoThrow<ProtocolVersion>();
     if (!record_protocol_version.isOK()) {
         return boost::none;
     }
     // Parse the record length. It should be be larger than the remaining expected payload.
-    auto record_length = cdr.readAndAdvance<BigEndian<std::uint16_t>>();
+    auto record_length = cdr.readAndAdvanceNoThrow<BigEndian<std::uint16_t>>();
     if (!record_length.isOK() || record_length.getValue() < cdr.length()) {
         return boost::none;
     }
 
     // Parse the handshake header.
     // Extract the HandshakeType, and ensure it is a ClientHello.
-    StatusWith<std::uint8_t> handshake_type = cdr.readAndAdvance<std::uint8_t>();
+    StatusWith<std::uint8_t> handshake_type = cdr.readAndAdvanceNoThrow<std::uint8_t>();
     if (!handshake_type.isOK() || handshake_type.getValue() != HandshakeType_client_hello) {
         return boost::none;
     }
     // Extract the handshake length, and ensure it is larger than the remaining expected
     // payload. This requires a little work because the packet represents it with a uint24_t.
     StatusWith<std::array<std::uint8_t, 3>> handshake_length_bytes =
-        cdr.readAndAdvance<std::array<std::uint8_t, 3>>();
+        cdr.readAndAdvanceNoThrow<std::array<std::uint8_t, 3>>();
     if (!handshake_length_bytes.isOK()) {
         return boost::none;
     }
@@ -273,7 +274,7 @@ boost::optional<std::array<std::uint8_t, 7>> checkTLSRequest(const Buffer& buffe
     if (handshake_length < cdr.length()) {
         return boost::none;
     }
-    StatusWith<ProtocolVersion> client_version = cdr.readAndAdvance<ProtocolVersion>();
+    StatusWith<ProtocolVersion> client_version = cdr.readAndAdvanceNoThrow<ProtocolVersion>();
     if (!client_version.isOK()) {
         return boost::none;
     }
diff --git a/src/mongo/transport/message_compressor_manager.cpp b/src/mongo/transport/message_compressor_manager.cpp
index aeeeb2c0beb..a78667c31b6 100644
--- a/src/mongo/transport/message_compressor_manager.cpp
+++ b/src/mongo/transport/message_compressor_manager.cpp
@@ -53,31 +53,23 @@ struct CompressionHeader {
     uint8_t compressorId;
 
     void serialize(DataRangeCursor* cursor) {
-        uassertStatusOK(cursor->writeAndAdvance<LittleEndian<int32_t>>(originalOpCode));
-        uassertStatusOK(cursor->writeAndAdvance<LittleEndian<int32_t>>(uncompressedSize));
-        uassertStatusOK(cursor->writeAndAdvance<LittleEndian<uint8_t>>(compressorId));
+        cursor->writeAndAdvance<LittleEndian<int32_t>>(originalOpCode);
+        cursor->writeAndAdvance<LittleEndian<int32_t>>(uncompressedSize);
+        cursor->writeAndAdvance<LittleEndian<uint8_t>>(compressorId);
     }
 
     CompressionHeader(int32_t _opcode, int32_t _size, uint8_t _id)
         : originalOpCode{_opcode}, uncompressedSize{_size}, compressorId{_id} {}
 
     CompressionHeader(ConstDataRangeCursor* cursor) {
-        originalOpCode = _readWithChecking<LittleEndian<std::int32_t>>(cursor);
-        uncompressedSize = _readWithChecking<LittleEndian<std::int32_t>>(cursor);
-        compressorId = _readWithChecking<LittleEndian<uint8_t>>(cursor);
+        originalOpCode = cursor->readAndAdvance<LittleEndian<std::int32_t>>();
+        uncompressedSize = cursor->readAndAdvance<LittleEndian<std::int32_t>>();
+        compressorId = cursor->readAndAdvance<LittleEndian<uint8_t>>();
     }
 
     static size_t size() {
         return sizeof(originalOpCode) + sizeof(uncompressedSize) + sizeof(compressorId);
     }
-
-private:
-    template <typename T>
-    T _readWithChecking(ConstDataRangeCursor* cursor) {
-        auto sw = cursor->readAndAdvance<T>();
-        uassertStatusOK(sw.getStatus());
-        return sw.getValue();
-    }
 };
 
 const transport::Session::Decoration<MessageCompressorManager> getForSession =
diff --git a/src/mongo/transport/message_compressor_manager_test.cpp b/src/mongo/transport/message_compressor_manager_test.cpp
index 1418af12272..bffde5f9c29 100644
--- a/src/mongo/transport/message_compressor_manager_test.cpp
+++ b/src/mongo/transport/message_compressor_manager_test.cpp
@@ -334,10 +334,9 @@ TEST(MessageCompressorManager, MessageSizeTooLarge) {
     badMessage.setLen(128);
 
     DataRangeCursor cursor(badMessage.data(), badMessage.data() + badMessage.dataLen());
-    uassertStatusOK(cursor.writeAndAdvance<LittleEndian<int32_t>>(dbQuery));
-    uassertStatusOK(cursor.writeAndAdvance<LittleEndian<int32_t>>(MaxMessageSizeBytes + 1));
-    uassertStatusOK(
-        cursor.writeAndAdvance<LittleEndian<uint8_t>>(registry.getCompressor("noop")->getId()));
+    cursor.writeAndAdvance<LittleEndian<int32_t>>(dbQuery);
+    cursor.writeAndAdvance<LittleEndian<int32_t>>(MaxMessageSizeBytes + 1);
+    cursor.writeAndAdvance<LittleEndian<uint8_t>>(registry.getCompressor("noop")->getId());
 
     auto status = compManager.decompressMessage(Message(badMessageBuffer), nullptr).getStatus();
     ASSERT_NOT_OK(status);
@@ -357,8 +356,8 @@ TEST(MessageCompressorManager, RuntMessage) {
     // This is a totally bogus compression header of just the orginal opcode + 0 byte uncompressed
     // size
     DataRangeCursor cursor(badMessage.data(), badMessage.data() + badMessage.dataLen());
-    uassertStatusOK(cursor.writeAndAdvance<LittleEndian<int32_t>>(dbQuery));
-    uassertStatusOK(cursor.writeAndAdvance<LittleEndian<int32_t>>(0));
+    cursor.writeAndAdvance<LittleEndian<int32_t>>(dbQuery);
+    cursor.writeAndAdvance<LittleEndian<int32_t>>(0);
 
     auto status = compManager.decompressMessage(Message(badMessageBuffer), nullptr).getStatus();
     ASSERT_NOT_OK(status);
diff --git a/src/mongo/transport/message_compressor_noop.h b/src/mongo/transport/message_compressor_noop.h
index 3eeb08f83b3..e8f07560d64 100644
--- a/src/mongo/transport/message_compressor_noop.h
+++ b/src/mongo/transport/message_compressor_noop.h
@@ -39,16 +39,20 @@ public:
         return inputSize;
     }
 
-    StatusWith<std::size_t> compressData(ConstDataRange input, DataRange output) override {
-        output.write(input).transitional_ignore();
+    StatusWith<std::size_t> compressData(ConstDataRange input, DataRange output) override try {
+        output.write(input);
         counterHitCompress(input.length(), input.length());
         return {input.length()};
+    } catch (const DBException& e) {
+        return e.toStatus();
     }
 
-    StatusWith<std::size_t> decompressData(ConstDataRange input, DataRange output) override {
-        output.write(input).transitional_ignore();
+    StatusWith<std::size_t> decompressData(ConstDataRange input, DataRange output) override try {
+        output.write(input);
         counterHitDecompress(input.length(), input.length());
         return {input.length()};
+    } catch (const DBException& e) {
+        return e.toStatus();
     }
 };
 }  // namespace mongo
diff --git a/src/mongo/util/bufreader.h b/src/mongo/util/bufreader.h
index 42ff79af60c..90e270e7f90 100644
--- a/src/mongo/util/bufreader.h
+++ b/src/mongo/util/bufreader.h
@@ -64,7 +64,7 @@ public:
     template <typename T>
     void read(T& t) {
         ConstDataRangeCursor cdrc(_pos, _end);
-        uassertStatusOK(cdrc.readAndAdvance(&t));
+        cdrc.readAndAdvance(&t);
         _pos = cdrc.data();
     }
 
@@ -79,7 +79,7 @@ public:
     /** read in the object specified, but do not advance buffer pointer */
     template <typename T>
     void peek(T& t) const {
-        uassertStatusOK(ConstDataRange(_pos, _end).readInto(&t));
+        ConstDataRange(_pos, _end).readInto(&t);
     }
 
     /** read in and return an object of the specified type, but do not advance buffer pointer */
@@ -109,7 +109,7 @@ public:
     /** return current position pointer, and advance by len */
     const void* skip(unsigned len) {
         ConstDataRangeCursor cdrc(_pos, _end);
-        uassertStatusOK(cdrc.advance(len));
+        cdrc.advance(len);
         return std::exchange(_pos, cdrc.data());
     }
 
diff --git a/src/mongo/util/net/http_client_curl.cpp b/src/mongo/util/net/http_client_curl.cpp
index b96018cbb01..1f3e6534dbe 100644
--- a/src/mongo/util/net/http_client_curl.cpp
+++ b/src/mongo/util/net/http_client_curl.cpp
@@ -174,7 +174,7 @@ size_t ReadMemoryCallback(char* buffer, size_t size, size_t nitems, void* instre
     if (cdrc->length() > 0) {
         size_t readSize = std::min(size * nitems, cdrc->length());
         memcpy(buffer, cdrc->data(), readSize);
-        invariant(cdrc->advance(readSize).isOK());
+        invariant(cdrc->advanceNoThrow(readSize).isOK());
         ret = readSize;
     }
 
diff --git a/src/mongo/util/net/ssl_manager.cpp b/src/mongo/util/net/ssl_manager.cpp
index 85fc0ccd36b..d1b0cfe96df 100644
--- a/src/mongo/util/net/ssl_manager.cpp
+++ b/src/mongo/util/net/ssl_manager.cpp
@@ -825,7 +825,7 @@ struct DataType::Handler<DERToken> {
 namespace {
 
 StatusWith<std::string> readDERString(ConstDataRangeCursor& cdc) {
-    auto swString = cdc.readAndAdvance<DERToken>();
+    auto swString = cdc.readAndAdvanceNoThrow<DERToken>();
     if (!swString.isOK()) {
         return swString.getStatus();
     }
@@ -849,7 +849,7 @@ StatusWith<DERToken> DERToken::parse(ConstDataRange cdr, size_t* outLength) {
 
     ConstDataRangeCursor cdrc(cdr);
 
-    auto swTagByte = cdrc.readAndAdvance<char>();
+    auto swTagByte = cdrc.readAndAdvanceNoThrow<char>();
     if (!swTagByte.getStatus().isOK()) {
         return swTagByte.getStatus();
     }
@@ -893,7 +893,7 @@ StatusWith<DERToken> DERToken::parse(ConstDataRange cdr, size_t* outLength) {
 
     // Read length
     // Depending on the high bit, either read 1 byte or N bytes
-    auto swInitialLengthByte = cdrc.readAndAdvance<char>();
+    auto swInitialLengthByte = cdrc.readAndAdvanceNoThrow<char>();
     if (!swInitialLengthByte.getStatus().isOK()) {
         return swInitialLengthByte.getStatus();
     }
@@ -918,7 +918,7 @@ StatusWith<DERToken> DERToken::parse(ConstDataRange cdr, size_t* outLength) {
         // Ensure we have enough data for the length bytes
         const char* lengthLongFormPtr = cdrc.data();
 
-        Status statusLength = cdrc.advance(lengthBytesCount);
+        Status statusLength = cdrc.advanceNoThrow(lengthBytesCount);
         if (!statusLength.isOK()) {
             return statusLength;
         }
@@ -965,7 +965,7 @@ StatusWith<stdx::unordered_set<RoleName>> parsePeerRoles(ConstDataRange cdrExten
      *  ...!UTF8String:"Unrecognized entity in MongoDBAuthorizationGrant"
      * }
      */
-    auto swSet = cdcExtension.readAndAdvance<DERToken>();
+    auto swSet = cdcExtension.readAndAdvanceNoThrow<DERToken>();
     if (!swSet.isOK()) {
         return swSet.getStatus();
     }
@@ -986,7 +986,7 @@ StatusWith<stdx::unordered_set<RoleName>> parsePeerRoles(ConstDataRange cdrExten
          *  database UTF8String
          * }
          */
-        auto swSequence = cdcSet.readAndAdvance<DERToken>();
+        auto swSequence = cdcSet.readAndAdvanceNoThrow<DERToken>();
         if (!swSequence.isOK()) {
             return swSequence.getStatus();
         }
diff --git a/src/mongo/util/net/ssl_manager_test.cpp b/src/mongo/util/net/ssl_manager_test.cpp
index 0614c41445e..acf4d04e438 100644
--- a/src/mongo/util/net/ssl_manager_test.cpp
+++ b/src/mongo/util/net/ssl_manager_test.cpp
@@ -114,8 +114,7 @@ TEST(SSLManager, MongoDBRolesParser) {
         unsigned char derData[] = {0x31, 0x1a, 0x30, 0x18, 0x0c, 0x09, 0x72, 0x6f, 0x6c, 0x65,
                                    0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69,
                                    0x72, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_OK(swPeer.getStatus());
         auto item = *(swPeer.getValue().begin());
         ASSERT_EQ(item.getRole(), "role_name");
@@ -148,8 +147,7 @@ TEST(SSLManager, MongoDBRolesParser) {
             0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c,
             0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
             0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69, 0x72, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_OK(swPeer.getStatus());
 
         auto item = *(swPeer.getValue().begin());
@@ -168,24 +166,21 @@ TEST(SSLManager, MongoDBRolesParser) {
                                    0x6e, 0x61, 0x6d, 0x65, 0x0c, 0x0b, 0x54, 0x68, 0x69, 0x72,
                                    0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64};
 
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
     // Negative: Runt, only a tag
     {
         unsigned char derData[] = {0x31};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
     // Negative: Runt, only a tag and short length
     {
         unsigned char derData[] = {0x31, 0x0b};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
@@ -194,8 +189,7 @@ TEST(SSLManager, MongoDBRolesParser) {
         unsigned char derData[] = {
             0x31, 0x88, 0xff, 0xff,
         };
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
@@ -204,8 +198,7 @@ TEST(SSLManager, MongoDBRolesParser) {
         unsigned char derData[] = {
             0x31, 0x82, 0xff, 0xff,
         };
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
@@ -213,8 +206,7 @@ TEST(SSLManager, MongoDBRolesParser) {
     {
         unsigned char derData[] = {
             0x0c, 0x0b, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
@@ -222,8 +214,7 @@ TEST(SSLManager, MongoDBRolesParser) {
     {
         unsigned char derData[] = {
             0x16, 0x0b, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_NOT_OK(swPeer.getStatus());
     }
 
@@ -234,8 +225,7 @@ TEST(SSLManager, MongoDBRolesParser) {
                                    0x6e, 0x30, 0x18, 0x0c, 0x0f, 0x72, 0x65, 0x61, 0x64,
                                    0x41, 0x6e, 0x79, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61,
                                    0x73, 0x65, 0x0c, 0x05, 0x61, 0x64, 0x6d, 0x69, 0x6e};
-        auto swPeer = parsePeerRoles(ConstDataRange(reinterpret_cast<char*>(derData),
-                                                    std::extent<decltype(derData)>::value));
+        auto swPeer = parsePeerRoles(ConstDataRange(derData));
         ASSERT_OK(swPeer.getStatus());
 
         auto roles = getSortedRoles(swPeer.getValue());
diff --git a/src/mongo/util/uuid.h b/src/mongo/util/uuid.h
index 401738d4400..de3a9c3f543 100644
--- a/src/mongo/util/uuid.h
+++ b/src/mongo/util/uuid.h
@@ -125,7 +125,7 @@ public:
      * Returns a ConstDataRange view of the UUID.
      */
     ConstDataRange toCDR() const {
-        return ConstDataRange(reinterpret_cast<const char*>(_uuid.data()), _uuid.size());
+        return ConstDataRange(_uuid);
     }
 
     /**