quiche/common/quiche_default_mem_slice_impl.h

#ifndef QUICHE_COMMON_QUICHE_DEFAULT_MEM_SLICE_IMPL_H_
#define QUICHE_COMMON_QUICHE_DEFAULT_MEM_SLICE_IMPL_H_

#include <cstddef>
#include <cstdlib>
#include <memory>
#include <utility>

#include "quiche/common/platform/api/quiche_export.h"
#include "quiche/common/quiche_buffer_allocator.h"
#include "quiche/common/quiche_callbacks.h"

namespace quiche {

// The default (and soon, hopefully the only) implementation of QuicheMemSlice.
class QUICHE_EXPORT QuicheDefaultMemSliceImpl {
 public:
  QuicheDefaultMemSliceImpl() = default;

  explicit QuicheDefaultMemSliceImpl(QuicheBuffer buffer)
      : data_(buffer.data()), size_(buffer.size()) {
    QuicheUniqueBufferPtr owned = buffer.Release();
    QuicheBufferAllocator* allocator = owned.get_deleter().allocator();
    owned.release();
    done_callback_ = [allocator](const char* ptr) {
      allocator->Delete(const_cast<char*>(ptr));
    };
  }

  QuicheDefaultMemSliceImpl(std::unique_ptr<char[]> buffer, size_t length)
      : data_(buffer.release()),
        size_(length),
        done_callback_(+[](const char* ptr) { delete[] ptr; }) {}

  QuicheDefaultMemSliceImpl(const char* buffer, size_t length,
                            SingleUseCallback<void(const char*)> done_callback)
      : data_(buffer),
        size_(length),
        done_callback_(std::move(done_callback)) {}

  QuicheDefaultMemSliceImpl(const QuicheDefaultMemSliceImpl& other) = delete;
  QuicheDefaultMemSliceImpl& operator=(const QuicheDefaultMemSliceImpl& other) =
      delete;

  // Move constructors. |other| will not hold a reference to the data buffer
  // after this call completes.
  QuicheDefaultMemSliceImpl(QuicheDefaultMemSliceImpl&& other) {
    data_ = other.data_;
    size_ = other.size_;
    done_callback_ = std::move(other.done_callback_);
    other.data_ = nullptr;
    other.size_ = 0;
    other.done_callback_ = nullptr;
  }
  QuicheDefaultMemSliceImpl& operator=(QuicheDefaultMemSliceImpl&& other) {
    Reset();
    data_ = other.data_;
    size_ = other.size_;
    done_callback_ = std::move(other.done_callback_);
    other.data_ = nullptr;
    other.size_ = 0;
    other.done_callback_ = nullptr;
    return *this;
  }

  ~QuicheDefaultMemSliceImpl() { Reset(); }

  void Reset() {
    if (done_callback_ && data_ != nullptr) {
      std::move(done_callback_)(data_);
    }
    data_ = nullptr;
    size_ = 0;
    done_callback_ = nullptr;
  }

  const char* data() const { return data_; }
  size_t length() const { return size_; }
  bool empty() const { return size_ == 0; }

 private:
  const char* data_ = nullptr;
  size_t size_ = 0;
  SingleUseCallback<void(const char*)> done_callback_ = nullptr;
};

}  // namespace quiche

#endif  // QUICHE_COMMON_QUICHE_DEFAULT_MEM_SLICE_IMPL_H_