diff options
Diffstat (limited to '')
-rw-r--r-- | src/shared_buffer.hh | 210 |
1 files changed, 210 insertions, 0 deletions
diff --git a/src/shared_buffer.hh b/src/shared_buffer.hh new file mode 100644 index 0000000..61aa5e0 --- /dev/null +++ b/src/shared_buffer.hh @@ -0,0 +1,210 @@ +/** + * Copyright (c) 2014, Timothy Stack + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of Timothy Stack nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * @file shared_buffer.hh + */ + +#ifndef shared_buffer_hh +#define shared_buffer_hh + +#include <string> +#include <vector> + +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> + +#include "base/attr_line.hh" +#include "base/auto_mem.hh" +#include "base/file_range.hh" +#include "base/intern_string.hh" +#include "base/lnav_log.hh" +#include "scn/util/string_view.h" + +class shared_buffer; + +struct shared_buffer_ref { +public: + shared_buffer_ref(char* data = nullptr, size_t len = 0) + : sb_owner(nullptr), sb_data(data), sb_length(len) + { + } + + ~shared_buffer_ref() { this->disown(); } + + shared_buffer_ref(const shared_buffer_ref& other) + { + this->sb_owner = nullptr; + this->sb_data = nullptr; + this->sb_length = 0; + this->sb_metadata = file_range::metadata{}; + + this->copy_ref(other); + } + + shared_buffer_ref(shared_buffer_ref&& other) noexcept; + + shared_buffer_ref& operator=(const shared_buffer_ref& other) + { + if (this != &other) { + this->disown(); + this->copy_ref(other); + } + + return *this; + } + + bool empty() const + { + return this->sb_data == nullptr || this->sb_length == 0; + } + + const char* get_data() const { return this->sb_data; } + + const char* get_data_at(off_t offset) const + { + return &this->sb_data[offset]; + } + + size_t length() const { return this->sb_length; } + + shared_buffer_ref& rtrim(bool pred(char)) + { + while (this->sb_length > 0 && pred(this->sb_data[this->sb_length - 1])) + { + this->sb_length -= 1; + } + + return *this; + } + + bool contains(const char* ptr) const + { + const char* buffer_end = this->sb_data + this->sb_length; + + return (this->sb_data <= ptr && ptr < buffer_end); + } + + file_range::metadata& get_metadata() { return this->sb_metadata; } + + char* get_writable_data() + { + if (this->take_ownership()) { + return const_cast<char*>(this->sb_data); + } + + return nullptr; + } + + string_fragment to_string_fragment(off_t offset, size_t len) const + { + return string_fragment{ + this->sb_data, (int) offset, (int) (offset + len)}; + } + + string_fragment to_string_fragment() const + { + return string_fragment::from_bytes(this->sb_data, this->length()); + } + + scn::string_view to_string_view(const line_range& lr) const + { + return scn::string_view{ + this->get_data_at(lr.lr_start), + this->get_data_at(lr.lr_end), + }; + } + + using narrow_result = std::pair<const char*, size_t>; + narrow_result narrow(size_t new_data, size_t new_length); + + void widen(narrow_result old_data_length); + + void share(shared_buffer& sb, const char* data, size_t len); + + bool subset(shared_buffer_ref& other, off_t offset, size_t len); + + void erase_ansi(); + + bool take_ownership(); + + void disown(); + +private: + void copy_ref(const shared_buffer_ref& other); + + auto_mem<char*> sb_backtrace; + file_range::metadata sb_metadata; + shared_buffer* sb_owner; + const char* sb_data; + size_t sb_length; +}; + +class shared_buffer { +public: + ~shared_buffer() { this->invalidate_refs(); } + + void add_ref(shared_buffer_ref& ref) { this->sb_refs.push_back(&ref); } + + bool invalidate_refs() + { + bool retval = true; + + while (!this->sb_refs.empty()) { + auto iter = this->sb_refs.begin(); + + retval = retval && (*iter)->take_ownership(); + } + + return retval; + } + + std::vector<shared_buffer_ref*> sb_refs; +}; + +struct tmp_shared_buffer { + explicit tmp_shared_buffer(const char* str, size_t len = -1) + { + if (len == (size_t) -1) { + len = strlen(str); + } + + this->tsb_ref.share(this->tsb_manager, (char*) str, len); + }; + + shared_buffer tsb_manager; + shared_buffer_ref tsb_ref; +}; + +inline std::string +to_string(const shared_buffer_ref& sbr) +{ + return {sbr.get_data(), sbr.length()}; +} + +#endif |