tec_memfile.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-12 01:52:18 by magnolia>
/*----------------------------------------------------------------------
------------------------------------------------------------------------
Copyright (c) 2020-2026 The Emacs Cat (https://github.com/olddeuteronomy/tec).
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
------------------------------------------------------------------------
----------------------------------------------------------------------*/
#pragma once
 
#include <cstddef>
#include <cstdio>
#include <string>
#include <sstream>
 
#include <memory.h>
 
#include "tec/tec_def.hpp" // IWYU pragma: keep
#include "tec/tec_trace.hpp"
 
 
namespace tec {
 
 
class MemFile {
public:
    struct _Char2 {
        char c0;
        char c1;
    };
 
    inline static constexpr _Char2 to_hex_chars(unsigned char ch) noexcept {
        constexpr char table[] = "0123456789ABCDEF";
        if (0x20 < ch && ch < 0x7F) {
            return {' ', static_cast<char>(ch)};
        } else {
            return {table[ch >> 4], table[ch & 0x0F]};
        }
    }
 
public:
 
    static constexpr size_t kDefaultBlockSize{BUFSIZ};
 
private:
 
    std::string buffer_;
 
    size_t blk_size_;
 
    long pos_;
 
private:
 
    size_t calc_required_capacity(long pos, size_t len) const {
       return buffer_.capacity()
                + blk_size_
                + ((pos + len) / blk_size_) * blk_size_;
    }
 
public:
    MemFile()
        : buffer_(kDefaultBlockSize, 0)
        , blk_size_{kDefaultBlockSize}
        , pos_{0}
    {
        buffer_.resize(0);
    }
 
    explicit MemFile(size_t block_size)
        : buffer_(block_size, 0)
        , blk_size_{block_size}
        , pos_{0}
    {
        buffer_.resize(0);
    }
 
    explicit MemFile(const std::string& s)
        : buffer_(kDefaultBlockSize, 0)
        , blk_size_{kDefaultBlockSize}
        , pos_{0}
    {
        buffer_.resize(0);
        write(s.data(), s.size());
    }
 
    MemFile(const void* src, size_t len)
        : buffer_(kDefaultBlockSize, 0)
        , blk_size_{kDefaultBlockSize}
        , pos_{0}
    {
        buffer_.resize(0);
        write(src, len);
    }
 
    virtual ~MemFile() = default;
 
 
    void copy_from(const MemFile& src) {
        rewind();
        write(src.data(), src.size());
    }
 
    void move_from(MemFile&& src, size_t size_to_shrink=0) {
        blk_size_ = src.blk_size_;
        pos_ = src.pos_;
        buffer_ = std::move(src.buffer_);
        if (size_to_shrink > 0 && size_to_shrink < size()) {
            buffer_.resize(size_to_shrink);
        }
    }
 
    const std::string& str() const noexcept {
        return buffer_;
    }
 
    const void* data() const {
        // To prevent silly GCC warning?
        return &buffer_.at(0);
    }
 
    void* data() {
        // To prevent silly GCC warning?
        return &buffer_.at(0);
    }
 
    const char* ptr(long pos) const {
        return buffer_.data() + pos;
    }
 
    char* ptr(long pos) {
        return buffer_.data() + pos;
    }
 
    constexpr size_t block_size() const noexcept {
        return blk_size_;
    }
 
    size_t size() const noexcept {
        return buffer_.size();
    }
 
    size_t capacity() const noexcept {
        return buffer_.capacity();
    }
 
    constexpr long tell() const noexcept {
        return pos_;
    }
 
    constexpr void rewind() noexcept {
        pos_ = 0;
    }
 
    long seek(long offset, int whence) {
        long origin = (whence == SEEK_CUR ? pos_ : (whence == SEEK_END ? size() : 0));
        size_t new_pos = origin + offset;
        if( new_pos < 0) {
            return -1;
        }
        if( new_pos > size() ) {
            return -2;
        }
        pos_ = new_pos;
        return pos_;
    }
 
    void resize(size_t len) {
        size_t new_size = pos_ + len;
        if (new_size > size()) {
            if (new_size > buffer_.capacity()) {
                TEC_ENTER("MemFile:resize");
                size_t new_cap = calc_required_capacity(pos_, new_size);
                TEC_TRACE("Cap: {}->{}, Size: {}->{}",
                          buffer_.capacity(), new_cap,
                          size(), new_size);
                buffer_.reserve(new_cap);
            }
            buffer_.resize(new_size);
        }
    }
 
    size_t write(const void* src, size_t len) {
        if( len == 0 ) {
            return 0;
        }
        if (pos_ + len > size()) {
            resize(len);
        }
        ::memcpy(buffer_.data() + pos_, src, len);
        pos_ += len;
        return len;
     }
 
    size_t read(void* dst, size_t len) {
        if( len == 0 ) {
            return 0;
        }
        if( pos_ + len > size() ) {
            // Reading out of bound.
            return 0;
        }
        if (buffer_.empty()) {
            return 0;
        }
        ::memcpy(dst, buffer_.data() + pos_, len);
        pos_ += len;
        return len;
    }
 
 
    std::string as_hex() const {
        std::ostringstream os;
        if (size() > 0) {
            for (unsigned char c: buffer_) {
                auto ch = to_hex_chars(c);
                os << ch.c0 << ch.c1;
 
            }
        }
        return os.str();
    }
 
};
 
 
using Blob = MemFile;
 
using Bytes = MemFile;
 
 
} // namespace tec