//===-- DataBuffer.h --------------------------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#ifndef LLDB_UTILITY_DATABUFFER_H

#define LLDB_UTILITY_DATABUFFER_H

#include <cstdint>

#include <cstring>

#include "lldb/lldb-types.h"

#include "llvm/ADT/ArrayRef.h"

namespace lldb_private {

/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"

/// A pure virtual protocol class for abstracted read only data buffers.

///

/// DataBuffer is an abstract class that gets packaged into a shared

/// pointer that can use to implement various ways to store data (on the heap,

/// memory mapped, cached inferior memory). It gets used by DataExtractor so

/// many DataExtractor objects can share the same data and sub-ranges of that

/// shared data, and the last object that contains a reference to the shared

/// data will free it.

///

/// Subclasses can implement as many different constructors or member

/// functions that allow data to be stored in the object's buffer prior to

/// handing the shared data to clients that use these buffers.

///

/// All subclasses must override all of the pure virtual functions as they are

/// used by clients to access the data. Having a common interface allows

/// different ways of storing data, yet using it in one common way.

///

/// This class currently expects all data to be available without any extra

/// calls being made, but we can modify it to optionally get data on demand

/// with some extra function calls to load the data before it gets accessed.

class DataBuffer {

public:

  virtual ~DataBuffer() = default;

  /// Get the number of bytes in the data buffer.

  ///

  /// \return

  ///     The number of bytes this object currently contains.

  virtual lldb::offset_t GetByteSize() const = 0;

  /// Get a const pointer to the data.

  ///

  /// \return

  ///     A const pointer to the bytes owned by this object, or NULL

  ///     if the object contains no bytes.

  const uint8_t *GetBytes() const { return GetBytesImpl(); }

  llvm::ArrayRef<uint8_t> GetData() const {

    return llvm::ArrayRef<uint8_t>(GetBytes(), GetByteSize());

  }

  /// LLVM RTTI support.

  /// {

  static char ID;

  virtual bool isA(const void *ClassID) const { return ClassID == &ID; }

  static bool classof(const DataBuffer *data_buffer) {

    return data_buffer->isA(&ID);

  }

  /// }

protected:

  /// Get a const pointer to the data.

  ///

  /// \return

  ///     A const pointer to the bytes owned by this object, or NULL

  ///     if the object contains no bytes.

  virtual const uint8_t *GetBytesImpl() const = 0;

};

/// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"

/// A pure virtual protocol class for abstracted writable data buffers.

///

/// DataBuffer is an abstract class that gets packaged into a shared pointer

/// that can use to implement various ways to store data (on the heap, memory

/// mapped, cached inferior memory). It gets used by DataExtractor so many

/// DataExtractor objects can share the same data and sub-ranges of that

/// shared data, and the last object that contains a reference to the shared

/// data will free it.

class WritableDataBuffer : public DataBuffer {

public:

  /// Destructor

  ///

  /// The destructor is virtual as other classes will inherit from this class

  /// and be downcast to the DataBuffer pure virtual interface. The virtual

  /// destructor ensures that destructing the base class will destruct the

  /// class that inherited from it correctly.

  ~WritableDataBuffer() override = default;

  using DataBuffer::GetBytes;

  using DataBuffer::GetData;

  /// Get a pointer to the data.

  ///

  /// \return

  ///     A pointer to the bytes owned by this object, or NULL if the

  ///     object contains no bytes.

  uint8_t *GetBytes() { return const_cast<uint8_t *>(GetBytesImpl()); }

  llvm::MutableArrayRef<uint8_t> GetData() {

    return llvm::MutableArrayRef<uint8_t>(GetBytes(), GetByteSize());

  }

  /// LLVM RTTI support.

  /// {

  static char ID;

  bool isA(const void *ClassID) const override {

    return ClassID == &ID || 
DataBuffer::isA(ClassID)3
;

  }

  static bool classof(const DataBuffer *data_buffer) {

    return data_buffer->isA(&ID);

  }

  /// }

};

class DataBufferUnowned : public WritableDataBuffer {

public:

  DataBufferUnowned(uint8_t *bytes, lldb::offset_t size)

      : m_bytes(bytes), m_size(size) {}

  const uint8_t *GetBytesImpl() const override { return m_bytes; }

  lldb::offset_t GetByteSize() const override { return m_size; }

  /// LLVM RTTI support.

  /// {

  static char ID;

  bool isA(const void *ClassID) const override {

    return ClassID == &ID || WritableDataBuffer::isA(ClassID);

  }

  static bool classof(const DataBuffer *data_buffer) {

    return data_buffer->isA(&ID);

  }

  /// }

private:

  uint8_t *m_bytes;

  lldb::offset_t m_size;

};

} // namespace lldb_private

#endif // LLDB_UTILITY_DATABUFFER_H