dl_stream_output.h

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <list>
#include <map>
#include <unordered_map>
#include <string>
 
#include "base/dl_concept.h"
#include "math/dl_algorithm.h"
#include "memory/dl_buffer.h"
#include "memory/dl_memory.h"
 
namespace dl
{
class StreamOutput
{
public:
    StreamOutput();
    ~StreamOutput();

    const std::byte* GetData();
 
 
    BufferView GetBuffer()
    {
        return _buf;
    }
    Buffer ToBuffer()
    {
        return _buf;
    }

    template <IsCopyable T>
    void Write(const T* data)
    {
        Write(data, sizeof(T));
    }
 
    void Write(const Buffer* data)
    {
        Write(data->data(), data->size());
    }
 
    //---------------------------------------------特殊内容写入---------------------------
    template <typename T>
    void Write64(const T* data)
    {
        uint64_t temp = uint64_t(*data);
        Write(&temp, sizeof(uint64_t));//防止64位递归调用
    }

    template <typename T>
    void WriteSize(const T* data)
    {
        size_t len = std::size(*data);
        Write64(&len);
    }

    void WriteCString(const char* str)
    {
        Write(str, strlen(str) + 1);
    }
 
    template <typename T>
    void Write(const std::list<T>* container)
    {
        Write64(pointer(container->size()));
        for (auto& iter : *container)
        {
            Write(&iter);
        }
    }
 
    template <typename T>
    void Write(const std::vector<T>* container)
    {
        Write64(pointer(container->size()));
        for (auto& iter : *container)
        {
            Write(&iter);
        }
    }
 
    void Write(const std::string* str)
    {
        Write64(pointer(str->size()));
        for (auto& iter : *str)
        {
            Write(&iter);
        }
    }
 
    template <typename K, typename V>
    void Write(const std::map<K, V>* container)
    {
        Write64(pointer(container->size()));
        for (auto& iter : *container)
        {
            Write(&iter.first);
            Write(&iter.second);
        }
    }
 
    template <typename K, typename V>
    void Write(const std::unordered_map<K, V>* container)
    {
        Write64(pointer(container->size()));
        for (auto& iter : *container)
        {
            Write(&iter.first);
            Write(&iter.second);
        }
    }
    //----------------------------------------------------------------------------
    void Write(const void* data, size_t byte_count);
 

    void Fill(int val, size_t byte_count);

    bool Save(std::string_view path_name, bool compress = false);

    void Clear();

    size_t GetPos() { return _head; }

    void SetPos(size_t pos);

    void Compress(Memory::CompressMode mode);

    void SetDelete(bool d)
    {
        _delete = d;
    }
private:
    void _realloc(size_t size);
 
    Buffer _buf;
    size_t _head;
    bool _delete;//默认会删除堆内存
};
}