XunBang/Distribution_Service
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
25de7b4c32
Distribution_Service/CC_SDK/Include/basic/CC.h

1115 lines
34 KiB
C
Raw Normal View History

V0.1
2025-11-11 17:46:19 +08:00
#ifndef CC_H
#define CC_H
#pragma once
V0.12
2025-12-05 16:46:23 +08:00
#if defined(__arm__) || defined(__aarch64__)
#define IS_ARM 1
#if defined(__aarch64__)
#define IS_ARM64 1
#else
#define IS_ARM32 1
#endif
#else
#define IS_ARM 0
#endif
V0.1
2025-11-11 17:46:19 +08:00
#define CCTime_Day_S 86400
#define CCTime_Points_S 60
#include "CCMap.h"
#include "CCList.h"
#include "CCQueue.h"
#include "CCArray.h"
#include "CCVector.h"
#include "CCFunction.h"
#include "CCArrayList.h"
#include "CCLinkedMap.h"
#include <cstdint>
#include <fstream>
#include "mutex"
#include <sstream>
#include <iomanip>
#include <ctime>
#include <thread>
#include <utility>
#include "functional"
#include <chrono>
#include <shared_mutex>
#include "CCAutoLock.h"
#include <stdexcept>
#include <future>
#include <chrono>
#include <regex>
#include <csetjmp>
#include "CCString.h"
#include "StreamHandler.h"
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#include <mswsock.h>
#include <Windows.h>
#pragma warning(disable : 4996)
#pragma comment(lib,"ws2_32.lib")
#elif __linux__
#include <unistd.h>
#include <csignal>
#endif
#if __OHOS__
#pragma warning(push)
#pragma warning(disable: -Wformat-security)
// 或者对于 GCC/Clang
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-security"
#endif
#define CCVar auto
#define C_Auto const auto
using StdString = std::string;
typedef std::exception CCException;
typedef std::ostream OStream;
// 定义颜色代码
#define RESET "\033[0m"
#define BLACK "\033[30m"
#define RED "\033[31m"
#define GREEN "\033[32m"
#define YELLOW "\033[33m"
#define BLUE "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN "\033[36m"
#define WHITE "\033[37m"
// 定义背景色代码
#define BG_BLACK "\033[40m"
#define BG_RED "\033[41m"
#define BG_GREEN "\033[42m"
#define BG_YELLOW "\033[43m"
#define BG_BLUE "\033[44m"
#define BG_MAGENTA "\033[45m"
#define BG_CYAN "\033[46m"
#define BG_WHITE "\033[47m"
// 定义格式属性代码
#define BOLD "\033[1m"
#define UNDERLINE "\033[4m"
#define BLINK "\033[5m"
#define REVERSE "\033[7m"
namespace CTL{
// 模板函数，用于输出ArrayList容器中的元素
template <typename T>
OStream& operator<<(OStream& os, const ArrayList<T>& arr) {
os << "[";
for (size_t i = 0; i < arr.size(); ++i) {
if (i != 0) {
os << ", ";
}
os << arr[i];
}
os << "]";
return os;
}
inline std::string generateUnique16CharString() {
// 获取高精度时间戳（纳秒）
auto now = std::chrono::high_resolution_clock::now();
auto nanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now)
.time_since_epoch()
.count();
// 转换为16位十六进制字符串（大写）
std::stringstream ss;
ss << std::hex << std::uppercase << std::setfill('0') << std::setw(16)
<< static_cast<uint64_t>(nanos);
return ss.str();
}
}
// 结构体CCTimeInfo用于存储时间信息
struct CCTimeInfo
{
int year;
int month;
int day;
int hour;
int minute;
int second;
int week;
};
// 类CCTimeData用于处理时间相关的操作
class CCTimeData
{
protected:
time_t * m_time{};
struct tm * p{};
public:
// 默认构造函数，获取当前时间信息
CCTimeData() {
GetTimeInfo = Now();
}
// 构造函数，传入特定的时间点
CCTimeData(std::time_t* t);
CCTimeData(const CCTimeInfo &t);
CCTimeData(const std::string &t);
~CCTimeData();
// 获取当前时间信息
static CCTimeInfo Now();
static CCTimeInfo GetTime(time_t t);
// 将时间信息转换为字符串
/*
* format 格式化字符串
* 返回格式化后的字符串
*
* yyyy 年份
* MM 月份
* dd 十进制表示的每月的第几天
* HH 十时制表示的小时
* hh 12小时制的小时
* mm 分钟数
* ss 秒数
*/
[[nodiscard]] std::string to_String(const StdString& format = "yyyy-MM-dd HH:mm:ss") const;
// 根据指定格式格式化时间信息
/*
%a 星期几的简写
%A 星期几的全称
%b 月分的简写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中，十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字，使用基于周的年
%G 年分，使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟：hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒：hh:mm:ss
%u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）
%U 第年的第几周，把星期日做为第一天（值从0到53）
%V 每年的第几周，使用基于周的年
%w 十进制表示的星期几（值从0到6，星期天为0）
%W 每年的第几周，把星期一做为第一天（值从0到53）
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份（值从0到99）
%Y 带世纪部分的十制年份
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。
%% 百分号
*/
[[nodiscard]] std::string Format(const std::string& format = "%Y-%M-%d %H:%M:%S") const;
// 解析格式 "yyyy-MM-dd HH:mm:ss"
static CCTimeInfo parseTimeString(const std::string& timeStr);
// 将时间字符串解析为 time_t
static time_t parseTimeString_t(const std::string& timeStr);
// 将 time_t 转换为格式化字符串
static std::string formatTime(time_t time);
// 计算时间加上秒数后的结果
static std::string addSecondsToTime(const std::string& timeStr, int seconds);
// 检查当前时间是否是新的一天
static bool IsNewDay();
// 比较时间信息
bool operator==(const CCTimeInfo& other) const;
// 比较时间是否晚于指定的时间信息
bool operator>(const CCTimeInfo& other) const;
// 比较时间是否早于指定的时间信息
bool operator<(const CCTimeInfo& other) const;
// 比叫时间与指定时间的差值
int operator-(const CCTimeInfo& other) const;
/**
* 判断是否闰年
* @return 是否闰年
*/
static bool isLeapYear(int year);
/**
* 计算从公元元年到指定日期的总天数
* @return 总天数
*/
static int dateToDays(int year, int month, int day);
/**
* 计算两个日期之间的天数差
* @param date1 日期1
* @param date2 日期2
* @return 天数差
*/
static int calculateDaysDifference(const std::string& date1, const std::string& date2);
private:
// 静态函数，用于获取星期几
static int GetWeek(int week);
// 存储时间信息的变量
CCTimeInfo GetTimeInfo{};
inline static std::string LastCheckedDate;
public:
};
// 类CC是一个工具类，包含了一些静态方法和属性
class CC{
public:
typedef int RIos;
public:
template<typename T>
static void format_one_arg(std::string& result, T&& value) {
size_t pos = result.find("{}");
if (pos != std::string::npos) {
std::string replacement;
if constexpr (std::is_same_v<std::decay_t<T>, const char*> ||
std::is_same_v<std::decay_t<T>, char*>) {
replacement = value ? value : "null";
} else if constexpr (std::is_arithmetic_v<std::decay_t<T>>) {
// 对于算术类型，明确指定类型
if constexpr (std::is_integral_v<std::decay_t<T>> && !std::is_same_v<std::decay_t<T>, bool>) {
replacement = CC::to_String(static_cast<long long>(value));
} else if constexpr (std::is_floating_point_v<std::decay_t<T>>) {
replacement = CC::to_String(static_cast<long double>(value));
} else if constexpr (std::is_same_v<std::decay_t<T>, bool>) {
replacement = CC::to_String(static_cast<bool>(value));
}
} else {
// 对于其他类型，假设对象有 to_String 方法
replacement = CC::to_String(value);
}
result.replace(pos, 2, replacement);
}
}
static std::string format_braces_template(std::string fmt_str) {
return fmt_str;
}
template<typename T, typename... Rest>
static std::string format_braces_template(std::string fmt_str, T&& first, Rest&&... rest) {
format_one_arg(fmt_str, std::forward<T>(first));
if constexpr (sizeof...(rest) > 0) {
return format_braces_template(fmt_str, std::forward<Rest>(rest)...);
}
return fmt_str;
}
template<typename T>
static std::string format_braces_template(std::string fmt_str, T&& first) {
format_one_arg(fmt_str, std::forward<T>(first));
return fmt_str;
}
template<typename... Args>
static StdString format(const char* fmt, Args... args) {
std::string fmt_str = fmt;
if (fmt_str.find("{}") != std::string::npos) {
return format_braces_template(fmt_str, args...);
}
const int length = std::snprintf(nullptr, 0, fmt, args...);
if (length <= 0) {
return fmt_str; // 格式化失败，返回原始格式字符串
}
// 分配足够的空间来存储格式化后的字符串
std::string result(length, '\0');
std::snprintf(&result[0], length + 1, fmt, args...);
return result;
}
// 设置程序关闭时的回调函数
inline static void SetCloseFun(const std::function<bool()>& obj) {
CloseFun = obj;
}
// 将整数转换为字符串
static StdString to_String(const int v){
return std::to_string(v);
}
// 将双精度浮点数转换为字符串
static StdString to_String(const double v){
return std::to_string(v);
}
// 将布尔值转换为字符串
static StdString to_String(const bool v){
return v ? "true" : "false";
}
// 将C风格字符串转换为StdString
static StdString to_String(const char* v){
return v;
}
// 直接返回传入的StdString
static StdString to_String(StdString v){
return v;
}
// 将指针转换为字符串
static StdString to_String(void* v){
return std::to_string((size_t)v);
}
static StdString to_String(const CTL::Byte v){
return std::to_string(v.get());
}
static StdString to_String(const long v){
return std::to_string(v);
}
static StdString to_String(const long unsigned int& v){
return std::to_string(v);
}
static StdString to_String(const long long v){
return std::to_string(v);
}
static StdString to_String(const long double v){
return std::to_string(v);
}
// 打印输出，不换行
template<typename T>
static void Print(const T& v,const char* Color = RESET){
customCout << Color << v << RESET;
}
// 格式化打印输出，不换行
template<typename T,typename... Args>
static void Print(long long size,const T& v,Args&&... args){
CCVar* va = new char[size];
memset(va,0,size);
sprintf(va,v,args...);
Print(va);
delete[] va;
}
// 格式化打印输出，并换行
template<typename T>
static void Println(const T& v,const char* Color = RESET){
customCout<< Color << v << RESET << std::endl;
}
// 带时间戳的打印输出，并换行
template<typename T>
static void TimePrintln(const T& v){
StdString time = "[" + CCTimeData().to_String() + "] -> ";
time = time + v;
Println(time);
}
// 带时间戳的格式化打印输出，并换行
template<typename T,typename... Args>
static void TimePrintln(long long size,const T& v,Args&&... args){
CCVar* va = new char[size];
memset(va,0,size);
sprintf(va,v,args...);
TimePrintln(va);
delete[] va;
}
// 打印错误信息，并抛出异常
static void ErrorPrintln(const StdString& v){
throw std::out_of_range(v.c_str());
}
// CCLogo打印相关的属性和方法
inline static int LogoTimeMS = 1;
static void CC_Print_Logo(){
// 打印CCLogo，每个部分之间暂停一段时间
customCout << " CCCCCCCCCCCCC CCCCCCCCCCCCC AAA PPPPPPPPPPPPPPPPP IIIIIIIIII " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " CCC::::::::::::C CCC::::::::::::C A:::A P::::::::::::::::P I::::::::I" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " CC:::::::::::::::C CC:::::::::::::::C A:::::A P::::::PPPPPP:::::P I::::::::I" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " C:::::CCCCCCCC::::C C:::::CCCCCCCC::::C A:::::::A PP:::::P P:::::PII::::::II" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " C:::::C CCCCCC C:::::C CCCCCC A:::::::::A P::::P P:::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::A:::::A P::::P P:::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::A A:::::A P::::PPPPPP:::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::A A:::::A P:::::::::::::PP I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::A A:::::A P::::PPPPPPPPP I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::AAAAAAAAA:::::A P::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << "C:::::C C:::::C A:::::::::::::::::::::A P::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " C:::::C CCCCCC C:::::C CCCCCC A:::::AAAAAAAAAAAAA:::::A P::::P I::::I " << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " C:::::CCCCCCCC::::C C:::::CCCCCCCC::::C A:::::A A:::::A PP::::::PP II::::::II" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " CC:::::::::::::::C CC:::::::::::::::C A:::::A A:::::A P::::::::P I::::::::I" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " CCC::::::::::::C CCC::::::::::::C A:::::A A:::::A P::::::::P I::::::::I" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " CCCCCCCCCCCCC CCCCCCCCCCCCC AAAAAAA AAAAAAAPPPPPPPPPP IIIIIIIIII" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " ________________________ "<< std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(LogoTimeMS));
customCout << " _:::::::::::::::::::::_ " << std::endl;
customCout << " ________________________ "<< std::endl;
customCout << " " << std::endl;
}
// 获取程序关闭时的回调函数
static std::function<bool()> GetCloseFun() {
return CloseFun;
}
static bool IsRun(){
return Exe_Run;
}
static void Exit(){
Exe_Run = false;
}
private:
// 程序关闭时的回调函数
inline static std::function<bool()> CloseFun;
inline static bool Exe_Run = true;
};
namespace CTL {
inline void SignalHandler(const int signum) {
signal(SIGINT, CTL::SignalHandler); // Ctrl+C
signal(SIGTERM, CTL::SignalHandler); // 终止请求
if (signum == 2) {
if(const auto CFun = CC::GetCloseFun()){
if (CFun()) {
CC::Exit();
}
}
else {
CC::Exit();
}
}
}
}
class CCAppInit_ {
public:
inline static std::function<void(int)> Signal;
CCAppInit_() {
signal(SIGINT, CTL::SignalHandler); // Ctrl+C
signal(SIGTERM, CTL::SignalHandler); // 终止请求
#if __linux__
#endif
#ifndef CC_LOGO_NO
CC::CC_Print_Logo();
#endif
}
~CCAppInit_() {
CC::Println("CC API library END OF RUN ! \u263A \u2764");
}
};
// CCInt类用于封装整型数值
class CCInt
{
private:
int value; // 存储整型数值的变量
public:
// 默认构造函数
CCInt() = default;
// 构造函数，初始化整型数值
// 参数v: 要封装的整型数值
CCInt(const int v){
this->value = v;
}
// 将整型数值转换为字符串表示
// 返回值: 整型数值的字符串表示
[[nodiscard]] StdString to_String() const{
return std::to_string(value);
}
// 显式转换为整型数值
// 返回值: 封装的整型数值
operator int() const{
return value;
}
operator StdString () const{
return std::to_string(value);
}
operator StdString (){
return std::to_string(value);
}
bool operator == (const CCInt& other) const{
return value == other.value;
}
bool operator == (const int& other) const{
return value == other;
}
bool operator != (const CCInt& other) const{
return value != other.value;
}
bool operator != (const int& other) const{
return value != other;
}
bool operator > (const CCInt& other) const{
return value > other.value;
}
bool operator > (const int& other) const{
return value > other;
}
bool operator < (const CCInt& other) const{
return value < other.value;
}
bool operator < (const int& other) const{
return value < other;
}
bool operator >= (const CCInt& other) const{
return value >= other.value;
}
bool operator >= (const int& other) const{
return value >= other;
}
bool operator <= (const CCInt& other) const{
return value <= other.value;
}
bool operator <= (const int& other) const{
return value <= other;
}
int operator + (const CCInt& other) const{
return value + other.value;
}
int operator + (const int& other) const{
return value + other;
}
int operator - (const CCInt& other) const{
return value - other.value;
}
int operator - (const int& other) const{
return value - other;
}
int operator * (const CCInt& other) const{
return value * other.value;
}
int operator * (const int& other) const{
return value * other;
}
int operator / (const CCInt& other) const{
return value / other.value;
}
int operator / (const int& other) const{
return value / other;
}
int operator % (const CCInt& other) const{
return value % other.value;
}
int operator % (const int& other) const{
return value % other;
}
int operator ++ (){
return ++value;
}
int operator -- (){
return --value;
}
int operator & (const CCInt& other) const{
return value & other.value;
}
int operator & (const int& other) const{
return value & other;
}
int operator | (const CCInt& other) const{
return value | other.value;
}
int operator | (const int& other) const{
return value | other;
}
int operator ^ (const CCInt& other) const{
return value ^ other.value;
}
int operator ^ (const int& other) const{
return value ^ other;
}
int operator << (const CCInt& other) const{
return value << other.value;
}
int operator << (const int& other) const{
return value << other;
}
int operator >> (const CCInt& other) const{
return value >> other.value;
}
int operator >> (const int& other) const{
return value >> other;
}
int operator && (const CCInt& other) const{
return value && other.value;
}
int operator && (const int& other) const{
return value && other;
}
int operator || (const CCInt& other) const{
return value || other.value;
}
int operator || (const int& other) const{
return value || other;
}
int operator ! (){
return !value;
}
int operator ~ (){
return ~value;
}
int operator = (const CCInt& other){
value = other.value;
return value;
}
int operator = (const int& other){
value = other;
return value;
}
int operator -= (const CCInt& other){
value -= other.value;
return value;
}
int operator -= (const int& other){
value -= other;
return value;
}
int operator += (const CCInt& other){
value += other.value;
return value;
}
int operator += (const int& other){
value += other;
return value;
}
int operator *= (const CCInt& other){
value *= other.value;
return value;
}
int operator *= (const int& other){
value *= other;
return value;
}
int operator /= (const CCInt& other){
value /= other.value;
return value;
}
int operator /= (const int& other){
value /= other;
return value;
}
};
// CCDouble类用于封装双精度浮点数值
class CCDouble
{
private:
double value; // 存储双精度浮点数值的变量
public:
// 默认构造函数
CCDouble() = default;
// 构造函数，初始化双精度浮点数值
// 参数v: 要封装的双精度浮点数值
CCDouble(const double v){
this->value = v;
}
// 将双精度浮点数值转换为字符串表示
// 参数x: 小数点后的位数，默认为5
// 返回值: 双精度浮点数值的字符串表示
[[nodiscard]] StdString to_String(const int x = 5) const{
std::ostringstream stream;
stream << std::fixed << std::setprecision(x) << value;
return stream.str();
}
// 显式转换为双精度浮点数值
operator double() const{
return value;
}
operator StdString () const{
return std::to_string(value);
}
bool operator == (const CCDouble& other) const{
return value == other.value;
}
bool operator == (const double& other) const{
return value == other;
}
bool operator != (const CCDouble& other) const{
return value != other.value;
}
bool operator != (const double& other) const{
return value != other;
}
bool operator > (const CCDouble& other) const{
return value > other.value;
}
bool operator > (const double& other) const{
return value > other;
}
bool operator < (const CCDouble& other) const{
return value < other.value;
}
bool operator < (const double& other) const{
return value < other;
}
bool operator >= (const CCDouble& other) const{
return value >= other.value;
}
bool operator >= (const double& other) const{
return value >= other;
}
bool operator <= (const CCDouble& other) const{
return value <= other.value;
}
bool operator <= (const double& other) const{
return value <= other;
}
double operator + (const CCDouble& other) const{
return value + other.value;
}
double operator + (const double& other) const{
return value + other;
}
double operator - (const CCDouble& other) const{
return value - other.value;
}
double operator - (const double& other) const{
return value - other;
}
double operator * (const CCDouble& other) const{
return value * other.value;
}
double operator * (const double& other) const{
return value * other;
}
double operator / (const CCDouble& other) const{
return value / other.value;
}
double operator / (const double& other) const{
return value / other;
}
double operator ++ (){
return ++value;
}
double operator -- (){
return --value;
}
double operator = (const CCDouble& other){
value = other.value;
return value;
}
double operator = (const double& other){
value = other;
return value;
}
double operator -= (const CCDouble& other){
value -= other.value;
return value;
}
double operator -= (const double& other){
value -= other;
return value;
}
double operator += (const CCDouble& other){
value += other.value;
return value;
}
double operator += (const double& other){
value += other;
return value;
}
double operator *= (const CCDouble& other){
value *= other.value;
return value;
}
double operator *= (const double& other) {
value *= other;
return value;
}
double operator /= (const CCDouble& other){
value /= other.value;
return value;
}
double operator /= (const double& other){
value /= other;
return value;
}
};
// CCFloat类用于封装单精度浮点数值
class CCFloat
{
private:
float value; // 存储单精度浮点数值的变量
public:
// 默认构造函数
CCFloat() = default;
// 构造函数，初始化单精度浮点数值
// 参数v: 要封装的单精度浮点数值
CCFloat(const float v){
this->value = v;
}
// 将单精度浮点数值转换为字符串表示
// 参数x: 小数点后的位数，默认为5
// 返回值: 单精度浮点数值的字符串表示
[[nodiscard]] StdString to_String(const int x = 5) const{
std::ostringstream stream;
stream << std::fixed << std::setprecision(x) << value;
return stream.str();
}
// 显式转换为单精度浮点数值
operator float() const{
return value;
}
operator StdString () const{
return std::to_string(value);
}
bool operator == (const CCFloat& other) const{
return value == other.value;
}
bool operator == (const float& other) const{
return value == other;
}
bool operator != (const CCFloat& other) const{
return value != other.value;
}
bool operator != (const float& other) const{
return value != other;
}
bool operator > (const CCFloat& other) const{
return value > other.value;
}
bool operator > (const float& other) const{
return value > other;
}
bool operator < (const CCFloat& other) const{
return value < other.value;
}
bool operator < (const float& other) const{
return value < other;
}
bool operator >= (const CCFloat& other) const{
return value >= other.value;
}
bool operator >= (const float& other) const{
return value >= other;
}
bool operator <= (const CCFloat& other) const{
return value <= other.value;
}
bool operator <= (const float& other) const{
return value <= other;
}
float operator + (const CCFloat& other) const{
return value + other.value;
}
float operator + (const float& other) const{
return value + other;
}
float operator - (const CCFloat& other) const{
return value - other.value;
}
float operator - (const float& other) const{
return value - other;
}
float operator * (const CCFloat& other) const{
return value * other.value;
}
float operator * (const float& other) const{
return value * other;
}
float operator / (const CCFloat& other) const{
return value / other.value;
}
float operator / (const float& other) const{
return value / other;
}
float operator ++ (){
return ++value;
}
float operator -- (){
return --value;
}
float operator = (const CCFloat& other){
value = other.value;
return value;
}
float operator = (const float& other){
value = other;
return value;
}
float operator -= (const CCFloat& other){
value -= other.value;
return value;
}
float operator -= (const float& other){
value -= other;
return value;
}
float operator += (const CCFloat& other){
value += other.value;
return value;
}
float operator += (const float& other){
value += other;
return value;
}
float operator *= (const CCFloat& other){
value *= other.value;
return value;
}
float operator *= (const float& other){
value *= other;
return value;
}
float operator /= (const CCFloat& other){
value /= other.value;
return value;
}
float operator /= (const float& other){
value /= other;
return value;
}
};
// CCSize类用于封装尺寸值（size_t类型）
class CCSize {
size_t value; // 存储尺寸值的变量
public:
// 默认构造函数
CCSize() = default;
// 构造函数，初始化尺寸值
// 参数v: 要封装的尺寸值
CCSize(const size_t v){
this->value = v;
}
// 显式转换为尺寸值
// 返回值: 封装的尺寸值
operator size_t() const{
return value;
}
// 将尺寸值转换为字符串表示
// 返回值: 尺寸值的字符串表示
[[nodiscard]] StdString to_String() const{
return std::to_string(value);
}
operator StdString () const{
return std::to_string(value);
}
bool operator == (const CCSize& other) const{
return value == other.value;
}
bool operator == (const size_t& other) const{
return value == other;
}
bool operator != (const CCSize& other) const{
return value != other.value;
}
bool operator != (const size_t& other) const{
return value != other;
}
bool operator > (const CCSize& other) const{
return value > other.value;
}
bool operator > (const size_t& other) const{
return value > other;
}
bool operator < (const CCSize& other) const{
return value < other.value;
}
bool operator < (const size_t& other) const{
return value < other;
}
bool operator >= (const CCSize& other) const{
return value >= other.value;
}
bool operator >= (const size_t& other) const{
return value >= other;
}
bool operator <= (const CCSize& other) const{
return value <= other.value;
}
bool operator <= (const size_t& other) const{
return value <= other;
}
size_t operator + (const CCSize& other) const{
return value + other.value;
}
size_t operator + (const size_t& other) const{
return value + other;
}
size_t operator - (const CCSize& other) const{
return value - other.value;
}
size_t operator - (const size_t& other) const{
return value - other;
}
size_t operator * (const CCSize& other) const{
return value * other.value;
}
size_t operator * (const size_t& other) const{
return value * other;
}
size_t operator / (const CCSize& other) const{
return value / other.value;
}
size_t operator / (const size_t& other) const{
return value / other;
}
size_t operator ++ (){
return ++value;
}
size_t operator -- (){
return --value;
}
size_t operator = (const CCSize& other){
value = other.value;
return value;
}
size_t operator = (const size_t& other){
value = other;
return value;
}
size_t operator -= (const CCSize& other){
value -= other.value;
return value;
}
size_t operator -= (const size_t& other){
value -= other;
return value;
}
size_t operator += (const CCSize& other){
value += other.value;
return value;
}
size_t operator += (const size_t& other){
value += other;
return value;
}
size_t operator *= (const CCSize& other){
value *= other.value;
return value;
}
size_t operator *= (const size_t& other){
value *= other;
return value;
}
size_t operator /= (const CCSize& other){
value /= other.value;
return value;
}
size_t operator /= (const size_t& other){
value /= other;
return value;
}
};
#if __OHOS__
#pragma warning(pop)
// 或者对于 GCC/Clang
#pragma GCC diagnostic pop
#endif
#endif
inline CCAppInit_ CCAppInit;
Reference in New Issue Copy Permalink