dl_stream_input.h

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <list>
#include <map>
#include <unordered_map>
#include <string>
 
#include "base/dl_concept.h"
#include "memory/dl_buffer.h"
#include "io/dl_log.h"
 
 
namespace dl
{
 
constexpr size_t SIZE_STREAM_INPUT_CONTAINER_CHECK = 1000000;

class StreamInput
{
public:
    StreamInput();
    ~StreamInput();
 
    const std::byte* GetBuffer();
    size_t GetSize() { return _buf.size(); }
 
    template <IsCopyable T>
    void Read(T* data)
    {
        Read(data, sizeof(T));
    }
    //-------------------------------------------特殊操作------------------------------------------
    template <typename T>
    void Read64(T* data)
    {
        uint64_t temp = 0;
        Read(&temp, sizeof(uint64_t));//防止64位递归调用
        *data = (T)temp;
    }

    template <typename T>
    void ReadSize(T* data)
    {
        size_t len = 0;
        Read64(&len);
        data->resize(len);
    }

    void ReadCString(const char* str)
    {
        size_t i = 0;
        std::byte* p = GetCurrent();
        while ((bool)(p[i++]))
        {
 
        }
        Read(p, i);
    }

    template<typename T>
    bool StreamReadEqual(const T& v)
    {
        T v_read;
        Read(&v_read);
        return v_read == v;
    }
 
    //-------------------------------------------容器操作------------------------------------------
    template <typename T>
    void Read(std::list<T>* container)
    {
        size_t size = 0;
        Read64(&size);
        if (size > SIZE_STREAM_INPUT_CONTAINER_CHECK)
        {
            log_warn0("不合理的读取值！");
            return;
        }
        container->resize(size);
        for (auto& iter : *container)
        {
            Read(&iter);
        }
    }
 
    template <typename T>
    void Read(std::vector<T>* container)
    {
        size_t size = 0;
        Read64(&size);
        if (size > SIZE_STREAM_INPUT_CONTAINER_CHECK)
        {
            log_warn0("不合理的读取值！");
            return;
        }
        container->resize((size_t)size);
        for (auto& iter : *container)
        {
            Read(&iter);
        }
    }
 
    void Read(std::string* str)
    {
        size_t size = 0;
        Read64(&size);
        if (size > SIZE_STREAM_INPUT_CONTAINER_CHECK)
        {
            log_warn0("不合理的读取值！");
            return;
        }
        str->resize((size_t)size);
        for (auto& iter : *str)
        {
            Read(&iter);
        }
    }
 
    template <typename K, typename V>
    void Read(std::map<K, V>* container)
    {
        size_t size = 0;
        Read64(&size);
        if (size > SIZE_STREAM_INPUT_CONTAINER_CHECK)
        {
            log_warn0("不合理的读取值！");
            return;
        }
        for (size_t i = 0; i < size; ++i)
        {
            K key;
            V value;
            Read(&key);
            Read(&value);
            (*container)[key] = value;
        }
    }
 
    template <typename K, typename V>
    void Read(std::unordered_map<K, V>* container)
    {
        size_t size = 0;
        Read64(&size);
        if (size > SIZE_STREAM_INPUT_CONTAINER_CHECK)
        {
            log_warn0("不合理的读取值！");
            return;
        }
        for (size_t i = 0; i < size; ++i)
        {
            K key;
            V value;
            Read(&key);
            Read(&value);
            (*container)[key] = value;
        }
    }
    //----------------------------------------------------------------------------------
 
 
    bool Read(void* data, size_t byte_count);
 

    bool LoadFromFile(std::string_view path_name, bool decompress = false, size_t length = 0);
    void LoadFromMemory(BufferView buf, bool decompress = false);
 
    size_t GetPos() { return _head; }
    size_t GetRemain() { return _buf.size() - _head; }
 
    void SetPos(size_t pos);
    std::byte* GetCurrent()
    {
        return _buf.data() + _head;
    }
 
    bool IsEnd();
private:
    Buffer _buf;
    size_t _head;
};
 
}