RestartTrim.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <vector>
 
namespace adsidac {
 
struct RestartLayout {
    std::size_t header_end = 0;   
    std::size_t base = 0;         
    std::size_t base_end = 0;     
    std::size_t target = 0;       
    std::size_t target_end = 0;   
    bool have_header = false;     
    bool have_base = false;       
    bool have_target = false;     
};
 
inline RestartLayout scan_restart(const std::vector<char>& buf, std::int32_t want)
{
    auto rd32 = [](const char* p) { std::int32_t v; std::memcpy(&v, p, 4); return v; };
    RestartLayout L;
    std::size_t p = 0, prev = 0;
 
    while (p + 8 <= buf.size()) {
        const std::int32_t reclen = rd32(&buf[p]);
        if (reclen < 0 || p + 8 + static_cast<std::size_t>(reclen) > buf.size()) break;
 
        if (reclen == 24 && std::memcmp(&buf[p + 4], "restart ", 8) == 0) {
            // The dump starts at the 8-byte header record just before this one.
            const std::size_t start = prev;
            const bool complete = (rd32(&buf[p + 4 + 8]) & 16) != 0;
            if (!L.have_header) { L.header_end = start; L.have_header = true; }
            if (L.have_base   && L.base_end   == 0) L.base_end   = start;
            if (L.have_target && L.target_end == 0) L.target_end = start;
            if (complete && !L.have_base) { L.base = start; L.have_base = true; L.base_end = 0; }
            if (want >= 0 && rd32(&buf[p + 4 + 16]) == want && !L.have_target) {
                L.target = start; L.have_target = true; L.target_end = 0;
            }
        }
        prev = p;
        p += 8 + static_cast<std::size_t>(reclen);
    }
    if (L.have_base   && L.base_end   == 0) L.base_end   = buf.size();
    if (L.have_target && L.target_end == 0) L.target_end = buf.size();
    return L;
}
 
inline bool has_complete_restart(const std::vector<char>& buf)
{
    return scan_restart(buf, -1).have_base;
}
 
inline std::vector<char> extract_header_and_base(const std::vector<char>& buf)
{
    const RestartLayout L = scan_restart(buf, -1);
    if (!L.have_header || !L.have_base) return {};
    std::vector<char> out;
    out.reserve(L.header_end + (L.base_end - L.base));
    out.insert(out.end(), buf.begin(), buf.begin() + L.header_end);
    out.insert(out.end(), buf.begin() + L.base, buf.begin() + L.base_end);
    return out;
}
 
inline std::vector<char> extract_record_no_base(const std::vector<char>& buf, std::int32_t want)
{
    const RestartLayout L = scan_restart(buf, want);
    if (!L.have_header || !L.have_target) return {};
    if (L.target_end <= L.target || L.target_end > buf.size()) return {};
    std::vector<char> out;
    out.reserve(L.header_end + (L.target_end - L.target));
    out.insert(out.end(), buf.begin(), buf.begin() + L.header_end);
    out.insert(out.end(), buf.begin() + L.target, buf.begin() + L.target_end);
    return out;
}
 
inline std::vector<char> splice_base(const std::vector<char>& hdr_base,
                                     const std::vector<char>& body)
{
    const RestartLayout B = scan_restart(body, -1);
    if (!B.have_header) return {};
    std::vector<char> out;
    out.reserve(hdr_base.size() + (body.size() - B.header_end));
    out.insert(out.end(), hdr_base.begin(), hdr_base.end());
    out.insert(out.end(), body.begin() + B.header_end, body.end());
    return out;
}
 
inline std::vector<char> extract_restart_record(const std::vector<char>& buf, std::int32_t want)
{
    const RestartLayout L = scan_restart(buf, want);
    if (!L.have_header || !L.have_target || !L.have_base) return {};
    if (L.target_end <= L.target || L.target_end > buf.size()) return {};
    if (L.base_end   <= L.base   || L.base_end   > buf.size()) return {};
 
    const bool target_is_base = (L.target == L.base);
    std::vector<char> out;
    out.reserve(L.header_end + (L.base_end - L.base)
                + (target_is_base ? 0 : L.target_end - L.target));
    out.insert(out.end(), buf.begin(), buf.begin() + L.header_end);
    out.insert(out.end(), buf.begin() + L.base, buf.begin() + L.base_end);
    if (!target_is_base)
        out.insert(out.end(), buf.begin() + L.target, buf.begin() + L.target_end);
    return out;
}
 
} // namespace adsidac