SERVER-15174 Provide some improved semantics for data_cursor and data_view

3 files changed, 142 insertions, 57 deletions

diff --git a/src/mongo/base/data_cursor.h b/src/mongo/base/data_cursor.h
index 135af3b1a05..f601ea3b740 100644
--- a/src/mongo/base/data_cursor.h
+++ b/src/mongo/base/data_cursor.h
@@ -35,102 +35,180 @@
 
 namespace mongo {
 
-    template <class T>
-    struct CursorMethods : public T {
+    class ConstDataCursor : public ConstDataView {
+    public:
+
+        typedef ConstDataView view_type;
 
-        CursorMethods(typename T::bytes_type bytes) : T(bytes) {}
+        ConstDataCursor(ConstDataView::bytes_type bytes)
+            : ConstDataView(bytes) {
+        }
 
-        T operator+(std::size_t s) const {
-            return this->T::view() + s;
+        ConstDataCursor operator+(std::size_t s) const {
+            return view() + s;
         }
 
-        T& operator+=(std::size_t s) {
-            *this = this->T::view() + s;
+        ConstDataCursor& operator+=(std::size_t s) {
+            *this = view() + s;
             return *this;
         }
 
-        T operator-(std::size_t s) const {
-            return this->T::view() - s;
+        ConstDataCursor operator-(std::size_t s) const {
+            return view() - s;
         }
 
-        T& operator-=(std::size_t s) {
-            *this = this->T::view() - s;
+        ConstDataCursor& operator-=(std::size_t s) {
+            *this = view() - s;
             return *this;
         }
 
-        T& operator++() {
-            return this->operator+=(1);
+        ConstDataCursor& operator++() {
+            return operator+=(1);
         }
 
-        T operator++(int) {
-            T tmp = *this;
+        ConstDataCursor operator++(int) {
+            ConstDataCursor tmp = *this;
             operator++();
             return tmp;
         }
 
-        T& operator--() {
-            return this->operator-=(1);
+        ConstDataCursor& operator--() {
+            return operator-=(1);
         }
 
-        T operator--(int) {
-            T tmp = *this;
+        ConstDataCursor operator--(int) {
+            ConstDataCursor tmp = *this;
             operator--();
             return tmp;
         }
 
-        template <typename U>
-        void skip() {
-            *this = this->T::view() + sizeof(U);
+        template <typename T>
+        ConstDataCursor& skip() {
+            *this = view() + sizeof(T);
+            return *this;
         }
 
-        template <typename U>
-        U readNativeAndAdvance() {
-            U out = this->T::template readNative<U>();
-            this->skip<U>();
+        template <typename T>
+        ConstDataCursor& readNativeAndAdvance(T* t) {
+            readNative(t);
+            skip<T>();
+            return *this;
+        }
+
+        template <typename T>
+        T readNativeAndAdvance() {
+            T out;
+            readNativeAndAdvance(&out);
             return out;
         }
 
-        template <typename U>
-        U readLEAndAdvance() {
-            return littleToNative(readNativeAndAdvance<U>());
+        template <typename T>
+        T readLEAndAdvance() {
+            return endian::littleToNative(readNativeAndAdvance<T>());
         }
 
-        template <typename U>
-        U readBEAndAdvance() {
-            return bigToNative(readNativeAndAdvance<U>());
+        template <typename T>
+        T readBEAndAdvance() {
+            return endian::bigToNative(readNativeAndAdvance<T>());
         }
 
     };
 
-    class ConstDataCursor : public CursorMethods<ConstDataView> {
+    class DataCursor : public DataView {
     public:
 
-        ConstDataCursor(ConstDataView::bytes_type bytes) : CursorMethods<ConstDataView>(bytes) {}
-    };
+        typedef DataView view_type;
 
-    class DataCursor : public CursorMethods<DataView> {
-    public:
+        DataCursor(DataView::bytes_type bytes)
+            : DataView(bytes) {}
+
+        operator ConstDataCursor() const {
+            return view();
+        }
+
+        DataCursor operator+(std::size_t s) const {
+            return view() + s;
+        }
+
+        DataCursor& operator+=(std::size_t s) {
+            *this = view() + s;
+            return *this;
+        }
+
+        DataCursor operator-(std::size_t s) const {
+            return view() - s;
+        }
+
+        DataCursor& operator-=(std::size_t s) {
+            *this = view() - s;
+            return *this;
+        }
+
+        DataCursor& operator++() {
+            return operator+=(1);
+        }
+
+        DataCursor operator++(int) {
+            DataCursor tmp = *this;
+            operator++();
+            return tmp;
+        }
 
-        DataCursor(DataView::bytes_type bytes) : CursorMethods<DataView>(bytes) {}
+        DataCursor& operator--() {
+            return operator-=(1);
+        }
+
+        DataCursor operator--(int) {
+            DataCursor tmp = *this;
+            operator--();
+            return tmp;
+        }
 
         template <typename T>
-        void writeNativeAndAdvance(const T& value) {
-            this->writeNative(value);
-            this->skip<T>();
+        DataCursor& skip() {
+            *this = view() + sizeof(T);
+            return *this;
         }
 
         template <typename T>
-        void writeLEAndAdvance(const T& value) {
-            return writeNativeAndAdvance(nativeToLittle(value));
+        DataCursor& readNativeAndAdvance(T* t) {
+            readNative(t);
+            skip<T>();
+            return *this;
         }
 
         template <typename T>
-        void writeBEAndAdvance(const T& value) {
-            return writeNativeAndAdvance(nativeToBig(value));
+        T readNativeAndAdvance() {
+            T out;
+            readNativeAndAdvance(&out);
+            return out;
         }
 
-        operator ConstDataCursor() const {
-            return view();
+        template <typename T>
+        T readLEAndAdvance() {
+            return endian::littleToNative(readNativeAndAdvance<T>());
+        }
+
+        template <typename T>
+        T readBEAndAdvance() {
+            return endian::bigToNative(readNativeAndAdvance<T>());
+        }
+
+        template <typename T>
+        DataCursor& writeNativeAndAdvance(const T& value) {
+            writeNative(value);
+            skip<T>();
+            return *this;
+        }
+
+        template <typename T>
+        DataCursor& writeLEAndAdvance(const T& value) {
+            return writeNativeAndAdvance(endian::nativeToLittle(value));
+        }
+
+        template <typename T>
+        DataCursor& writeBEAndAdvance(const T& value) {
+            return writeNativeAndAdvance(endian::nativeToBig(value));
         }
     };
 
diff --git a/src/mongo/base/data_view.h b/src/mongo/base/data_view.h
index f0430d6a504..9b4d43762e8 100644
--- a/src/mongo/base/data_view.h
+++ b/src/mongo/base/data_view.h
@@ -47,20 +47,26 @@ namespace mongo {
         }
 
         template<typename T>
+        const ConstDataView& readNative(T* t, size_t offset = 0) const {
+            std::memcpy(t, view(offset), sizeof(*t));
+            return *this;
+        }
+
+        template<typename T>
         T readNative(std::size_t offset = 0) const {
             T t;
-            std::memcpy(&t, view(offset), sizeof(t));
+            readNative(&t, offset);
             return t;
         }
 
         template<typename T>
         T readLE(std::size_t offset = 0) const {
-            return littleToNative(readNative<T>(offset));
+            return endian::littleToNative(readNative<T>(offset));
         }
 
         template<typename T>
         T readBE(std::size_t offset = 0) const {
-            return bigToNative(readNative<T>(offset));
+            return endian::bigToNative(readNative<T>(offset));
         }
 
     private:
@@ -83,18 +89,19 @@ namespace mongo {
         }
 
         template<typename T>
-        void writeNative(const T& value, std::size_t offset = 0) {
+        DataView& writeNative(const T& value, std::size_t offset = 0) {
             std::memcpy(view(offset), &value, sizeof(value));
+            return *this;
         }
 
         template<typename T>
-        void writeLE(const T& value, std::size_t offset = 0) {
-            return writeNative(nativeToLittle(value), offset);
+        DataView& writeLE(const T& value, std::size_t offset = 0) {
+            return writeNative(endian::nativeToLittle(value), offset);
         }
 
         template<typename T>
-        void writeBE(const T& value, std::size_t offset = 0) {
-            return writeNative(nativeToBig(value), offset);
+        DataView& writeBE(const T& value, std::size_t offset = 0) {
+            return writeNative(endian::nativeToBig(value), offset);
         }
     };
 
diff --git a/src/mongo/base/data_view_test.cpp b/src/mongo/base/data_view_test.cpp
index 2f224d5a71b..288d44f0f8e 100644
--- a/src/mongo/base/data_view_test.cpp
+++ b/src/mongo/base/data_view_test.cpp
@@ -38,8 +38,8 @@ namespace mongo {
     TEST(DataView, ConstDataView) {
         char buf[sizeof(uint32_t) * 3];
         uint32_t native = 1234;
-        uint32_t le = nativeToLittle(native);
-        uint32_t be = nativeToBig(native);
+        uint32_t le = endian::nativeToLittle(native);
+        uint32_t be = endian::nativeToBig(native);
 
         std::memcpy(buf, &native, sizeof(uint32_t));
         std::memcpy(buf + sizeof(uint32_t), &le, sizeof(uint32_t));