Program Listing for File CapnpBinary.hpp

↰ Return to documentation for file (include/db/Capnp/CapnpBinary/CapnpBinary.hpp)

#pragma once

#include <optional>
#include <vector>

#include <capnp/message.h>
#include <capnp/serialize.h>

#include "MixBinary.capnp.h"
#include "MusicBinary.capnp.h"
#include "NoteBinary.capnp.h"
#include "PDJE_EXPORT_SETTER.hpp"
#include "PDJE_LOG_SETTER.hpp"

template <typename DType> class CapReader {
  private:
    std::vector<kj::byte>                        Origin;
    std::optional<capnp::FlatArrayMessageReader> capreader;

  public:
    CapReader()  = default;
    ~CapReader() = default;
    std::optional<typename DType::Reader> Rp;
    bool
    open(const std::vector<kj::byte> &capnpBinary)
    {
        try {
            Origin.resize(capnpBinary.size());
            memcpy(Origin.data(), capnpBinary.data(), capnpBinary.size());
            kj::ArrayPtr<const kj::byte> arr(Origin.data(), Origin.size());
            capreader.emplace(::kj::arrayPtr(
                reinterpret_cast<const capnp::word *>(arr.begin()),
                arr.size() / sizeof(capnp::word)));
            Rp = capreader->getRoot<DType>();
            return true;
        } catch (std::exception &e) {
            critlog("failed to open capnpBinary. from CapReader open. "
                    "ExceptionLog: ");
            critlog(e.what());
            return false;
        }
    }
    std::vector<kj::byte>
    out()
    {
        return Origin;
    }
};

template <typename DType> class CapWriter {
  private:
    std::optional<capnp::MallocMessageBuilder> capwriter;

  public:
    CapWriter()  = default;
    ~CapWriter() = default;
    std::optional<typename DType::Builder> Wp;

    bool
    open(const std::vector<kj::byte> &capnpBinary)
    {
        try {
            kj::ArrayPtr<const kj::byte> arr(capnpBinary.data(),
                                             capnpBinary.size());
            capwriter.emplace();
            Wp = capwriter->initRoot<DType>();
            capnp::FlatArrayMessageReader readed(::kj::arrayPtr(
                reinterpret_cast<const capnp::word *>(arr.begin()),
                arr.size() / sizeof(capnp::word)));
            auto                          readroot = readed.getRoot<DType>();
            Wp->initDatas(readroot.getDatas().size());
            Wp->setDatas(readroot.getDatas());
            return true;
        } catch (std::exception &e) {
            critlog("failed to open capnpBinary. from CapWriter open. "
                    "ExceptionLog: ");
            critlog(e.what());
            return false;
        }
    }

    bool
    makeNew()
    {
        try {

            capwriter.emplace();
            Wp = capwriter->initRoot<DType>();
            return true;
        } catch (std::exception &e) {
            critlog("failed to make new capnpWriter. from CapWriter makeNew. "
                    "ExceptionLog: ");
            critlog(e.what());
            return false;
        }
    }

    std::vector<kj::byte>
    out()
    {
        try {
            auto farr  = capnp::messageToFlatArray(capwriter.value());
            auto fbyte = farr.asBytes();
            std::vector<kj::byte> buffer(fbyte.begin(), fbyte.end());
            return buffer;
        } catch (std::exception &e) {
            critlog("failed to return capnp binary datas. from CapWriter out. "
                    "ExceptionLog: ");
            critlog(e.what());
            return std::vector<kj::byte>();
        }
    }
};