feat: write/read string

Author: KobeBryant114514

include/binarystream/BinaryStream.hpp

@@ -50,8 +50,11 @@ class BinaryStream : public ReadOnlyBinaryStream {
     BSAPI void writeNormalizedFloat(float value);
     BSAPI void writeSignedBigEndianInt(int32_t value);
     BSAPI void writeString(std::string_view value);
+    BSAPI void writeShortString(std::string_view value);
+    BSAPI void writeLongString(std::string_view value);
     BSAPI void writeUnsignedInt24(uint32_t value);
     BSAPI void writeRawBytes(std::string_view rawBuffer);
+    BSAPI void writeRawBytes(std::string_view rawBuffer, size_t size);
     BSAPI void writeStream(ReadOnlyBinaryStream const& stream);
 };
 

include/binarystream/ReadOnlyBinaryStream.hpp

@@ -105,9 +105,15 @@ class ReadOnlyBinaryStream {
     [[nodiscard]] BSAPI int32_t   getSignedBigEndianInt() noexcept;
     [[nodiscard]] BSAPI uint32_t  getUnsignedInt24() noexcept;
 
-    BSAPI void          getString(std::string& outString);
+    BSAPI void getString(std::string& outString);
+    BSAPI void getShortString(std::string& outString);
+    BSAPI void getLongString(std::string& outString);
+
     [[nodiscard]] BSAPI std::string getString();
-    BSAPI void                      getRawBytes(std::string& rawBuffer, size_t length);
+    [[nodiscard]] BSAPI std::string getShortString();
+    [[nodiscard]] BSAPI std::string getLongString();
+
+    BSAPI void          getRawBytes(std::string& rawBuffer, size_t length);
     [[nodiscard]] BSAPI std::string getRawBytes(size_t length);
 };
 

src/binarystream/BinaryStream.cpp

@@ -121,11 +121,21 @@ void BinaryStream::writeNormalizedFloat(float value) {
 void BinaryStream::writeSignedBigEndianInt(int32_t value) { write(value, true); }
 
 void BinaryStream::writeString(std::string_view value) {
-    writeUnsignedVarInt(static_cast<uint32_t>(value.size()));
-    if (!value.empty()) {
-        mBuffer.append(value.data(), value.size());
-        mBufferView = mBuffer;
-    }
+    auto size = static_cast<uint32_t>(value.size());
+    writeUnsignedVarInt(size);
+    writeRawBytes(value, size);
+}
+
+void BinaryStream::writeShortString(std::string_view value) {
+    auto size = static_cast<uint16_t>(value.size());
+    writeSignedShort(size);
+    writeRawBytes(value, size);
+}
+
+void BinaryStream::writeLongString(std::string_view value) {
+    auto size = static_cast<int>(value.size());
+    writeSignedInt(size);
+    writeRawBytes(value, size);
 }
 
 void BinaryStream::writeUnsignedInt24(uint32_t value) {
@@ -147,6 +157,13 @@ void BinaryStream::writeRawBytes(std::string_view rawBuffer) {
     }
 }
 
+void BinaryStream::writeRawBytes(std::string_view rawBuffer, size_t size) {
+    if (!rawBuffer.empty()) {
+        mBuffer.append(rawBuffer.data(), size);
+        mBufferView = mBuffer;
+    }
+}
+
 void BinaryStream::writeStream(ReadOnlyBinaryStream const& stream) { writeRawBytes(stream.view()); }
 
 } // namespace bstream

src/binarystream/ReadOnlyBinaryStream.cpp

@@ -218,19 +218,17 @@ int32_t ReadOnlyBinaryStream::getSignedBigEndianInt() noexcept {
 
 void ReadOnlyBinaryStream::getString(std::string& outString) {
     uint32_t length = getUnsignedVarInt();
-    if (mHasOverflowed || length == 0) {
-        outString.clear();
-        return;
-    }
+    getRawBytes(outString, length);
+}
 
-    if (mReadPointer + length > mBufferView.size()) {
-        mHasOverflowed = true;
-        outString.clear();
-        return;
-    }
+void ReadOnlyBinaryStream::getShortString(std::string& outString) {
+    short length = getSignedShort();
+    getRawBytes(outString, length);
+}
 
-    outString.assign(mBufferView.substr(mReadPointer, length));
-    mReadPointer += length;
+void ReadOnlyBinaryStream::getLongString(std::string& outString) {
+    int length = getSignedInt();
+    getRawBytes(outString, length);
 }
 
 std::string ReadOnlyBinaryStream::getString() {
@@ -239,6 +237,18 @@ std::string ReadOnlyBinaryStream::getString() {
     return result;
 }
 
+std::string ReadOnlyBinaryStream::getShortString() {
+    std::string result;
+    getShortString(result);
+    return result;
+}
+
+std::string ReadOnlyBinaryStream::getLongString() {
+    std::string result;
+    getLongString(result);
+    return result;
+}
+
 uint32_t ReadOnlyBinaryStream::getUnsignedInt24() noexcept {
     if (mReadPointer + 3 > mBufferView.size()) {
         mHasOverflowed = true;