temporary_buffer.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  You may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/*
 * Copyright (C) 2014 Cloudius Systems, Ltd.
 */
 
#pragma once
 
#ifndef SEASTAR_MODULE
#include <algorithm>
#include <cstddef>
#include <string_view>
#include <malloc.h>
#endif
#include <seastar/core/deleter.hh>
#include <seastar/util/eclipse.hh>
#include <seastar/util/std-compat.hh>
#include <seastar/util/modules.hh>
 
namespace seastar {
 
 
SEASTAR_MODULE_EXPORT
template <typename CharType>
class temporary_buffer {
    static_assert(sizeof(CharType) == 1, "must buffer stream of bytes");
    CharType* _buffer;
    size_t _size;
    deleter _deleter;
public:
    explicit temporary_buffer(size_t size)
        : _buffer(static_cast<CharType*>(malloc(size * sizeof(CharType)))), _size(size)
        , _deleter(make_free_deleter(_buffer)) {
        if (size && !_buffer) {
            throw std::bad_alloc();
        }
    }
    //explicit temporary_buffer(CharType* borrow, size_t size) : _buffer(borrow), _size(size) {}
    temporary_buffer() noexcept
        : _buffer(nullptr)
        , _size(0) {}
    temporary_buffer(const temporary_buffer&) = delete;
 
    temporary_buffer(temporary_buffer&& x) noexcept : _buffer(x._buffer), _size(x._size), _deleter(std::move(x._deleter)) {
        x._buffer = nullptr;
        x._size = 0;
    }
 
    temporary_buffer(CharType* buf, size_t size, deleter d) noexcept
        : _buffer(buf), _size(size), _deleter(std::move(d)) {}
    temporary_buffer(const CharType* src, size_t size) : temporary_buffer(size) {
        std::copy_n(src, size, _buffer);
    }
    void operator=(const temporary_buffer&) = delete;
    temporary_buffer& operator=(temporary_buffer&& x) noexcept {
        if (this != &x) {
            _buffer = x._buffer;
            _size = x._size;
            _deleter = std::move(x._deleter);
            x._buffer = nullptr;
            x._size = 0;
        }
        return *this;
    }
    const CharType* get() const noexcept { return _buffer; }
    CharType* get_write() noexcept { return _buffer; }
    size_t size() const noexcept { return _size; }
    const CharType* begin() const noexcept { return _buffer; }
    const CharType* end() const noexcept { return _buffer + _size; }
    temporary_buffer prefix(size_t size) && noexcept {
        auto ret = std::move(*this);
        ret._size = size;
        return ret;
    }
    CharType operator[](size_t pos) const noexcept {
        return _buffer[pos];
    }
    bool empty() const noexcept { return !size(); }
    explicit operator bool() const noexcept { return size(); }
    temporary_buffer share() {
        return temporary_buffer(_buffer, _size, _deleter.share());
    }
    temporary_buffer share(size_t pos, size_t len) {
        auto ret = share();
        ret._buffer += pos;
        ret._size = len;
        return ret;
    }
    temporary_buffer clone() const {
        return {_buffer, _size};
    }
    void trim_front(size_t pos) noexcept {
        _buffer += pos;
        _size -= pos;
    }
    void trim(size_t pos) noexcept {
        _size = pos;
    }
    deleter release() noexcept {
        return std::move(_deleter);
    }
    static temporary_buffer aligned(size_t alignment, size_t size) {
        void *ptr = nullptr;
        auto ret = ::posix_memalign(&ptr, alignment, size * sizeof(CharType));
        auto buf = static_cast<CharType*>(ptr);
        if (ret) {
            throw std::bad_alloc();
        }
        return temporary_buffer(buf, size, make_free_deleter(buf));
    }
 
    static temporary_buffer copy_of(std::string_view view) {
        void* ptr = ::malloc(view.size());
        if (!ptr) {
            throw std::bad_alloc();
        }
        auto buf = static_cast<CharType*>(ptr);
        memcpy(buf, view.data(), view.size());
        return temporary_buffer(buf, view.size(), make_free_deleter(buf));
    }
 
    bool operator==(const temporary_buffer& o) const noexcept {
        return size() == o.size() && std::equal(begin(), end(), o.begin());
    }
 
    bool operator!=(const temporary_buffer& o) const noexcept {
        return !(*this == o);
    }
};
 
 
}