1 files changed, 129 insertions, 0 deletions
diff --git a/brillo/streams/memory_containers.cc b/brillo/streams/memory_containers.cc
new file mode 100644
index 0000000..6e277b8
--- /dev/null
+++ b/brillo/streams/memory_containers.cc
@@ -0,0 +1,129 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <brillo/streams/memory_containers.h>
+
+#include <base/callback.h>
+#include <brillo/streams/stream_errors.h>
+
+namespace brillo {
+namespace data_container {
+
+namespace {
+
+bool ErrorStreamReadOnly(const tracked_objects::Location& location,
+                         ErrorPtr* error) {
+  Error::AddTo(error,
+               location,
+               errors::stream::kDomain,
+               errors::stream::kOperationNotSupported,
+               "Stream is read-only");
+  return false;
+}
+
+}  // anonymous namespace
+
+void ContiguousBufferBase::CopyMemoryBlock(void* dest,
+                                           const void* src,
+                                           size_t size) const {
+  memcpy(dest, src, size);
+}
+
+bool ContiguousBufferBase::Read(void* buffer,
+                                size_t size_to_read,
+                                size_t offset,
+                                size_t* size_read,
+                                ErrorPtr* error) {
+  size_t buf_size = GetSize();
+  if (offset < buf_size) {
+    size_t remaining = buf_size - offset;
+    if (size_to_read >= remaining) {
+      size_to_read = remaining;
+    }
+    const void* src_buffer = GetReadOnlyBuffer(offset, error);
+    if (!src_buffer)
+      return false;
+
+    CopyMemoryBlock(buffer, src_buffer, size_to_read);
+  } else {
+    size_to_read = 0;
+  }
+  if (size_read)
+    *size_read = size_to_read;
+  return true;
+}
+
+bool ContiguousBufferBase::Write(const void* buffer,
+                                 size_t size_to_write,
+                                 size_t offset,
+                                 size_t* size_written,
+                                 ErrorPtr* error) {
+  if (size_to_write) {
+    size_t new_size = offset + size_to_write;
+    if (GetSize() < new_size && !Resize(new_size, error))
+      return false;
+    void* ptr = GetBuffer(offset, error);
+    if (!ptr)
+      return false;
+    CopyMemoryBlock(ptr, buffer, size_to_write);
+    if (size_written)
+      *size_written = size_to_write;
+  }
+  return true;
+}
+
+bool ContiguousReadOnlyBufferBase::Write(const void* buffer,
+                                         size_t size_to_write,
+                                         size_t offset,
+                                         size_t* size_written,
+                                         ErrorPtr* error) {
+  return ErrorStreamReadOnly(FROM_HERE, error);
+}
+
+bool ContiguousReadOnlyBufferBase::Resize(size_t new_size, ErrorPtr* error) {
+  return ErrorStreamReadOnly(FROM_HERE, error);
+}
+
+void* ContiguousReadOnlyBufferBase::GetBuffer(size_t offset, ErrorPtr* error) {
+  ErrorStreamReadOnly(FROM_HERE, error);
+  return nullptr;
+}
+
+ByteBuffer::ByteBuffer(size_t reserve_size)
+    : VectorPtr(new std::vector<uint8_t>()) {
+  vector_ptr_->reserve(reserve_size);
+}
+
+ByteBuffer::~ByteBuffer() {
+  delete vector_ptr_;
+}
+
+StringPtr::StringPtr(std::string* string) : string_ptr_(string) {}
+
+bool StringPtr::Resize(size_t new_size, ErrorPtr* error) {
+  string_ptr_->resize(new_size);
+  return true;
+}
+
+const void* StringPtr::GetReadOnlyBuffer(size_t offset, ErrorPtr* error) const {
+  return string_ptr_->data() + offset;
+}
+
+void* StringPtr::GetBuffer(size_t offset, ErrorPtr* error) {
+  return &(*string_ptr_)[offset];
+}
+
+ReadOnlyStringRef::ReadOnlyStringRef(const std::string& string)
+    : string_ref_(string) {}
+
+const void* ReadOnlyStringRef::GetReadOnlyBuffer(size_t offset,
+                                                 ErrorPtr* error) const {
+  return string_ref_.data() + offset;
+}
+
+ReadOnlyStringCopy::ReadOnlyStringCopy(std::string string)
+    : ReadOnlyStringRef(string_copy_), string_copy_(std::move(string)) {}
+
+}  // namespace data_container
+}  // namespace brillo