inline uint_t Buffer::Size() const
{
    return m_size;
}

// .h
class ConstBuffer
    {
    public:

        using pointer_type = const void*;

        ConstBuffer() noexcept = default;
        ConstBuffer(const ConstBuffer& that) = default;
        ConstBuffer(ConstBuffer&& that) noexcept;
        ConstBuffer(const ConstBuffer& that, uint_t maxSize);
        ConstBuffer(pointer_type data, uint_t size) noexcept;

        void swap(ConstBuffer& that) noexcept;
        ConstBuffer& operator=(ConstBuffer that) noexcept;
        ConstBuffer& operator+=(uint_t offset) noexcept;

        pointer_type Data() const noexcept;
        uint_t Size() const noexcept;

    protected:

        pointer_type m_data = nullptr;  // Buffer data reference
        uint_t m_size = 0;              // Buffer data size
    };

    // .cpp

    inline ConstBuffer::ConstBuffer(ConstBuffer&& that) noexcept
    :   m_data(std::move(that.m_data))
    ,   m_size(std::move(that.m_size))
    {
    }

    inline ConstBuffer::ConstBuffer(const ConstBuffer& that, uint_t maxSize)
    :   m_data(that.m_data)
    ,   m_size(std::min(that.m_size, maxSize))
    {
    }

    inline ConstBuffer::ConstBuffer(pointer_type data, uint_t size) noexcept 
    :   m_data(data)
    ,   m_size(size) 
    {
    }

    inline void ConstBuffer::swap(ConstBuffer& that) noexcept
    {
        std::swap(m_data, that.m_data);
        std::swap(m_size, that.m_size);
    }

    inline ConstBuffer& ConstBuffer::operator=(ConstBuffer that) noexcept
    {
        swap(that);

        return *this;
    }

    inline ConstBuffer& ConstBuffer::operator+=(uint_t offset) noexcept
    {
        assert(offset <= m_size); // Buffer offset must be set in buffer bounds

        offset = std::min(offset, m_size);
        const void* data = static_cast<const uint8_t*>(const_cast<const void*>(m_data)) + offset;
        
        ConstBuffer tmp(data, m_size - offset);
        std::swap(tmp, *this);
       
        return *this;
    }

    inline ConstBuffer::pointer_type ConstBuffer::Data() const noexcept
    {
        return static_cast<ConstBuffer::pointer_type>(m_data);
    }

    inline uint_t ConstBuffer::Size() const noexcept
    {
        return m_size; // Вот на ЭТУ строчку ругается!!!: warning C4702: unreachable code
    }

V>inline uint_t Buffer::Size() const
V>{
V>    return m_size;
V>}
V>

if( isDebug() ) {
    check( buffer.Size() >= mySize );
}