#ifndef ARROW_BUFFER_H

#define ARROW_BUFFER_H

#include <algorithm>

#include <cstdint>

#include <cstring>

#include <memory>

#include <string>

#include <type_traits>

#include "arrow/memory_pool.h"

#include "arrow/status.h"

#include "arrow/util/bit-util.h"

#include "arrow/util/macros.h"

#include "arrow/util/visibility.h"

namespace arrow {

class ARROW_EXPORT Buffer {

public:

/// \brief Construct from buffer and size without copying memory

///

/// \param[in] data a memory buffer

/// \param[in] size buffer size

///

/// \note The passed memory must be kept alive through some other means

Buffer(const uint8_t* data, int64_t size)

: is_mutable_(false),

data_(data),

mutable_data_(NULLPTR),

size_(size),

capacity_(size) {}

/// \brief Construct from std::string without copying memory

///

/// \param[in] data a std::string object

///

/// \note The std::string must stay alive for the lifetime of the Buffer, so

/// temporary rvalue strings must be stored in an lvalue somewhere

explicit Buffer(const std::string& data)

: Buffer(reinterpret_cast<const uint8_t*>(data.c_str()),

static_cast<int64_t>(data.size())) {}

virtual ~Buffer() = default;

/// An offset into data that is owned by another buffer, but we want to be

/// able to retain a valid pointer to it even after other shared_ptr's to the

/// parent buffer have been destroyed

///

/// This method makes no assertions about alignment or padding of the buffer but

/// in general we expected buffers to be aligned and padded to 64 bytes. In the future

/// we might add utility methods to help determine if a buffer satisfies this contract.

Buffer(const std::shared_ptr<Buffer>& parent, const int64_t offset, const int64_t size)

: Buffer(parent->data() + offset, size) {

parent_ = parent;

}

bool is_mutable() const { return is_mutable_; }

/// Return true if both buffers are the same size and contain the same bytes

/// up to the number of compared bytes

bool Equals(const Buffer& other, int64_t nbytes) const;

/// Return true if both buffers are the same size and contain the same bytes

bool Equals(const Buffer& other) const;

/// Copy a section of the buffer into a new Buffer.

Status Copy(const int64_t start, const int64_t nbytes, MemoryPool* pool,

std::shared_ptr<Buffer>* out) const;

/// Copy a section of the buffer using the default memory pool into a new Buffer.

Status Copy(const int64_t start, const int64_t nbytes,

std::shared_ptr<Buffer>* out) const;

/// \brief Construct a new buffer that owns its memory from a std::string

///

/// \param[in] data a std::string object

/// \param[in] pool a memory pool

/// \param[out] out the created buffer

///

/// \return Status message

static Status FromString(const std::string& data, MemoryPool* pool,

std::shared_ptr<Buffer>* out);

/// \brief Construct a new buffer that owns its memory from a std::string

/// using the default memory pool

static Status FromString(const std::string& data, std::shared_ptr<Buffer>* out);

int64_t capacity() const { return capacity_; }

const uint8_t* data() const { return data_; }

uint8_t* mutable_data() {

#ifndef NDEBUG

CheckMutable();

#endif

return mutable_data_;

}

int64_t size() const { return size_; }

std::shared_ptr<Buffer> parent() const { return parent_; }

protected:

bool is_mutable_;

const uint8_t* data_;

uint8_t* mutable_data_;

int64_t size_;

int64_t capacity_;

// null by default, but may be set

std::shared_ptr<Buffer> parent_;

void CheckMutable() const;

private:

ARROW_DISALLOW_COPY_AND_ASSIGN(Buffer);

};

static inline std::shared_ptr<Buffer> SliceBuffer(const std::shared_ptr<Buffer>& buffer,

}

static inline std::shared_ptr<Buffer> SliceBuffer(const std::shared_ptr<Buffer>& buffer,

}

std::shared_ptr<Buffer> SliceMutableBuffer(const std::shared_ptr<Buffer>& buffer,

const int64_t offset, const int64_t length);

class ARROW_EXPORT MutableBuffer : public Buffer {

public:

MutableBuffer(uint8_t* data, const int64_t size) : Buffer(data, size) {

mutable_data_ = data;

is_mutable_ = true;

}

MutableBuffer(const std::shared_ptr<Buffer>& parent, const int64_t offset,

const int64_t size);

protected:

MutableBuffer() : Buffer(NULLPTR, 0) {}

};

class ARROW_EXPORT ResizableBuffer : public MutableBuffer {

public:

/// Change buffer reported size to indicated size, allocating memory if

/// necessary. This will ensure that the capacity of the buffer is a multiple

/// of 64 bytes as defined in Layout.md.

///

/// @param shrink_to_fit On deactivating this option, the capacity of the Buffer won't

/// decrease.

virtual Status Resize(const int64_t new_size, bool shrink_to_fit = true) = 0;

/// Ensure that buffer has enough memory allocated to fit the indicated

/// capacity (and meets the 64 byte padding requirement in Layout.md).

/// It does not change buffer's reported size.

virtual Status Reserve(const int64_t new_capacity) = 0;

template <class T>

Status TypedResize(const int64_t new_nb_elements, bool shrink_to_fit = true) {

return Resize(sizeof(T) * new_nb_elements, shrink_to_fit);

}

template <class T>

Status TypedReserve(const int64_t new_nb_elements) {

return Reserve(sizeof(T) * new_nb_elements);

}

protected:

ResizableBuffer(uint8_t* data, int64_t size) : MutableBuffer(data, size) {}

};

class ARROW_EXPORT PoolBuffer : public ResizableBuffer {

public:

explicit PoolBuffer(MemoryPool* pool = NULLPTR);

~PoolBuffer() override;

Status Resize(const int64_t new_size, bool shrink_to_fit = true) override;

Status Reserve(const int64_t new_capacity) override;

private:

MemoryPool* pool_;

};

class ARROW_EXPORT BufferBuilder {

public:

explicit BufferBuilder(MemoryPool* pool ARROW_MEMORY_POOL_DEFAULT)

: pool_(pool), data_(NULLPTR), capacity_(0), size_(0) {}

/// \brief Resizes the buffer to the nearest multiple of 64 bytes

///

/// \param elements the new capacity of the of the builder. Will be rounded

/// up to a multiple of 64 bytes for padding

/// \param shrink_to_fit if new capacity smaller than existing size,

/// reallocate internal buffer. Set to false to avoid reallocations when

/// shrinking the builder

/// \return Status

Status Resize(const int64_t elements, bool shrink_to_fit = true) {

}

/// \brief Ensure that builder can accommodate the additional number of bytes

/// without the need to perform allocations

///

/// \param size number of additional bytes to make space for

/// \return Status

Status Reserve(const int64_t size) { return Resize(size_ + size, false); }

Status Append(const void* data, int64_t length) {

}

template <size_t NBYTES>

Status Append(const std::array<uint8_t, NBYTES>& data) {

}

// Advance pointer and zero out memory

Status Advance(const int64_t length) {

}

// Unsafe methods don't check existing size

void UnsafeAppend(const void* data, int64_t length) {

memcpy(data_ + size_, data, static_cast<size_t>(length));

size_ += length;

}

Status Finish(std::shared_ptr<Buffer>* out) {

}

void Reset() {

buffer_ = NULLPTR;

capacity_ = size_ = 0;

}

int64_t capacity() const { return capacity_; }

int64_t length() const { return size_; }

const uint8_t* data() const { return data_; }

protected:

std::shared_ptr<PoolBuffer> buffer_;

MemoryPool* pool_;

uint8_t* data_;

int64_t capacity_;

int64_t size_;

};

template <typename T>

class ARROW_EXPORT TypedBufferBuilder : public BufferBuilder {

public:

explicit TypedBufferBuilder(MemoryPool* pool) : BufferBuilder(pool) {}

Status Append(T arithmetic_value) {

static_assert(std::is_arithmetic<T>::value,

"Convenience buffer append only supports arithmetic types");

return BufferBuilder::Append(reinterpret_cast<uint8_t*>(&arithmetic_value),

sizeof(T));

}

Status Append(const T* arithmetic_values, int64_t num_elements) {

}

void UnsafeAppend(T arithmetic_value) {

}

void UnsafeAppend(const T* arithmetic_values, int64_t num_elements) {

}

const T* data() const { return reinterpret_cast<const T*>(data_); }

int64_t length() const { return size_ / sizeof(T); }

int64_t capacity() const { return capacity_ / sizeof(T); }

};

Status AllocateBuffer(MemoryPool* pool, const int64_t size, std::shared_ptr<Buffer>* out);

Status AllocateResizableBuffer(MemoryPool* pool, const int64_t size,

std::shared_ptr<ResizableBuffer>* out);

} // namespace arrow

#endif // ARROW_BUFFER_H