buffer.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_BUFFER_HEADER
#define LIBFILEZILLA_BUFFER_HEADER
 
#include "libfilezilla.hpp"
 
#include <vector>
#include <type_traits>

 
namespace fz {

class FZ_PUBLIC_SYMBOL buffer final
{
public:
    typedef unsigned char value_type;
 
    buffer() noexcept = default;

    explicit buffer(size_t capacity);
 
    buffer(buffer const& buf);
    buffer(buffer && buf) noexcept;
 
    ~buffer() { delete[] data_; }
 
    buffer& operator=(buffer const& buf);
    buffer& operator=(buffer && buf) noexcept;

    unsigned char const* get() const { return pos_; }
    unsigned char* get() { return pos_; }

    unsigned char* data() { return pos_; }
    unsigned char const* data() const { return pos_; }

    unsigned char* get(size_t write_size);

    void add(size_t added);

    template<typename T, std::enable_if_t<std::is_signed_v<T>, int> = 0>
    void add(T added) {
        if (added > 0) {
            add(static_cast<size_t>(added));
        }
    }

    void consume(size_t consumed);
 
    size_t size() const { return size_; }

    void clear();
 
    void clear_and_free();

    void append(unsigned char const* data, size_t len);
    void append(std::string_view const& str);
    void append(std::basic_string_view<uint8_t> const& data);
    void append(std::vector<uint8_t> const& data);
    void append(fz::buffer const& b);
    void append(unsigned char v);
    void append(size_t len, unsigned char c);
 
    buffer& operator+=(unsigned char v) {
        append(v);
        return *this;
    }
    buffer& operator+=(std::string_view const& str) {
        append(str);
        return *this;
    }
    buffer& operator+=(std::vector<uint8_t> const& data) {
        append(data);
        return *this;
    }
    buffer& operator+=(fz::buffer const& b) {
        append(b);
        return *this;
    }
 
    bool empty() const { return size_ == 0; }
    explicit operator bool() const {
        return size_ != 0;
    }
 
    size_t capacity() const { return capacity_; }
    void reserve(size_t capacity);
 
    void resize(size_t size);

    unsigned char operator[](size_t i) const { return pos_[i]; }
    unsigned char & operator[](size_t i) { return pos_[i]; }
 
    bool operator==(buffer const& rhs) const;
 
    bool operator!=(buffer const& rhs) const {
        return !(*this == rhs);
    }
 
    std::string_view to_view() const;
 
    void wipe();
    void wipe_unused();
 
private:
 
    // Invariants:
    //   size_ <= capacity_
    //   data_ <= pos_
    //   pos_ <= data_ + capacity_
    //   pos_ + size_ <= data_ + capacity_
    unsigned char* data_{};
    unsigned char* pos_{};
    size_t size_{};
    size_t capacity_{};
};
 
inline void wipe(buffer & b) {
    b.wipe();
}
 
inline void wipe_unused(buffer & b) {
    b.wipe_unused();
}
 
}
 
#endif