File Manager

X7ROOT File Manager

Current Path: /opt/alt/php84/usr/include/php/ext/swoole/include

opt / alt / php84 / usr / include / php / ext / swoole / include /

?? ..
?? swoole.h(26.96 KB)
?? swoole_api.h(2.02 KB)
?? swoole_asm_context.h(2.31 KB)
?? swoole_async.h(3.29 KB)
?? swoole_atomic.h(2.3 KB)
?? swoole_base64.h(1.3 KB)
?? swoole_buffer.h(2.24 KB)
?? swoole_channel.h(2.37 KB)
?? swoole_client.h(11.75 KB)
?? swoole_config.h(8.79 KB)
?? swoole_coroutine.h(8.92 KB)
?? swoole_coroutine_api.h(5.12 KB)
?? swoole_coroutine_channel.h(4.17 KB)
?? swoole_coroutine_context.h(2.75 KB)
?? swoole_coroutine_socket.h(17.64 KB)
?? swoole_coroutine_system.h(3.78 KB)
?? swoole_dtls.h(2.42 KB)
?? swoole_error.h(6.46 KB)
?? swoole_file.h(4.88 KB)
?? swoole_file_hook.h(2.76 KB)
?? swoole_hash.h(1.24 KB)
?? swoole_heap.h(1.9 KB)
?? swoole_http.h(7.24 KB)
?? swoole_http2.h(8.55 KB)
?? swoole_iouring.h(5.52 KB)
?? swoole_llhttp.h(2.02 KB)
?? swoole_lock.h(3.25 KB)
?? swoole_log.h(15.71 KB)
?? swoole_lru_cache.h(3.18 KB)
?? swoole_memory.h(2.83 KB)
?? swoole_message_bus.h(5.18 KB)
?? swoole_mime_type.h(1.42 KB)
?? swoole_mqtt.h(2.16 KB)
?? swoole_msg_queue.h(1.96 KB)
?? swoole_pipe.h(2.6 KB)
?? swoole_process_pool.h(13.17 KB)
?? swoole_protocol.h(5.03 KB)
?? swoole_proxy.h(3.3 KB)
?? swoole_reactor.h(12.4 KB)
?? swoole_redis.h(1.83 KB)
?? swoole_server.h(49.72 KB)
?? swoole_signal.h(2.99 KB)
?? swoole_socket.h(18.51 KB)
?? swoole_socket_hook.h(2.31 KB)
?? swoole_socket_impl.h(1.43 KB)
?? swoole_ssl.h(5.22 KB)
?? swoole_static_handler.h(5.21 KB)
?? swoole_string.h(7.32 KB)
?? swoole_table.h(6.5 KB)
?? swoole_thread.h(1.99 KB)
?? swoole_timer.h(4.37 KB)
?? swoole_uring_socket.h(3.84 KB)
?? swoole_util.h(7.49 KB)
?? swoole_version.h(1.74 KB)
?? swoole_websocket.h(5.11 KB)

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

X7ROOT File Manager

Editing: swoole_string.h

Upload File

Create Folder