byp4a55 professor6T9

Linux server326.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64
LiteSpeed
67.223.118.122

swoole_string.h

/*
  +----------------------------------------------------------------------+
  | Swoole                                                               |
  +----------------------------------------------------------------------+
  | This source file is subject to version 2.0 of the Apache license,    |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.apache.org/licenses/LICENSE-2.0.html                      |
  | If you did not receive a copy of the Apache2.0 license and are unable|
  | to obtain it through the world-wide-web, please send a note to       |
  | license@swoole.com so we can mail you a copy immediately.            |
  +----------------------------------------------------------------------+
  | Author: Tianfeng Han  <rango@swoole.com>                             |
  |         Twosee  <twose@qq.com>                                       |
  +----------------------------------------------------------------------+
*/

#pragma once

#include "swoole.h"

#include <string>

#define SW_STRINGL(s) s->str, s->length
#define SW_STRINGS(s) s->str, s->size
// copy value
#define SW_STRINGCVL(s) s->str + s->offset, s->length - s->offset
// append value
#define SW_STRINGAVL(s) s->str + s->length, s->size - s->length

namespace swoole {
typedef std::function<bool(const char *, size_t)> StringExplodeHandler;

class String {
  private:
    void alloc(size_t _size, const Allocator *_allocator);
    void move(String &&src);
    void copy(const String &src);

public:
    size_t length;
    size_t size;
    off_t offset;
    char *str;
    const Allocator *allocator;

String() {
        length = size = offset = 0;
        str = nullptr;
        allocator = nullptr;
    }

explicit String(size_t _size, const Allocator *_allocator = nullptr) {
        alloc(_size, _allocator);
    }

String(const char *_str, size_t _length) {
        alloc(_length + 1, nullptr);
        memcpy(str, _str, _length);
        str[_length] = '\0';
        length = _length;
    }

explicit String(const std::string &_str) : String(_str.c_str(), _str.length()) {}

String(const String &src) {
        copy(src);
    }

String(String &&src) noexcept {
        move(std::move(src));
    }

String &operator=(const String &src) noexcept;
    String &operator=(String &&src) noexcept;

~String() {
        if (allocator && str) {
            allocator->free(str);
        }
    }

char *value() const {
        return str;
    }

size_t get_length() const {
        return length;
    }

size_t capacity() const {
        return size;
    }

std::string to_std_string() const {
        return {str, length};
    }

bool contains(const char *needle, size_t l_needle) const {
        return swoole_strnstr(str, length, needle, l_needle) != nullptr;
    }

bool contains(const std::string &needle) const {
        return contains(needle.c_str(), needle.size());
    }

bool starts_with(const char *needle, size_t l_needle) const {
        if (length < l_needle) {
            return false;
        }
        return memcmp(str, needle, l_needle) == 0;
    }

bool starts_with(const std::string &needle) const {
        return starts_with(needle.c_str(), needle.length());
    }

bool ends_with(const char *needle, size_t l_needle) const {
        if (length < l_needle) {
            return false;
        }
        return memcmp(str + length - l_needle, needle, l_needle) == 0;
    }

bool ends_with(const std::string &needle) const {
        return ends_with(needle.c_str(), needle.length());
    }

bool equals(const char *data, size_t len) const {
        if (length != len) {
            return false;
        }
        return memcmp(str, data, len) == 0;
    }

bool equals(const std::string &data) const {
        if (length != data.size()) {
            return false;
        }
        return memcmp(str, data.c_str(), length) == 0;
    }

void grow(size_t incr_value);
    String substr(size_t offset, size_t len) const;

bool empty() const {
        return str == nullptr || length == 0;
    }

void clear() {
        length = 0;
        offset = 0;
    }

void extend() {
        extend(size * 2);
    }

void extend(size_t new_size) {
        assert(new_size > size);
        reserve(new_size);
    }

void extend_align(size_t _new_size) {
        size_t align_size = SW_MEM_ALIGNED_SIZE(size * 2);
        while (align_size < _new_size) {
            align_size *= 2;
        }
        reserve(align_size);
    }

void reserve(size_t new_size);
    /**
     * Transfer ownership of the string content pointer to the caller, who will capture this memory.
     * The caller must manage and free this memory; it will not free when the string is destructed.
     */
    char *release();
    void repeat(const char *data, size_t len, size_t n);
    void append(const char *append_str, size_t length);

void append(const std::string &append_str) {
        append(append_str.c_str(), append_str.length());
    }

void append(const char c) {
        append(&c, sizeof(c));
    }

void append(int value);
    void append(const String &append_str);
    bool append_random_bytes(size_t length, bool base64 = false);

void write(off_t _offset, const String &write_str);
    void write(off_t _offset, const char *write_str, size_t _length);

void set_null_terminated() {
        if (length == size) {
            extend(length + 1);
        }
        str[length] = '\0';
    }

ssize_t split(const char *delimiter, size_t delimiter_length, const StringExplodeHandler &handler);
    void print(bool print_value = true) const;

enum FormatFlag {
        FORMAT_APPEND = 1 << 0,
        FORMAT_GROW = 1 << 1,
    };

template <typename... Args>
    size_t format_impl(int flags, const char *format, Args... args) {
        size_t _size = sw_snprintf(nullptr, 0, format, args...);
        if (_size == 0) {
            return 0;
        }
        // store \0 terminator
        ++_size;

size_t new_size = (flags & FORMAT_APPEND) ? length + _size : _size;
        if (flags & FORMAT_GROW) {
            size_t align_size = SW_MEM_ALIGNED_SIZE(size * 2);
            while (align_size < new_size) {
                align_size *= 2;
            }
            new_size = align_size;
        }

size_t n;
        if (flags & FORMAT_APPEND) {
            if (_size > size - length) {
                reserve(new_size);
            }
            n = sw_snprintf(str + length, size - length, format, args...);
            length += n;
        } else {
            if (_size > size) {
                reserve(new_size);
            }
            n = sw_snprintf(str, size, format, args...);
            length = n;
        }

return n;
    }

// This function replaces the entire string instead of appending content.
    template <typename... Args>
    size_t format(const char *format, Args... args) {
        return format_impl(0, format, args...);
    }

template <typename... Args>
    size_t append_format(const char *format, Args... args) {
        return format_impl(FORMAT_APPEND, format, args...);
    }

char *pop(size_t init_size);
    void reduce(off_t offset);
};

inline String *make_string(size_t size, const Allocator *allocator = nullptr) {
    return new String(size, allocator);
}
}  // namespace swoole

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	0755	2026-04-08 07:04:39
..	dir	-	root/linksafe	0755	2026-04-08 07:02:09
swoole.h	text/x-c++	26.96 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_api.h	text/x-c	2.02 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_asm_context.h	text/x-c	2.31 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_async.h	text/x-c++	3.29 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_atomic.h	text/x-c	2.3 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_base64.h	text/x-c++	1.3 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_buffer.h	text/x-c++	2.24 KB	root/linksafe	0644	2026-03-18 08:53:14
swoole_channel.h	text/x-c++	2.37 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_client.h	text/x-c++	11.75 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_config.h	text/x-c	8.79 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine.h	text/x-c++	8.92 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine_api.h	text/x-c	5.12 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine_channel.h	text/x-c++	4.17 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine_context.h	text/x-c++	2.75 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine_socket.h	text/x-c++	17.64 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_coroutine_system.h	text/x-c++	3.78 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_dtls.h	text/x-c++	2.42 KB	root/linksafe	0644	2026-03-18 08:53:15
swoole_error.h	text/x-c++	6.46 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_file.h	text/x-c++	4.88 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_file_hook.h	text/x-c	2.76 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_hash.h	text/x-c	1.24 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_heap.h	text/x-c++	1.9 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_http.h	text/x-c++	7.24 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_http2.h	text/x-c++	8.55 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_iouring.h	text/x-c++	5.52 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_llhttp.h	text/x-c	2.02 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_lock.h	text/x-c++	3.25 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_log.h	text/x-c++	15.71 KB	root/linksafe	0644	2026-03-18 08:53:16
swoole_lru_cache.h	text/x-c++	3.18 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_memory.h	text/x-c++	2.83 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_message_bus.h	text/x-c++	5.18 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_mime_type.h	text/x-c++	1.42 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_mqtt.h	text/x-c++	2.16 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_msg_queue.h	text/x-c++	1.96 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_pipe.h	text/x-c++	2.6 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_process_pool.h	text/x-c++	13.17 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_protocol.h	text/x-c++	5.03 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_proxy.h	text/x-c++	3.3 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_reactor.h	text/x-c++	12.4 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_redis.h	text/x-c++	1.83 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_server.h	text/x-c++	49.72 KB	root/linksafe	0644	2026-03-18 08:53:17
swoole_signal.h	text/x-c++	2.99 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_socket.h	text/x-c++	18.51 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_socket_hook.h	text/x-c	2.31 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_socket_impl.h	text/x-c	1.43 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_ssl.h	text/x-c++	5.22 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_static_handler.h	text/x-c++	5.21 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_string.h	text/x-c++	7.32 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_table.h	text/x-c++	6.5 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_thread.h	text/x-c++	1.99 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_timer.h	text/x-c++	4.37 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_uring_socket.h	text/x-c++	3.84 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_util.h	text/x-c++	7.49 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_version.h	text/x-c	1.74 KB	root/linksafe	0644	2026-03-18 08:53:18
swoole_websocket.h	text/x-c++	5.11 KB	root/linksafe	0644	2026-03-18 08:53:19

Team Anon Force

https://t.me/Professor6T9x