Util.h

浏览该文件的文档.

// Copyright 2024 libsese
//
// Licensed 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
 
#include "sese/Config.h"
#include "sese/io/InputStream.h"
#include "sese/io/OutputStream.h"
 
#include <chrono>
#include <thread>
 
using namespace std::chrono_literals;
 
namespace sese {
 
// 使用预声明减少头文件引用
enum class Level;
 
int64_t toInteger(const std::string &string, int radix = 10);
 
std::string getClassName(const std::type_info *type);
 
struct StrCmp {
    int operator()(char const *lv, char const *rv) const;
    int operator()(const std::string &lv, const std::string &rv) const;
};
 
struct StrCmpI {
    int operator()(char const *lv, char const *rv) const;
    int operator()(const std::string &lv, const std::string &rv) const;
};
 
bool strcmp(char const *lv, char const *rv) noexcept;
 
bool strcmpDoNotCase(char const *lv, char const *rv) noexcept;
 
bool isSpace(char ch) noexcept;
 
const char *getLevelString(Level level) noexcept;
 
int32_t findFirstAt(const char *str, char ch);
 
void sleep(uint32_t second);
 
template<class REP, class PERIOD>
void sleep(const std::chrono::duration<REP, PERIOD> &duration) {
    std::this_thread::sleep_for(duration);
}
 
std::string getErrorString(int64_t error = errno);
 
int32_t  getErrorCode();
 
size_t streamMove(sese::io::OutputStream *out, sese::io::InputStream *in, size_t size) noexcept;
 
template<class T>
size_t number2StringLength(T num, size_t radix = 10) {
    static_assert(!std::is_same_v<T, double>, "Must be an integer");
    static_assert(!std::is_same_v<T, float>, "Must be an integer");
    size_t length = 0;
    if (num == 0) return 1;
    if (num < 0) {
        length += 1;
        num *= -1;
    }
    do {
        num /= static_cast<T>(radix);
        length += 1;
    } while (num > 0);
    return length;
}
 
template<class T>
size_t floating2StringLength(T num, uint16_t placeholder) {
    static_assert(std::is_same_v<T, double> || std::is_same_v<T, float>, "Must be a floating number");
    size_t length = number2StringLength(static_cast<int64_t>(num));
    if (placeholder > 0) {
        length += 1 + placeholder;
    }
    return length;
}
 
// GCOVR_EXCL_START
template<typename TP>
std::time_t to_time_t(TP tp) {
    using namespace std::chrono;
    auto sctp = time_point_cast<system_clock::duration>(tp - TP::clock::now() + system_clock::now());
    return system_clock::to_time_t(sctp);
}
// GCOVR_EXCL_STOP
 
template <typename T>
bool isAdditionOverflow(T a, T b) {
    if constexpr (std::is_unsigned_v<T>) {
        return a > std::numeric_limits<T>::max() - b;
    } else {
        if ((b > 0 && a > std::numeric_limits<T>::max() - b) ||
            (b < 0 && a < std::numeric_limits<T>::min() - b)) {
            return true;
        }
    }
    return false;
}
 
template <typename T>
bool isSubtractionOverflow(T a, T b) {
    if constexpr (std::is_unsigned<T>::value) {
        return a < b;
    } else {
        if ((b < 0 && a > std::numeric_limits<T>::max() + b) ||
            (b > 0 && a < std::numeric_limits<T>::min() + b)) {
           return true;
        }
    }
    return false;
}
 
} // namespace sese
 
extern "C" const char *getSpecificVersion();
 
#ifdef _WIN32
#pragma warning(disable : 4996)
#endif
 
#define CheckRange(x, max) ((unsigned int) (x) < (max))
 
#define CheckRangeBetween(x, min, max) (((x) - (min)) | ((max) - (x)) >= 0)