From 247ac893b02f41817ea4f7c0c8d07a7aa738914f Mon Sep 17 00:00:00 2001 From: Josiah VanderZee Date: Tue, 16 Jun 2026 06:21:09 -0500 Subject: [PATCH] Remove TsBuffer.h Fixes #1570. This removes the unused `ConstBuffer` class. The header was not included anywhere. The only mention of `ConstBuffer` in the docs is in the history of `TextView`. Therefore, that mention has been preserved. --- include/tscore/TsBuffer.h | 508 -------------------------------------- 1 file changed, 508 deletions(-) delete mode 100644 include/tscore/TsBuffer.h diff --git a/include/tscore/TsBuffer.h b/include/tscore/TsBuffer.h deleted file mode 100644 index 857437eb511..00000000000 --- a/include/tscore/TsBuffer.h +++ /dev/null @@ -1,508 +0,0 @@ -/** @file - Definitions for a buffer type, to carry a reference to a chunk of memory. - - @section license License - - Licensed to the Apache Software Foundation (ASF) under one - or more contributor license agreements. See the NOTICE file - distributed with this work for additional information - regarding copyright ownership. The ASF licenses this file - to you under the Apache License, Version 2.0 (the - "License"); 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. - */ - -#pragma once - -#if defined _MSC_VER -#include -#else -#include -#endif - -// For memcmp() -#include -#include - -/// Apache Traffic Server commons. -namespace ts -{ -struct ConstBuffer; -/** A chunk of writable memory. - A convenience class because we pass this kind of pair frequently. - - @note The default construct leaves the object - uninitialized. This is for performance reasons. To construct an - empty @c Buffer use @c Buffer(0). - */ -struct Buffer { - using self = Buffer; ///< Self reference type. - using pseudo_bool = bool (self::*)() const; - - char *_ptr = nullptr; ///< Pointer to base of memory chunk. - size_t _size = 0; ///< Size of memory chunk. - - /// Default constructor (empty buffer). - Buffer(); - - /** Construct from pointer and size. - @note Due to ambiguity issues do not call this with - two arguments if the first argument is 0. - */ - Buffer(char *ptr, ///< Pointer to buffer. - size_t n ///< Size of buffer. - ); - /** Construct from two pointers. - @note This presumes a half open range, (start, end] - */ - Buffer(char *start, ///< First valid character. - char *end ///< First invalid character. - ); - - /** Equality. - @return @c true if @a that refers to the same memory as @a this, - @c false otherwise. - */ - bool operator==(self const &that) const; - /** Inequality. - @return @c true if @a that does not refer to the same memory as @a this, - @c false otherwise. - */ - bool operator!=(self const &that) const; - /** Equality for a constant buffer. - @return @c true if @a that refers to the same memory as @a this. - @c false otherwise. - */ - bool operator==(ConstBuffer const &that) const; - /** Inequality. - @return @c true if @a that does not refer to the same memory as @a this, - @c false otherwise. - */ - bool operator!=(ConstBuffer const &that) const; - - /// @return The first character in the buffer. - char operator*() const; - /** Discard the first character in the buffer. - @return @a this object. - */ - self &operator++(); - - /// Check for empty buffer. - /// @return @c true if the buffer has a zero pointer @b or size. - bool operator!() const; - /// Check for non-empty buffer. - /// @return @c true if the buffer has a non-zero pointer @b and size. - operator pseudo_bool() const; - - /// @name Accessors. - //@{ - /// Get the data in the buffer. - char *data() const; - /// Get the size of the buffer. - size_t size() const; - //@} - - /// Set the chunk. - /// Any previous values are discarded. - /// @return @c this object. - self &set(char *ptr, ///< Buffer address. - size_t n = 0 ///< Buffer size. - ); - /// Reset to empty. - self &reset(); -}; - -/** A chunk of read only memory. - A convenience class because we pass this kind of pair frequently. - */ -struct ConstBuffer { - using self = ConstBuffer; ///< Self reference type. - using pseudo_bool = bool (self::*)() const; - - char const *_ptr = nullptr; ///< Pointer to base of memory chunk. - size_t _size = 0; ///< Size of memory chunk. - - /// Default constructor (empty buffer). - ConstBuffer(); - - /** Construct from pointer and size. - */ - ConstBuffer(char const *ptr, ///< Pointer to buffer. - size_t n ///< Size of buffer. - ); - /** Construct from two pointers. - @note This presumes a half open range (start, end] - @note Due to ambiguity issues do not invoke this with - @a start == 0. - */ - ConstBuffer(char const *start, ///< First valid character. - char const *end ///< First invalid character. - ); - /// Construct from writable buffer. - ConstBuffer(Buffer const &buffer ///< Buffer to copy. - ); - - /** Equality. - @return @c true if @a that refers to the same memory as @a this, - @c false otherwise. - */ - bool operator==(self const &that) const; - /** Equality. - @return @c true if @a that refers to the same memory as @a this, - @c false otherwise. - */ - bool operator==(Buffer const &that) const; - /** Inequality. - @return @c true if @a that does not refer to the same memory as @a this, - @c false otherwise. - */ - bool operator!=(self const &that) const; - /** Inequality. - @return @c true if @a that does not refer to the same memory as @a this, - @c false otherwise. - */ - bool operator!=(Buffer const &that) const; - /// Assign from non-const Buffer. - self &operator=(Buffer const &that ///< Source buffer. - ); - - /// @return The first character in the buffer. - char operator*() const; - /** Discard the first character in the buffer. - @return @a this object. - */ - self &operator++(); - /** Discard the first @a n characters. - @return @a this object. - */ - self &operator+=(size_t n); - - /// Check for empty buffer. - /// @return @c true if the buffer has a zero pointer @b or size. - bool operator!() const; - /// Check for non-empty buffer. - /// @return @c true if the buffer has a non-zero pointer @b and size. - operator pseudo_bool() const; - - operator std::string_view() const { return {_ptr, _size}; } - - /// @name Accessors. - //@{ - /// Get the data in the buffer. - char const *data() const; - /// Get the size of the buffer. - size_t size() const; - /// Access a character (no bounds check). - char operator[](int n) const; - //@} - /// @return @c true if @a p points at a character in @a this. - bool contains(char const *p) const; - - /// Set the chunk. - /// Any previous values are discarded. - /// @return @c this object. - self &set(char const *ptr, ///< Buffer address. - size_t n = 0 ///< Buffer size. - ); - /** Set from 2 pointers. - @note This presumes a half open range (start, end] - */ - self &set(char const *start, ///< First valid character. - char const *end ///< First invalid character. - ); - /// Reset to empty. - self &reset(); - - /** Find a character. - @return A pointer to the first occurrence of @a c in @a this - or @c nullptr if @a c is not found. - */ - char const *find(char c) const; - - /** Split the buffer on the character at @a p. - - The buffer is split in to two parts and the character at @a p - is discarded. @a this retains all data @b after @a p. The - initial part of the buffer is returned. Neither buffer will - contain the character at @a p. - - This is convenient when tokenizing and @a p points at the token - separator. - - @note If @a *p is not in the buffer then @a this is not changed - and an empty buffer is returned. This means the caller can - simply pass the result of @c find and check for an empty - buffer returned to detect no more separators. - - @return A buffer containing data up to but not including @a p. - */ - self splitOn(char const *p); - - /** Split the buffer on the character @a c. - - The buffer is split in to two parts and the occurrence of @a c - is discarded. @a this retains all data @b after @a c. The - initial part of the buffer is returned. Neither buffer will - contain the first occurrence of @a c. - - This is convenient when tokenizing and @a c is the token - separator. - - @note If @a c is not found then @a this is not changed and an - empty buffer is returned. - - @return A buffer containing data up to but not including @a p. - */ - self splitOn(char c); - /** Get a trailing segment of the buffer. - - @return A buffer that contains all data after @a p. - */ - self after(char const *p) const; - /** Get a trailing segment of the buffer. - - @return A buffer that contains all data after the first - occurrence of @a c. - */ - self after(char c) const; - /** Remove trailing segment. - - Data at @a p and beyond is removed from the buffer. - If @a p is not in the buffer, no change is made. - - @return @a this. - */ - self &clip(char const *p); -}; - -// ---------------------------------------------------------- -// Inline implementations. - -inline Buffer::Buffer() {} -inline Buffer::Buffer(char *ptr, size_t n) : _ptr(ptr), _size(n) {} -inline Buffer & -Buffer::set(char *ptr, size_t n) -{ - _ptr = ptr; - _size = n; - return *this; -} -inline Buffer::Buffer(char *start, char *end) : _ptr(start), _size(end - start) {} -inline Buffer & -Buffer::reset() -{ - _ptr = nullptr; - _size = 0; - return *this; -} -inline bool -Buffer::operator!=(self const &that) const -{ - return !(*this == that); -} -inline bool -Buffer::operator!=(ConstBuffer const &that) const -{ - return !(*this == that); -} -inline bool -Buffer::operator==(self const &that) const -{ - return _size == that._size && _ptr == that._ptr; -} -inline bool -Buffer::operator==(ConstBuffer const &that) const -{ - return _size == that._size && _ptr == that._ptr; -} -inline bool -Buffer::operator!() const -{ - return !(_ptr && _size); -} -inline Buffer::operator pseudo_bool() const -{ - return _ptr && _size ? &self::operator! : nullptr; -} -inline char -Buffer::operator*() const -{ - return *_ptr; -} -inline Buffer & -Buffer::operator++() -{ - ++_ptr; - --_size; - return *this; -} -inline char * -Buffer::data() const -{ - return _ptr; -} -inline size_t -Buffer::size() const -{ - return _size; -} - -inline ConstBuffer::ConstBuffer() {} -inline ConstBuffer::ConstBuffer(char const *ptr, size_t n) : _ptr(ptr), _size(n) {} -inline ConstBuffer::ConstBuffer(char const *start, char const *end) : _ptr(start), _size(end - start) {} -inline ConstBuffer::ConstBuffer(Buffer const &that) : _ptr(that._ptr), _size(that._size) {} -inline ConstBuffer & -ConstBuffer::set(char const *ptr, size_t n) -{ - _ptr = ptr; - _size = n; - return *this; -} - -inline ConstBuffer & -ConstBuffer::set(char const *start, char const *end) -{ - _ptr = start; - _size = end - start; - return *this; -} - -inline ConstBuffer & -ConstBuffer::reset() -{ - _ptr = nullptr; - _size = 0; - return *this; -} -inline bool -ConstBuffer::operator!=(self const &that) const -{ - return !(*this == that); -} -inline bool -ConstBuffer::operator!=(Buffer const &that) const -{ - return !(*this == that); -} -inline bool -ConstBuffer::operator==(self const &that) const -{ - return _size == that._size && 0 == memcmp(_ptr, that._ptr, _size); -} -inline ConstBuffer & -ConstBuffer::operator=(Buffer const &that) -{ - _ptr = that._ptr; - _size = that._size; - return *this; -} -inline bool -ConstBuffer::operator==(Buffer const &that) const -{ - return _size == that._size && 0 == memcmp(_ptr, that._ptr, _size); -} -inline bool -ConstBuffer::operator!() const -{ - return !(_ptr && _size); -} -inline ConstBuffer::operator pseudo_bool() const -{ - return _ptr && _size ? &self::operator! : nullptr; -} -inline char -ConstBuffer::operator*() const -{ - return *_ptr; -} -inline ConstBuffer & -ConstBuffer::operator++() -{ - ++_ptr; - --_size; - return *this; -} -inline ConstBuffer & -ConstBuffer::operator+=(size_t n) -{ - _ptr += n; - _size -= n; - return *this; -} -inline char const * -ConstBuffer::data() const -{ - return _ptr; -} -inline char -ConstBuffer::operator[](int n) const -{ - return _ptr[n]; -} -inline size_t -ConstBuffer::size() const -{ - return _size; -} -inline bool -ConstBuffer::contains(char const *p) const -{ - return _ptr <= p && p < _ptr + _size; -} - -inline ConstBuffer -ConstBuffer::splitOn(char const *p) -{ - self zret; // default to empty return. - if (this->contains(p)) { - size_t n = p - _ptr; - zret.set(_ptr, n); - _ptr = p + 1; - _size -= n + 1; - } - return zret; -} - -inline char const * -ConstBuffer::find(char c) const -{ - return static_cast(memchr(_ptr, c, _size)); -} - -inline ConstBuffer -ConstBuffer::splitOn(char c) -{ - return this->splitOn(this->find(c)); -} - -inline ConstBuffer -ConstBuffer::after(char const *p) const -{ - return this->contains(p) ? self(p + 1, (_size - (p - _ptr)) - 1) : self(); -} -inline ConstBuffer -ConstBuffer::after(char c) const -{ - return this->after(this->find(c)); -} -inline ConstBuffer & -ConstBuffer::clip(char const *p) -{ - if (this->contains(p)) { - _size = p - _ptr; - } - return *this; -} - -} // namespace ts - -using TsBuffer = ts::Buffer; -using TsConstBuffer = ts::ConstBuffer;