dl_table.h

浏览该文件的文档.

#pragma once
 
#include <cstddef>
#include <span>
#include <vector>
#include <cassert>
 
#include "dl_type.h"
#include "base/dl_range_accumulate.h"
 
namespace dl
{
template<typename T>
class Table2
{
public:
    Table2() :
        _w{ 0 }
    {}

    Table2(const Size& size)
    {
        _init(size);
    }

    Table2(const Size& size, const T* p)
    {
        _init(size);
 
        for (size_t i = 0; i < _data.size(); ++i)
        {
            _data[i] = *(p + i);
        }
    }

    void Resize(const Size& size)
    {
        assert(_w == 0);
        _init(size);
    }

    std::span<T> operator[](std::size_t j)
    {
        assert(j < _ptrLine.size());
        return { _ptrLine[j], _wLine };
    }

    const std::span<T> operator[](std::size_t j) const
    {
        assert(j < _ptrLine.size());
        return { _ptrLine[j], _wLine };
    }

    /*T& operator[](std::size_t j, std::size_t i)
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        return _ptrLine[j][i];
    }*/
 
    const T& Get(std::size_t j, std::size_t i) const
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        return _ptrLine[j][i];
    }

    void Fill(const T& v)
    {
        for (auto& iter : _data)
            iter = v;
    }

    void PushBack(std::vector<T>& vec)
    {
        assert(vec.size() == _w);
        _data.insert(_data.end(), vec.begin(), vec.end());
        _rebuild_ptr_line(_ptrLine.size() + 1);
    }
 
 
    bool IsEmpty() const { return _data.empty(); }
 
    const std::byte* GetBuffer() const
    {
        return (const std::byte*)_data.data();
    }
 
    T* GetData()
    {
        return _data.data();
    }
    
    const T* GetData() const
    {
        return _data.data();
    }
 
    unsigned GetWidth() const
    {
        return _w;
    }
 
    unsigned GetHeight() const
    {
        return (unsigned)_ptrLine.size();
    }
 
    Size GetSize() const
    {
        return { GetWidth(), GetHeight() };
    }
    
    // 由于标准库 size与 length等价，不使用length命令
    unsigned GetSizeMul() const
    {
        return GetWidth() * GetHeight();
    }
 
    size_t GetSizeByte()
    {
        return _data.size() * sizeof(T);
    }
 
    auto begin()
    {
        return _data.begin();
    }
    auto end()
    {
        return _data.end();
    }
private:
    std::vector<T> _data;
    std::vector<T*> _ptrLine; // 行指针
    std::vector<std::size_t> _wLine;// 行宽
 
    void _init(const Size& size)
    {
        _w = size[0];
        _data.resize(Accumulate::Mul(size));
        _rebuild_ptr_line(size[1]);
    }
    // 重建行指针
    void _rebuild_ptr_line(std::size_t h)
    {
        _ptrLine.resize(h);
        for (size_t i = 0; i < _ptrLine.size(); ++i)
            _ptrLine[i] = _data.data() + i;
    }
};
 
 
}