utilities: Implemented an ostream that writes to a user provided buffer

source/common/common/utility.cc

@@ -4,6 +4,8 @@
 #include <chrono>
 #include <cmath>
 #include <cstdint>
+#include <ios>
+#include <iostream>
 #include <iterator>
 #include <regex>
 #include <string>
@@ -221,6 +223,15 @@ std::string DateFormatter::now(TimeSource& time_source) {
   return fromTime(time_source.systemTime());
 }
 
+FixedSizeStreamBuffer::FixedSizeStreamBuffer(char* base, size_t size) {
+  this->setp(base, base + size);
+}
+
+OutputBufferStream::OutputBufferStream(char* data, size_t size)
+    : FixedSizeStreamBuffer{data, size}, std::ostream{static_cast<std::streambuf*>(this)} {}
+
+int OutputBufferStream::numValidBytesWrittenToBuffer() { return pptr() - pbase(); }
+
 ConstMemoryStreamBuffer::ConstMemoryStreamBuffer(const char* data, size_t size) {
   // std::streambuf won't modify `data`, but the interface still requires a char* for convenience,
   // so we need to const_cast.

source/common/common/utility.h

@@ -2,6 +2,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <ios>
 #include <set>
 #include <sstream>
 #include <string>
@@ -110,6 +111,27 @@ class RealTimeSource : public TimeSource {
   MonotonicTime monotonicTime() override { return std::chrono::steady_clock::now(); }
 };
 
+/**
+ * Class used for creating non-memory allocating std::ostream.
+ */
+class FixedSizeStreamBuffer : public std::streambuf {
+public:
+  FixedSizeStreamBuffer(char* base, size_t size);
+};
+
+/**
+ * std::ostream class that serializes writes into the provided buffer.
+ */
+class OutputBufferStream : private FixedSizeStreamBuffer, public std::ostream {
+public:
+  OutputBufferStream(char* data, size_t size);
+
+  /**
+   * @return the number of bytes written prior to the "put" pointer into the buffer.
+   */
+  int numValidBytesWrittenToBuffer();
+};
+
 /**
  * Class used for creating non-copying std::istream's. See InputConstMemoryStream below.
  */

test/common/common/BUILD

@@ -205,6 +205,7 @@ envoy_cc_test(
     ],
     deps = [
         "//source/common/common:utility_lib",
+        "//test/common/stats:stat_test_utility_lib",
         "//test/test_common:simulated_time_system_lib",
         "//test/test_common:test_time_lib",
         "//test/test_common:utility_lib",

test/common/common/utility_test.cc

@@ -8,6 +8,7 @@
 
 #include "common/common/utility.h"
 
+#include "test/common/stats/stat_test_utility.h"
 #include "test/test_common/simulated_time_system.h"
 #include "test/test_common/test_time.h"
 #include "test/test_common/utility.h"
@@ -116,6 +117,68 @@ TEST(DateUtil, NowToMilliseconds) {
   EXPECT_EQ(12345067, DateUtil::nowToMilliseconds(test_time));
 }
 
+TEST(OutputBufferStream, FailsOnWriteToEmptyBuffer) {
+  constexpr char data = 'x';
+  OutputBufferStream ostream{nullptr, 0};
+  ASSERT_TRUE(ostream.good());
+
+  ostream << data;
+
+  EXPECT_TRUE(ostream.bad());
+}
+
+TEST(OutputBufferStream, CanWriteToBuffer) {
+  constexpr char data[] = "123";
+  std::string buffer;
+  buffer.resize(3);
+
+  OutputBufferStream ostream{buffer.data(), buffer.size()};
+  ostream << data;
+
+  EXPECT_EQ(buffer, data);
+}
+
+TEST(OutputBufferStream, CannotOverwriteBuffer) {
+  constexpr char data[] = "123";
+  std::string buffer;
+  buffer.resize(2);
+
+  OutputBufferStream ostream{buffer.data(), buffer.size()};
+  ostream << data << std::endl;
+
+  EXPECT_EQ(buffer, "12");
+}
+
+TEST(OutputBufferStream, DoesNotAllocateMemoryEvenIfWeTryToOverflowBuffer) {
+  constexpr char data[] = "123";
+  std::string buffer;
+  buffer.resize(2);
+  Stats::TestUtil::MemoryTest memory_test;
+
+  OutputBufferStream ostream{buffer.data(), buffer.size()};
+  ostream << data << std::endl;
+
+  EXPECT_EQ(buffer, "12");
+  EXPECT_EQ(memory_test.consumedBytes(), 0);
+}
+
+TEST(OutputBufferStream, ReturnsNumberOfBytesWrittenIntoBuffer) {
+  constexpr char data[] = "123";
+  std::string buffer;
+  buffer.resize(3);
+
+  OutputBufferStream ostream{buffer.data(), buffer.size()};
+  ASSERT_EQ(ostream.numValidBytesWrittenToBuffer(), 0);
+
+  ostream << data;
+  ASSERT_EQ(buffer, data);
+  EXPECT_EQ(ostream.numValidBytesWrittenToBuffer(), 3);
+
+  // Try to overflow buffer, should still have 3 as bytes written.
+  ostream << data;
+  EXPECT_EQ(ostream.numValidBytesWrittenToBuffer(), 3);
+}
+
 TEST(InputConstMemoryStream, All) {
   {
     InputConstMemoryStream istream{nullptr, 0};