File Manager

X7ROOT File Manager

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

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

ðŸ“ ..
ðŸ“„ swoole.h(22.85 KB)
ðŸ“„ swoole_api.h(3.39 KB)
ðŸ“„ swoole_asm_context.h(1.76 KB)
ðŸ“„ swoole_async.h(3.7 KB)
ðŸ“„ swoole_atomic.h(2.15 KB)
ðŸ“„ swoole_base64.h(1.29 KB)
ðŸ“„ swoole_buffer.h(2.28 KB)
ðŸ“„ swoole_c_api.h(2.19 KB)
ðŸ“„ swoole_channel.h(2.34 KB)
ðŸ“„ swoole_client.h(8.41 KB)
ðŸ“„ swoole_config.h(8.84 KB)
ðŸ“„ swoole_coroutine.h(8.96 KB)
ðŸ“„ swoole_coroutine_c_api.h(4.9 KB)
ðŸ“„ swoole_coroutine_channel.h(4.18 KB)
ðŸ“„ swoole_coroutine_context.h(2.59 KB)
ðŸ“„ swoole_coroutine_socket.h(18.85 KB)
ðŸ“„ swoole_coroutine_system.h(3.48 KB)
ðŸ“„ swoole_dtls.h(2.41 KB)
ðŸ“„ swoole_error.h(5.85 KB)
ðŸ“„ swoole_file.h(4.09 KB)
ðŸ“„ swoole_file_hook.h(2.86 KB)
ðŸ“„ swoole_hash.h(9.69 KB)
ðŸ“„ swoole_heap.h(1.79 KB)
ðŸ“„ swoole_http.h(6.99 KB)
ðŸ“„ swoole_http2.h(8.38 KB)
ðŸ“„ swoole_lock.h(2.64 KB)
ðŸ“„ swoole_log.h(15.72 KB)
ðŸ“„ swoole_lru_cache.h(3.17 KB)
ðŸ“„ swoole_memory.h(2.75 KB)
ðŸ“„ swoole_message_bus.h(5.53 KB)
ðŸ“„ swoole_mime_type.h(1.44 KB)
ðŸ“„ swoole_mqtt.h(2.18 KB)
ðŸ“„ swoole_msg_queue.h(1.92 KB)
ðŸ“„ swoole_pipe.h(2.64 KB)
ðŸ“„ swoole_process_pool.h(8.88 KB)
ðŸ“„ swoole_protocol.h(5.32 KB)
ðŸ“„ swoole_proxy.h(2.14 KB)
ðŸ“„ swoole_reactor.h(11.25 KB)
ðŸ“„ swoole_redis.h(2.09 KB)
ðŸ“„ swoole_server.h(39.62 KB)
ðŸ“„ swoole_signal.h(1.68 KB)
ðŸ“„ swoole_socket.h(17.61 KB)
ðŸ“„ swoole_socket_hook.h(2.23 KB)
ðŸ“„ swoole_ssl.h(4.94 KB)
ðŸ“„ swoole_static_handler.h(4.7 KB)
ðŸ“„ swoole_string.h(8.06 KB)
ðŸ“„ swoole_table.h(7.35 KB)
ðŸ“„ swoole_timer.h(4.05 KB)
ðŸ“„ swoole_util.h(5.58 KB)
ðŸ“„ swoole_version.h(2.21 KB)
ðŸ“„ swoole_websocket.h(4.53 KB)
ðŸ“„ swoole_wheel_timer.h(2.48 KB)

Editing: swoole_util.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 <stdio.h>
#include <stdarg.h>

#include <string>
#include <memory>
#include <chrono>
#include <set>
#include <vector>
#include <stack>
#include <type_traits>

#define __SCOPEGUARD_CONCATENATE_IMPL(s1, s2) s1##s2
#define __SCOPEGUARD_CONCATENATE(s1, s2) __SCOPEGUARD_CONCATENATE_IMPL(s1, s2)

namespace swoole {

namespace std_string {
template <typename... Args>
inline std::string format(const char *format, Args... args) {
    size_t size = snprintf(nullptr, 0, format, args...) + 1;  // Extra space for '\0'
    std::unique_ptr<char[]> buf(new char[size]);
    snprintf(buf.get(), size, format, args...);
    return std::string(buf.get(), buf.get() + size - 1);  // We don't want the '\0' inside
}

inline std::string vformat(const char *format, va_list args) {
    va_list _args;
    va_copy(_args, args);
    size_t size = vsnprintf(nullptr, 0, format, _args) + 1;  // Extra space for '\0'
    va_end(_args);
    std::unique_ptr<char[]> buf(new char[size]);
    vsnprintf(buf.get(), size, format, args);
    return std::string(buf.get(), buf.get() + size - 1);  // We don't want the '\0' inside
}
}  // namespace std_string

// Keep parameter 'steady' as false for backward compatibility.
template <typename T>
static inline long time(bool steady = false) {
    if (sw_likely(steady)) {
        auto now = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<T>(now.time_since_epoch()).count();
    } else {
        auto now = std::chrono::system_clock::now();
        return std::chrono::duration_cast<T>(now.time_since_epoch()).count();
    }
}

static inline long get_timezone() {
#ifdef __linux__
    return timezone;
#else
    struct timezone tz;
    struct timeval tv;
    gettimeofday(&tv, &tz);
    return tz.tz_minuteswest * 60;
#endif
}

class DeferTask {
  private:
    std::stack<Callback> list_;

public:
    void add(Callback fn) {
        list_.push(fn);
    }

~DeferTask() {
        while (!list_.empty()) {
            auto fn = list_.top();
            fn(nullptr);
            list_.pop();
        }
    }
};

template <typename Fun>
class ScopeGuard {
  public:
    ScopeGuard(Fun &&f) : _fun(std::forward<Fun>(f)), _active(true) {}

~ScopeGuard() {
        if (_active) {
            _fun();
        }
    }

void dismiss() {
        _active = false;
    }

ScopeGuard() = delete;
    ScopeGuard(const ScopeGuard &) = delete;
    ScopeGuard &operator=(const ScopeGuard &) = delete;

ScopeGuard(ScopeGuard &&rhs) : _fun(std::move(rhs._fun)), _active(rhs._active) {
        rhs.dismiss();
    }

private:
    Fun _fun;
    bool _active;
};

namespace detail {
enum class ScopeGuardOnExit {};

template <typename Fun>
inline ScopeGuard<Fun> operator+(ScopeGuardOnExit, Fun &&fn) {
    return ScopeGuard<Fun>(std::forward<Fun>(fn));
}
}  // namespace detail

// Helper macro
#define ON_SCOPE_EXIT                                                                                                  \
    auto __SCOPEGUARD_CONCATENATE(ext_exitBlock_, __LINE__) = swoole::detail::ScopeGuardOnExit() + [&]()

std::string intersection(std::vector<std::string> &vec1, std::set<std::string> &vec2);

static inline size_t ltrim(char **str, size_t len) {
    size_t i;
    for (i = 0; i < len; ++i) {
        if ('\0' != **str && isspace(**str)) {
            ++*str;
        } else {
            break;
        }
    }
    return len - i;
}

static inline size_t rtrim(char *str, size_t len) {
    for (size_t i = len; i > 0;) {
        if (isspace(str[--i])) {
            str[i] = 0;
            len--;
        } else {
            break;
        }
    }
    return len;
}

static inline size_t rtrim(const char *str, size_t len) {
    for (size_t i = len; i > 0;) {
        if (isspace(str[--i])) {
            len--;
        } else {
            break;
        }
    }
    return len;
}

static inline ssize_t substr_len(const char *str, size_t len, char separator, bool before = false) {
    const char *substr = (const char *) memchr(str, separator, len);
    if (substr == nullptr) {
        return -1;
    }
    return before ? substr - str : str + len - substr - 1;
}

static inline bool starts_with(const char *haystack, size_t l_haystack, const char *needle, size_t l_needle) {
    if (l_needle > l_haystack) {
        return false;
    }
    return memcmp(haystack, needle, l_needle) == 0;
}

static inline bool ends_with(const char *haystack, size_t l_haystack, const char *needle, size_t l_needle) {
    if (l_needle > l_haystack) {
        return false;
    }
    return memcmp(haystack + l_haystack - l_needle, needle, l_needle) == 0;
}

}  // namespace swoole

X7ROOT File Manager

Editing: swoole_util.h

Upload File

Create Folder