#include <qpdf/Pl_Buffer.hh>

#include <qpdf/Util.hh>

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <stdexcept>

using namespace qpdf;

class Pl_Buffer::Members

{

  public:

    Members() = default;

    Members(Members const&) = delete;

    bool ready{true};

    std::string data;

};

Pl_Buffer::Pl_Buffer(char const* identifier, Pipeline* next) :

    Pipeline(identifier, next),

    m(std::make_unique<Members>())

{

}

// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer

Pl_Buffer::~Pl_Buffer() = default;

void

Pl_Buffer::write(unsigned char const* buf, size_t len)

{

    if (!len) {

        return;

    }

    m->data.append(reinterpret_cast<char const*>(buf), len);

    m->ready = false;

    if (next()) {

        next()->write(buf, len);

    }

}

void

Pl_Buffer::finish()

{

    m->ready = true;

    if (next()) {

        next()->finish();

    }

}

Buffer*

Pl_Buffer::getBuffer()

{

    util::assertion(m->ready, "Pl_Buffer::getBuffer() called when not ready");

    auto* b = new Buffer(std::move(m->data));

    m->data.clear();

    return b;

}

std::string

Pl_Buffer::getString()

{

    util::assertion(m->ready, "Pl_Buffer::getString() called when not ready");

    auto s = std::move(m->data);

    m->data.clear();

    return s;

}

std::shared_ptr<Buffer>

Pl_Buffer::getBufferSharedPointer()

{

    return std::shared_ptr<Buffer>(getBuffer());

}

void

Pl_Buffer::getMallocBuffer(unsigned char** buf, size_t* len)

{

    util::assertion(m->ready, "Pl_Buffer::getMallocBuffer() called when not ready");

    auto size = m->data.size();

    *len = size;

    if (size > 0) {

        *buf = reinterpret_cast<unsigned char*>(malloc(size));

        memcpy(*buf, m->data.data(), size);

    } else {

        *buf = nullptr;

    }

    m->data.clear();

}