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 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