1 files changed, 46 insertions, 39 deletions

diff --git a/ble/ByteBuffer.cpp b/ble/ByteBuffer.cpp
index 40ba06c..8aea2c8 100644
--- a/ble/ByteBuffer.cpp
+++ b/ble/ByteBuffer.cpp
@@ -9,29 +9,25 @@
 
 using namespace std;
 
-ByteBuffer::ByteBuffer(uint8_t* bytes, size_t size) :
-    zero(bytes), end_(&bytes[size]), cursor(bytes) {
-}
-
 ByteBuffer &ByteBuffer::write8(uint8_t value) {
-    assertCanAccessRelative(1);
-    (*cursor++) = value;
+    assertCanAccessPtr(cursor + 1);
+    *cursor++ = value;
     return *this;
 }
 
 ByteBuffer &ByteBuffer::write16le(uint16_t value) {
-    assertCanAccessRelative(2);
-    (*cursor++) = (uint8_t) (value & 0xff);
-    (*cursor++) = (uint8_t) ((value >> 8) & 0xff);
+    assertCanAccessPtr(cursor + 2);
+    *cursor++ = (uint8_t) (value & 0xff);
+    *cursor++ = (uint8_t) ((value >> 8) & 0xff);
     return *this;
 }
 
 ByteBuffer &ByteBuffer::write32le(uint32_t value) {
-    assertCanAccessRelative(4);
-    (*cursor++) = (uint8_t) (value & 0xff);
-    (*cursor++) = (uint8_t) ((value >> 8) & 0xff);
-    (*cursor++) = (uint8_t) ((value >> 16) & 0xff);
-    (*cursor++) = (uint8_t) ((value >> 24) & 0xff);
+    assertCanAccessPtr(cursor + 4);
+    *cursor++ = (uint8_t) (value & 0xff);
+    *cursor++ = (uint8_t) ((value >> 8) & 0xff);
+    *cursor++ = (uint8_t) ((value >> 16) & 0xff);
+    *cursor++ = (uint8_t) ((value >> 24) & 0xff);
     return *this;
 }
 
@@ -40,7 +36,7 @@ ByteBuffer &ByteBuffer::write(const ByteBuffer &value) {
 }
 
 ByteBuffer &ByteBuffer::write(const uint8_t *bytes, size_t len) {
-    assertCanAccessRelative(len);
+    assertCanAccessPtr(cursor + len);
 
     std::memcpy(cursor, bytes, len);
 
@@ -100,7 +96,7 @@ ByteBuffer &ByteBuffer::writeFLOAT(double d) {
             mdiff = abs(smantissa - rmantissa);
         }
 
-        uint32_t int_mantissa = (uint32_t) round(sgn * mantissa);
+        auto int_mantissa = uint32_t(round(sgn * mantissa));
         result = (exponent << 24) | (int_mantissa & 0xFFFFFF);
     }
 
@@ -108,22 +104,22 @@ ByteBuffer &ByteBuffer::writeFLOAT(double d) {
 }
 
 uint8_t ByteBuffer::get8(size_t index) const {
-    assertCanAccessRelative(index);
+    assertCanAccessPosition(index);
     return zero[index];
 }
 
 uint8_t ByteBuffer::peek8(size_t relative_index) const {
-    assertCanAccessRelative(relative_index);
+    assertCanAccessPtr(cursor + relative_index);
     return cursor[relative_index];
 }
 
 uint8_t ByteBuffer::read8() {
-    assertCanAccessRelative(0);
+    assertCanAccessPtr(cursor);
     return *cursor++;
 }
 
 uint16_t ByteBuffer::read16le() {
-    assertCanAccessRelative(1);
+    assertCanAccessPtr(cursor + 1);
     uint16_t value;
     value = *cursor++;
     value |= ((uint16_t) *cursor++) << 8;
@@ -131,7 +127,7 @@ uint16_t ByteBuffer::read16le() {
 }
 
 uint32_t ByteBuffer::read32le() {
-    assertCanAccessRelative(3);
+    assertCanAccessPtr(cursor + 3);
     uint32_t value;
     value = *cursor++;
     value |= ((uint32_t) *cursor++) << 8;
@@ -166,39 +162,46 @@ double ByteBuffer::readFLOAT() {
     return output;
 }
 
-void ByteBuffer::copy(uint8_t *bytes, size_t length) const {
-    assertCanAccessRelative(length - 1);
+void ByteBuffer::copyFromEntire(const ByteBuffer &other) const {
+    size_t length = other.getPosition();
 
-    std::memcpy(bytes, cursor, length);
+    assertCanAccessPosition(length - 1);
+    std::memcpy(cursor, other.zero, length);
 }
 
-void ByteBuffer::copy(ByteBuffer& other) const {
-    other.assertCanAccessRelative(getBytesLeft());
+void ByteBuffer::copyTo(uint8_t *bytes, size_t length) const {
+    assertCanAccessPtr(&cursor[length - 1]);
 
-    std::memcpy(other.cursor, cursor, getBytesLeft());
-}
-
-void ByteBuffer::reset() {
-    cursor = const_cast<uint8_t *>(zero);
+    std::memcpy(bytes, cursor, length);
 }
 
-ByteBuffer ByteBuffer::view() const {
+ByteBuffer ByteBuffer::viewCursorToEnd() const {
 //    LOG_DEBUG("cursor=" << getCursor() << ", size=" << getSize() << ", new size=" << end_ - cursor << ", cursor=" << (uint64_t) cursor << ", zero=" << (uint64_t) zero);
     return {cursor, getBytesLeft()};
 }
 
-ByteBuffer ByteBuffer::view(size_t length) const {
-    assertCanAccessRelative(length - 1);
+ByteBuffer ByteBuffer::viewBeginningToCursor() const {
+    return {zero, getPosition()};
+}
+
+ByteBuffer ByteBuffer::viewForward(size_t length) const {
+    assertCanAccessPtr(&cursor[length - 1]);
     return {cursor, length};
 }
 
-void ByteBuffer::assertCanAccessRelative(size_t diff) const {
-    assertCanAccessIndex(cursor + diff);
+ByteBuffer ByteBuffer::viewForwardAndSkip(size_t length){
+    auto v = viewForward(length);
+    skip(length);
+    return v;
+}
+
+void ByteBuffer::assertCanAccessPosition(size_t position) const {
+    assertCanAccessPtr(&zero[position]);
 }
 
-void ByteBuffer::assertCanAccessIndex(uint8_t *p) const {
-    if (p >= end_ || p < zero) {
-        throw ByteBufferException("Out of bounds! size=" + to_string(getSize()) + ", index=" + to_string(p - zero));
+void ByteBuffer::assertCanAccessPtr(uint8_t *ptr) const {
+    if (ptr >= end_ || ptr < zero) {
+        throw ByteBufferException("Out of bounds! size=" + to_string(getSize()) + ", index=" + to_string(ptr - zero));
     }
 }
 
@@ -211,3 +214,7 @@ std::string ByteBuffer::toString() const {
 
     return string(s.str());
 }
+
+const ByteBuffer ByteBuffer::wrap(const uint8_t *bytes, size_t capacity, size_t cursor) noexcept {
+    return {const_cast<uint8_t *>(bytes), capacity, cursor};
+}