AuroraSupport/AuroraRuntime
2
1
Fork 0
Code Issues 27 Pull Requests Releases Wiki Activity

[*] Exterminate more std:: references

Browse Source
This commit is contained in:
Reece Wilson 2022-01-19 17:08:13 +00:00
parent 7316aa0f8f
commit 7759d38ed0
69 changed files with 476 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Include/Aurora/Async/Async.hpp
View File

@ -126,10 +126,10 @@ namespace Aurora::Async
}; };
#define ASYNC_ERROR(exp) { if constexpr (std::is_same_v<T, bool>) { SysPushErrorGen(exp); return {}; } else { throw std::string(exp); } } #define ASYNC_ERROR(exp) { if constexpr (AuIsSame_v<T, bool>) { SysPushErrorGen(exp); return {}; } else { throw std::string(exp); } }
#define ASYNC_FINISH { if constexpr (std::is_same_v<T, bool>) { return true; } } #define ASYNC_FINISH { if constexpr (AuIsSame_v<T, bool>) { return true; } }
template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<T, bool> || std::is_void<T>::value)> template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || std::is_void<T>::value)>
static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<void(Args...)> func) static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<void(Args...)> func)
{ {
if (!func) return {}; if (!func) return {};
@ -147,14 +147,14 @@ namespace Aurora::Async
} }
/// Async app only /// Async app only
template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<T, bool> || std::is_void<T>::value)> template<typename T = void, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || std::is_void<T>::value)>
static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcher(AuFunction<void(Args...)> func) static AuFunction<T(Args&&...)> TranslateAsyncFunctionToDispatcher(AuFunction<void(Args...)> func)
{ {
return TranslateAsyncFunctionToDispatcherWithThread(GetAsyncApp()->GetCurrentThread(), func); return TranslateAsyncFunctionToDispatcherWithThread(GetAsyncApp()->GetCurrentThread(), func);
} }
/// Async app only /// Async app only
template<typename B = void, typename T, typename... Args, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<T, bool> || std::is_void<T>::value)> template<typename B = void, typename T, typename... Args, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<T, bool> || std::is_void<T>::value)>
static AuFunction<T(AuFunction<void(const B&)>, Args...)> TranslateAsyncReturnableFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<B(Args...)> func) static AuFunction<T(AuFunction<void(const B&)>, Args...)> TranslateAsyncReturnableFunctionToDispatcherWithThread(WorkerId_t id, AuFunction<B(Args...)> func)
{ {
return [=](AuFunction<T(const B&)> callback, Args... in) -> T return [=](AuFunction<T(const B&)> callback, Args... in) -> T

64
Include/Aurora/Async/JobFrom.hpp
View File

@ -32,28 +32,28 @@ namespace Aurora::Async
} }
template<typename Out_t = AVoid, typename ... Args, typename Callable_t> template<typename Out_t = AVoid, typename ... Args, typename Callable_t>
FJob<std::tuple<Args...>, Out_t> JobFromTupleConsumer(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess) FJob<AuTuple<Args...>, Out_t> JobFromTupleConsumer(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess)
{ {
FJob<std::tuple<Args...>, Out_t> ret; FJob<AuTuple<Args...>, Out_t> ret;
static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>); static_assert(AuIsSame_v<AuTuple<Args...>, AuTuple<AuUInt64, AuUInt64>>);
ret.onSuccess = [=](const std::tuple<Args...> &in, const Out_t &a) ret.onSuccess = [=](const AuTuple<Args...> &in, const Out_t &a)
{ {
std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const Out_t &>(a))); std::apply(onSuccess, std::tuple_cat(in, AuMakeTuple<const Out_t &>(a)));
}; };
return ret; return ret;
} }
template<typename Out_t = AVoid, typename ... Args, typename Callable_t, typename FailureCallable_t> template<typename Out_t = AVoid, typename ... Args, typename Callable_t, typename FailureCallable_t>
FJob<std::tuple<Args...>, Out_t> JobFromTupleConsumerEx(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess, FailureCallable_t &&onFailure) FJob<AuTuple<Args...>, Out_t> JobFromTupleConsumerEx(/*AuConsumer<Args..., const Result_t &> */ Callable_t &&onSuccess, FailureCallable_t &&onFailure)
{ {
FJob<std::tuple<Args...>, Out_t> ret; FJob<AuTuple<Args...>, Out_t> ret;
static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>); static_assert(AuIsSame_v<AuTuple<Args...>, AuTuple<AuUInt64, AuUInt64>>);
ret.onSuccess = [=](const std::tuple<Args...> &in, const Out_t &a) ret.onSuccess = [=](const AuTuple<Args...> &in, const Out_t &a)
{ {
std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const Out_t &>(a))); std::apply(onSuccess, std::tuple_cat(in, AuMakeTuple<const Out_t &>(a)));
}; };
ret.onFailure = [=](const std::tuple<Args...> &in) ret.onFailure = [=](const AuTuple<Args...> &in)
{ {
std::apply(onFailure, in); std::apply(onFailure, in);
}; };
@ -112,10 +112,10 @@ namespace Aurora::Async
} }
template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args> template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args>
static inline FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess) static inline FJob<AuTuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess)
{ {
FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> ret; FJob<AuTuple<Arg0_t, Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<Arg0_t, Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<Arg0_t, Args...> &in, const ReturnValue_t &out)
{ {
onSuccess(std::get<0>(in), out); onSuccess(std::get<0>(in), out);
}; };
@ -123,15 +123,15 @@ namespace Aurora::Async
} }
template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args> template<typename ReturnValue_t = void, typename Arg0_t, typename ... Args>
static inline FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazzEx(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess, const AuConsumer<const Arg0_t &> &onFailure) static inline FJob<AuTuple<Arg0_t, Args...>, ReturnValue_t> JobFromTupleClazzEx(const AuConsumer<const Arg0_t &, const ReturnValue_t &> &onSuccess, const AuConsumer<const Arg0_t &> &onFailure)
{ {
FJob<std::tuple<Arg0_t, Args...>, ReturnValue_t> ret; FJob<AuTuple<Arg0_t, Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<Arg0_t, Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<Arg0_t, Args...> &in, const ReturnValue_t &out)
{ {
onSuccess(std::get<0>(in), out); onSuccess(std::get<0>(in), out);
}; };
ret.onFailure = [=](const std::tuple<Arg0_t, Args...> &in) ret.onFailure = [=](const AuTuple<Arg0_t, Args...> &in)
{ {
onFailure(std::get<0>(in)); onFailure(std::get<0>(in));
}; };
@ -140,10 +140,10 @@ namespace Aurora::Async
#if 0 #if 0
template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args> template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args>
static inline FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const ReturnValue_t &> &onSuccess) static inline FJob<AuTuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<const ReturnValue_t &> &onSuccess)
{ {
FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret; FJob<AuTuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out)
{ {
onSuccess(out); onSuccess(out);
}; };
@ -151,22 +151,22 @@ namespace Aurora::Async
} }
template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args> template<typename ReturnValue_t = void, typename Clazz_t, typename ... Args>
static inline FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess) static inline FJob<AuTuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> JobFromTupleClazz(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess)
{ {
FJob<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret; FJob<AuTuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<AuSPtr<Clazz_t>, Args...> &in, const ReturnValue_t &out)
{ {
std::apply(onSuccess, std::tuple_cat(AuTuplePopFront(in), std::make_tuple<const ReturnValue_t &>(out))); std::apply(onSuccess, std::tuple_cat(AuTuplePopFront(in), AuMakeTuple<const ReturnValue_t &>(out)));
}; };
return ret; return ret;
} }
#endif #endif
template<typename ReturnValue_t = void, typename ... Args> template<typename ReturnValue_t = void, typename ... Args>
static inline FJob<std::tuple<Args...>, ReturnValue_t> JobFromTupleResultConsumer(const AuConsumer<const ReturnValue_t &> &onSuccess) static inline FJob<AuTuple<Args...>, ReturnValue_t> JobFromTupleResultConsumer(const AuConsumer<const ReturnValue_t &> &onSuccess)
{ {
FJob<std::tuple<Args...>, ReturnValue_t> ret; FJob<AuTuple<Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<Args...> &in, const ReturnValue_t &out)
{ {
onSuccess(out); onSuccess(out);
}; };
@ -174,12 +174,12 @@ namespace Aurora::Async
} }
template<typename ReturnValue_t = void, typename ... Args> template<typename ReturnValue_t = void, typename ... Args>
static inline FJob<std::tuple<Args...>, ReturnValue_t> JobFromTuple(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess) static inline FJob<AuTuple<Args...>, ReturnValue_t> JobFromTuple(const AuConsumer<Args..., const ReturnValue_t &> &onSuccess)
{ {
FJob<std::tuple<Args...>, ReturnValue_t> ret; FJob<AuTuple<Args...>, ReturnValue_t> ret;
ret.onSuccess = [=](const std::tuple<Args...> &in, const ReturnValue_t &out) ret.onSuccess = [=](const AuTuple<Args...> &in, const ReturnValue_t &out)
{ {
std::apply(onSuccess, std::tuple_cat(in, std::make_tuple<const ReturnValue_t &>(out))); std::apply(onSuccess, std::tuple_cat(in, AuMakeTuple<const ReturnValue_t &>(out)));
}; };
return ret; return ret;
} }

18
Include/Aurora/Async/TaskFrom.hpp
View File

@ -15,7 +15,7 @@ namespace Aurora::Async
FTask<Info_t, Out_t> ret; FTask<Info_t, Out_t> ret;
ret.onFrame = [callable = func](const Info_t &in) -> Out_t ret.onFrame = [callable = func](const Info_t &in) -> Out_t
{ {
if constexpr (std::is_same_v<Out_t, AVoid>) if constexpr (AuIsSame_v<Out_t, AVoid>)
{ {
callable(in); callable(in);
return {}; return {};
@ -29,11 +29,11 @@ namespace Aurora::Async
} }
template<typename Out_t = AVoid, typename ... Args, typename Functor> template<typename Out_t = AVoid, typename ... Args, typename Functor>
FTask<std::tuple<Args...>, Out_t> TaskFromTupleCallable(Functor &&func) FTask<AuTuple<Args...>, Out_t> TaskFromTupleCallable(Functor &&func)
{ {
FTask<std::tuple<Args...>, Out_t> ret; FTask<AuTuple<Args...>, Out_t> ret;
static_assert(std::is_same_v<std::tuple<Args...>, std::tuple<AuUInt64, AuUInt64>>); static_assert(AuIsSame_v<AuTuple<Args...>, AuTuple<AuUInt64, AuUInt64>>);
ret.onFrame = [callable = func](const std::tuple<Args...> &in) -> Out_t ret.onFrame = [callable = func](const AuTuple<Args...> &in) -> Out_t
{ {
return std::apply(callable, in); return std::apply(callable, in);
}; };
@ -41,12 +41,12 @@ namespace Aurora::Async
} }
template<typename Out_t = AVoid, typename Owner_t, typename ... Args> template<typename Out_t = AVoid, typename Owner_t, typename ... Args>
FTask<std::tuple<Args...>, Out_t> TaskFromTupleCallableWithOwnerArg(AuFunction<Out_t(Args...)> &&func, const Owner_t &ownerToPin) FTask<AuTuple<Args...>, Out_t> TaskFromTupleCallableWithOwnerArg(AuFunction<Out_t(Args...)> &&func, const Owner_t &ownerToPin)
{ {
FTask<std::tuple<Owner_t, Args...>, Out_t> ret; FTask<AuTuple<Owner_t, Args...>, Out_t> ret;
ret.onFrame = [callable = func](const std::tuple<Args...> &in) -> Out_t ret.onFrame = [callable = func](const AuTuple<Args...> &in) -> Out_t
{ {
return std::apply(callable, std::tuple_cat(std::make_tuple<Owner_t>(ownerToPin), in)); return std::apply(callable, AuTuple_cat(AuMakeTuple<Owner_t>(ownerToPin), in));
}; };
return ret; return ret;
} }

32
Include/Aurora/Async/WorkBasic.hpp
View File

@ -12,43 +12,43 @@ namespace Aurora::Async
/// --- THREAD POOL -- /// --- THREAD POOL --
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false) static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false)
{ {
return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait); return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false) static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch(); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false) static AuSPtr<IWorkItem> NewWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)
{ {
return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait); return worker.pool->NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false) static AuSPtr<IWorkItem> DispatchWork(const WorkerPId_tt &worker, a task, b job, c info, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch(); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
AuSPtr<IWorkItem> DispatchFunctional(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchFunctional(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
AuSPtr<IWorkItem> DispatchFunctor(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchFunctor(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerPId_tt, WorkerPId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerPId_tt = WorkerPId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerPId_tt, WorkerPId_t>)>
AuSPtr<IWorkItem> DispatchVoid(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchVoid(const WorkerPId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait);
@ -57,43 +57,43 @@ namespace Aurora::Async
/// --- ASYNC APP -- /// --- ASYNC APP --
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false) static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false)
{ {
return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait); return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job), enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a = const Job_t &, class b = Task_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false) static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch(); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, enableWait)->Dispatch();
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false) static AuSPtr<IWorkItem> NewWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)
{ {
return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait); return NewWorkItem(worker, AuMakeShared<WorkPairImpl<Info_t, Result_t, Task_t>>(task, job, info), enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, class a, class b = Job_t, class c, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false) static AuSPtr<IWorkItem> DispatchWork(const WorkerId_tt &worker, a task, b job, c info, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch(); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, task, job, info, enableWait)->Dispatch();
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
AuSPtr<IWorkItem> DispatchFunctional(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchFunctional(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
AuSPtr<IWorkItem> DispatchFunctor(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchFunctor(const WorkerId_tt &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromConsumerRefT<Info_t, Result_t>(task), job, inputParameters, enableWait);
} }
template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(std::is_same_v<WorkerId_tt, WorkerId_t>)> template<typename Info_t = AVoid, typename Result_t = AVoid, typename Task_t = FTask<Info_t, Result_t>, typename Job_t = FJob<Info_t, Result_t>, typename ClazzImpl, class a = const Job_t &, class b = const Info_t &, class WorkerId_tt = WorkerId_t, AU_TEMPLATE_ENABLE_WHEN(AuIsSame_v<WorkerId_tt, WorkerId_t>)>
AuSPtr<IWorkItem> DispatchVoid(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false) AuSPtr<IWorkItem> DispatchVoid(const WorkerId_t &worker, ClazzImpl task, a job, b inputParameters, bool enableWait = false)
{ {
return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait); return NewWork<Info_t, Result_t, Task_t, Job_t>(worker, TaskFromVoidVoid<Info_t, Result_t>(task), job, inputParameters, enableWait);
@ -105,7 +105,7 @@ namespace Aurora::Async
return DispatchWork<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>(worker, return DispatchWork<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>(worker,
TaskFromTupleCallableWithBindOwner2<FTask<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>, ReturnValue_t, FunctorTask_t>(task), TaskFromTupleCallableWithBindOwner2<FTask<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>, ReturnValue_t, FunctorTask_t>(task),
Async::JobFromTupleClazz<ReturnValue_t, AuSPtr<Clazz_t>, Args...>(job), Async::JobFromTupleClazz<ReturnValue_t, AuSPtr<Clazz_t>, Args...>(job),
std::make_tuple<AuSPtr<Clazz_t>, Args...>(AU_FWD(owner), std::forward<Args>(in)...), AuMakeTuple<AuSPtr<Clazz_t>, Args...>(AU_FWD(owner), std::forward<Args>(in)...),
false); false);
} }
@ -115,7 +115,7 @@ namespace Aurora::Async
return DispatchWork<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>(worker, return DispatchWork<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>(worker,
TaskFromTupleCallableWithBindOwner2<FTask<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>, ReturnValue_t, FunctorTask_t>(task), TaskFromTupleCallableWithBindOwner2<FTask<std::tuple<AuSPtr<Clazz_t>, Args...>, ReturnValue_t>, ReturnValue_t, FunctorTask_t>(task),
Async::JobFromTupleClazzEx<ReturnValue_t, AuSPtr<Clazz_t>, Args...>(success, failure), Async::JobFromTupleClazzEx<ReturnValue_t, AuSPtr<Clazz_t>, Args...>(success, failure),
std::make_tuple<AuSPtr<Clazz_t>, Args...>(AU_FWD(owner), std::forward<Args>(in)...), AuMakeTuple<AuSPtr<Clazz_t>, Args...>(AU_FWD(owner), std::forward<Args>(in)...),
false); false);
} }
} }

4
Include/Aurora/Async/WorkPairImpl.hpp
View File

@ -80,8 +80,8 @@ namespace Aurora::Async
private: private:
static constexpr bool IsCallbackPtr = std::is_pointer_v<Job_t> || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Job_t>::value || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Job_t>::value; static constexpr bool IsCallbackPtr = AuIsPointer_v<Job_t> || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Job_t>::value || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Job_t>::value;
static constexpr bool IsTaskPtr = std::is_pointer_v<Task_t> || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Task_t>::value || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Task_t>::value; static constexpr bool IsTaskPtr = AuIsPointer_v<Task_t> || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_SHARED_PTR, Task_t>::value || AuIsBaseOfTemplate<AURORA_RUNTIME_AU_UNIQUE_PTR, Task_t>::value;
//WorkerId_t caller; //WorkerId_t caller;
WorkerPId_t caller_; WorkerPId_t caller_;

6
Include/Aurora/Compression/StreamPipeProcessor.hpp
View File

@ -17,13 +17,13 @@ namespace Aurora::Compression
AuUInt32 threads; AuUInt32 threads;
/// consume from stream callback /// consume from stream callback
std::function<AuUInt(void *, AuUInt)> inPipe; AuFunction<AuUInt(void *, AuUInt)> inPipe;
/// write to stream callback /// write to stream callback
std::function<void(const void *, AuUInt)> writePipe; AuFunction<void(const void *, AuUInt)> writePipe;
/// preemption and reporting /// preemption and reporting
std::function<bool(AuUInt, AuUInt)> reportProgress; AuFunction<bool(AuUInt, AuUInt)> reportProgress;
}; };
AUKN_SYM bool Decompress(const CompressionPipe &stream, const DecompressInfo &meta); AUKN_SYM bool Decompress(const CompressionPipe &stream, const DecompressInfo &meta);

30
Include/Aurora/Hashing/Digests.hpp
View File

@ -9,52 +9,52 @@
namespace Aurora::Hashing namespace Aurora::Hashing
{ {
AUKN_SYM void MD5(const void *buffer, AuMach length, std::array<AuUInt8, 16> &md5); AUKN_SYM void MD5(const void *buffer, AuMach length, AuArray<AuUInt8, 16> &md5);
static void MD5(const AuList<AuUInt8> &bytebuffer, std::array<AuUInt8, 16> &md5) static void MD5(const AuList<AuUInt8> &bytebuffer, AuArray<AuUInt8, 16> &md5)
{ {
return MD5(bytebuffer.data(), bytebuffer.size(), md5); return MD5(bytebuffer.data(), bytebuffer.size(), md5);
} }
static void MD5(const AuString &bytebuffer, std::array<AuUInt8, 16> &md5) static void MD5(const AuString &bytebuffer, AuArray<AuUInt8, 16> &md5)
{ {
return MD5(bytebuffer.data(), bytebuffer.size(), md5); return MD5(bytebuffer.data(), bytebuffer.size(), md5);
} }
AUKN_SYM void SHA1(const void *buffer, AuMach length, std::array<AuUInt8, 20> &sha1); AUKN_SYM void SHA1(const void *buffer, AuMach length, AuArray<AuUInt8, 20> &sha1);
static void SHA1(const AuList<AuUInt8> &bytebuffer, std::array<AuUInt8, 20> &sha1) static void SHA1(const AuList<AuUInt8> &bytebuffer, AuArray<AuUInt8, 20> &sha1)
{ {
return SHA1(bytebuffer.data(), bytebuffer.size(), sha1); return SHA1(bytebuffer.data(), bytebuffer.size(), sha1);
} }
static void SHA1(const AuString &bytebuffer, std::array<AuUInt8, 20> &sha1) static void SHA1(const AuString &bytebuffer, AuArray<AuUInt8, 20> &sha1)
{ {
return SHA1(bytebuffer.data(), bytebuffer.size(), sha1); return SHA1(bytebuffer.data(), bytebuffer.size(), sha1);
} }
AUKN_SYM void Tiger(const void *buffer, AuMach length, std::array<AuUInt8, 24> &tiger); AUKN_SYM void Tiger(const void *buffer, AuMach length, AuArray<AuUInt8, 24> &tiger);
static void Tiger(const AuList<AuUInt8> &bytebuffer, std::array<AuUInt8, 24> &tiger) static void Tiger(const AuList<AuUInt8> &bytebuffer, AuArray<AuUInt8, 24> &tiger)
{ {
return Tiger(bytebuffer.data(), bytebuffer.size(), tiger); return Tiger(bytebuffer.data(), bytebuffer.size(), tiger);
} }
static void Tiger(const AuString &bytebuffer, std::array<AuUInt8, 24> &tiger) static void Tiger(const AuString &bytebuffer, AuArray<AuUInt8, 24> &tiger)
{ {
return Tiger(bytebuffer.data(), bytebuffer.size(), tiger); return Tiger(bytebuffer.data(), bytebuffer.size(), tiger);
} }
AUKN_SYM void SHA2(const void *buffer, AuMach length, std::array<AuUInt8, 32> &sha2); AUKN_SYM void SHA2(const void *buffer, AuMach length, AuArray<AuUInt8, 32> &sha2);
static void SHA2(const AuList<AuUInt8> &bytebuffer, std::array<AuUInt8, 32> &sha2) static void SHA2(const AuList<AuUInt8> &bytebuffer, AuArray<AuUInt8, 32> &sha2)
{ {
return SHA2(bytebuffer.data(), bytebuffer.size(), sha2); return SHA2(bytebuffer.data(), bytebuffer.size(), sha2);
} }
static void SHA2(const AuString &bytebuffer, std::array<AuUInt8, 32> &sha2) static void SHA2(const AuString &bytebuffer, AuArray<AuUInt8, 32> &sha2)
{ {
return SHA2(bytebuffer.data(), bytebuffer.size(), sha2); return SHA2(bytebuffer.data(), bytebuffer.size(), sha2);
} }
AUKN_SYM void SHA2_64(const void *buffer, AuMach length, std::array<AuUInt8, 64> &sha2); AUKN_SYM void SHA2_64(const void *buffer, AuMach length, AuArray<AuUInt8, 64> &sha2);
static void SHA2_64(const AuList<AuUInt8> &bytebuffer, std::array<AuUInt8, 64> &sha2) static void SHA2_64(const AuList<AuUInt8> &bytebuffer, AuArray<AuUInt8, 64> &sha2)
{ {
return SHA2_64(bytebuffer.data(), bytebuffer.size(), sha2); return SHA2_64(bytebuffer.data(), bytebuffer.size(), sha2);
} }
static void SHA2_64(const AuString &bytebuffer, std::array<AuUInt8, 64> &sha2) static void SHA2_64(const AuString &bytebuffer, AuArray<AuUInt8, 64> &sha2)
{ {
return SHA2_64(bytebuffer.data(), bytebuffer.size(), sha2); return SHA2_64(bytebuffer.data(), bytebuffer.size(), sha2);
} }

4
Include/Aurora/IO/Buffered/BlobArbitraryReader.hpp
View File

@ -28,13 +28,13 @@ namespace Aurora::IO::Buffered
if (buffer_.empty()) return EStreamError::eErrorEndOfStream; if (buffer_.empty()) return EStreamError::eErrorEndOfStream;
auto endOffset = offset + paramters.length; auto endOffset = offset + paramters.length;
auto realEndOffset = std::min(buffer_.size(), endOffset); auto realEndOffset = AuMin(buffer_.size(), endOffset);
auto actualLength = realEndOffset - offset; auto actualLength = realEndOffset - offset;
if (actualLength < 0) return EStreamError::eErrorEndOfStream; if (actualLength < 0) return EStreamError::eErrorEndOfStream;
paramters.outVariable = actualLength; paramters.outVariable = actualLength;
std::memcpy(paramters.ptr, buffer_.data() + offset, paramters.outVariable); AuMemcpy(paramters.ptr, buffer_.data() + offset, paramters.outVariable);
return EStreamError::eErrorNone; return EStreamError::eErrorNone;
} }

4
Include/Aurora/IO/Buffered/BlobReader.hpp
View File

@ -25,11 +25,11 @@ namespace Aurora::IO::Buffered
virtual EStreamError Read(const Memory::MemoryViewStreamWrite &paramters) override virtual EStreamError Read(const Memory::MemoryViewStreamWrite &paramters) override
{ {
auto realEndOffset = std::min(buffer_.size() - offset_, paramters.length); auto realEndOffset = AuMin(buffer_.size() - offset_, paramters.length);
if (realEndOffset == 0) return EStreamError::eErrorEndOfStream; if (realEndOffset == 0) return EStreamError::eErrorEndOfStream;
paramters.outVariable = realEndOffset; paramters.outVariable = realEndOffset;
std::memcpy(paramters.ptr, buffer_.data() + offset_, realEndOffset); AuMemcpy(paramters.ptr, buffer_.data() + offset_, realEndOffset);
offset_ += realEndOffset; offset_ += realEndOffset;
return EStreamError::eErrorNone; return EStreamError::eErrorNone;

2
Include/Aurora/IO/Buffered/BlobWriter.hpp
View File

@ -26,7 +26,7 @@ namespace Aurora::IO::Buffered
{ {
auto idx = buffer_.size(); auto idx = buffer_.size();
buffer_.resize(idx + parameters.length); buffer_.resize(idx + parameters.length);
std::memcpy(buffer_.data() + idx, parameters.ptr, buffer_.size() - idx); AuMemcpy(buffer_.data() + idx, parameters.ptr, buffer_.size() - idx);
return EStreamError::eErrorNone; return EStreamError::eErrorNone;
} }

6
Include/Aurora/Memory/ByteBuffer.hpp
View File

@ -108,7 +108,7 @@ namespace Aurora::Memory
this->writePtr = this->base; this->writePtr = this->base;
this->readPtr = this->base; this->readPtr = this->base;
} }
std::memcpy(this->base, buffer.base, this->length); AuMemcpy(this->base, buffer.base, this->length);
this->flagCircular = buffer.flagCircular; this->flagCircular = buffer.flagCircular;
this->flagExpandable = buffer.flagExpandable; this->flagExpandable = buffer.flagExpandable;
this->scaleSize = buffer.scaleSize; this->scaleSize = buffer.scaleSize;
@ -122,7 +122,7 @@ namespace Aurora::Memory
this->allocSize = length; this->allocSize = length;
this->readPtr = this->base; this->readPtr = this->base;
this->writePtr = this->readPtr + this->length; this->writePtr = this->readPtr + this->length;
std::memcpy(this->base, in, this->length); AuMemcpy(this->base, in, this->length);
this->scaleSize = kBufferInitialPower; this->scaleSize = kBufferInitialPower;
} }
@ -134,7 +134,7 @@ namespace Aurora::Memory
this->allocSize = vector.size(); this->allocSize = vector.size();
this->readPtr = this->base; this->readPtr = this->base;
this->writePtr = this->readPtr + this->length; this->writePtr = this->readPtr + this->length;
std::memcpy(this->base, vector.data(), this->length); AuMemcpy(this->base, vector.data(), this->length);
this->scaleSize = kBufferInitialPower; this->scaleSize = kBufferInitialPower;
} }

8
Include/Aurora/Memory/ByteBuffer_Memory.inl
View File

@ -35,7 +35,7 @@ namespace Aurora::Memory
return false; return false;
} }
std::memcpy(this->base, in, this->length); AuMemcpy(this->base, in, this->length);
return true; return true;
} }
@ -75,7 +75,7 @@ namespace Aurora::Memory
{ {
auto scale = GetAllocationPower(); auto scale = GetAllocationPower();
oldLength = this->length; oldLength = this->length;
newLength = std::max(AuUInt(length), AuUInt(((this->allocSize / scale) + 1) * scale)); newLength = AuMax(AuUInt(length), AuUInt(((this->allocSize / scale) + 1) * scale));
nextPtr = ZRealloc(this->base, newLength); nextPtr = ZRealloc(this->base, newLength);
if (!nextPtr) if (!nextPtr)
@ -109,9 +109,9 @@ namespace Aurora::Memory
else else
{ {
auto expansion = newLength - oldLength; auto expansion = newLength - oldLength;
auto movableTail = std::min(oldWriteIdx, expansion); auto movableTail = AuMin(oldWriteIdx, expansion);
std::memcpy(nextPtr + oldLength, nextPtr, movableTail); AuMemcpy(nextPtr + oldLength, nextPtr, movableTail);
this->readPtr = nextRead; this->readPtr = nextRead;
this->writePtr = nextPtr + oldLength + movableTail; this->writePtr = nextPtr + oldLength + movableTail;

26
Include/Aurora/Memory/ByteBuffer_ReadWrite.inl
View File

@ -33,14 +33,14 @@ namespace Aurora::Memory
toReadOverhead = readPtr - base; toReadOverhead = readPtr - base;
} }
writable = std::min(linearOverhead + toReadOverhead, requestLength); writable = AuMin(linearOverhead + toReadOverhead, requestLength);
linearWritable = std::min(linearOverhead, requestLength); linearWritable = AuMin(linearOverhead, requestLength);
toReadWritable = writable - linearWritable; toReadWritable = writable - linearWritable;
if (cptr) if (cptr)
{ {
std::memcpy(writePtr, cptr, linearWritable); AuMemcpy(writePtr, cptr, linearWritable);
} }
writePtr += linearWritable; writePtr += linearWritable;
@ -49,7 +49,7 @@ namespace Aurora::Memory
writePtr = base; writePtr = base;
if (cptr) if (cptr)
{ {
std::memcpy(writePtr, cptr + linearOverhead, toReadWritable); AuMemcpy(writePtr, cptr + linearOverhead, toReadWritable);
} }
writePtr += toReadWritable; writePtr += toReadWritable;
} }
@ -68,7 +68,7 @@ namespace Aurora::Memory
auto offset = writePtr - base; auto offset = writePtr - base;
auto overhead = length - offset; auto overhead = length - offset;
AuUInt len = std::min(overhead, requestLength); AuUInt len = AuMin(overhead, requestLength);
if ((len != requestLength) && (flagExpandable)) if ((len != requestLength) && (flagExpandable))
{ {
@ -78,12 +78,12 @@ namespace Aurora::Memory
} }
overhead = length - offset; overhead = length - offset;
len = std::min(overhead, requestLength); len = AuMin(overhead, requestLength);
} }
if (buffer) if (buffer)
{ {
std::memcpy(writePtr, buffer, len); AuMemcpy(writePtr, buffer, len);
} }
writePtr += len; writePtr += len;
@ -108,14 +108,14 @@ namespace Aurora::Memory
toWriteOverhead = writePtr - base; toWriteOverhead = writePtr - base;
} }
auto readable = std::min(linearOverhead + toWriteOverhead, requestedLength); auto readable = AuMin(linearOverhead + toWriteOverhead, requestedLength);
linearReadable = std::min(linearOverhead, requestedLength); linearReadable = AuMin(linearOverhead, requestedLength);
toWriteReadable = readable - linearReadable; toWriteReadable = readable - linearReadable;
if (out) if (out)
{ {
std::memcpy(out, readPtr, linearOverhead); AuMemcpy(out, readPtr, linearOverhead);
} }
if (!peek) if (!peek)
@ -125,7 +125,7 @@ namespace Aurora::Memory
if (toWriteOverhead) if (toWriteOverhead)
{ {
std::memcpy(reinterpret_cast<AuUInt8 *>(out) + linearOverhead, base, toWriteReadable); AuMemcpy(reinterpret_cast<AuUInt8 *>(out) + linearOverhead, base, toWriteReadable);
if (!peek) if (!peek)
{ {
@ -144,11 +144,11 @@ namespace Aurora::Memory
} }
else else
{ {
AuUInt len = std::min(AuUInt(writePtr - readPtr), requestedLength); AuUInt len = AuMin(AuUInt(writePtr - readPtr), requestedLength);
if (out) if (out)
{ {
std::memcpy(out, readPtr, len); AuMemcpy(out, readPtr, len);
} }
if (!peek) if (!peek)

8
Include/Aurora/Memory/ByteBuffer_TypedReadWrite.inl
View File

@ -12,7 +12,7 @@ namespace Aurora::Memory
template<typename T> template<typename T>
bool ByteBuffer::Read(T &out) bool ByteBuffer::Read(T &out)
{ {
if constexpr (std::is_class_v<T>) if constexpr (AuIsClass_v<T>)
{ {
if constexpr (AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, std::remove_reference_t<T>>::value) if constexpr (AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, std::remove_reference_t<T>>::value)
{ {
@ -32,7 +32,7 @@ namespace Aurora::Memory
return !this->flagReadError; return !this->flagReadError;
} }
else if constexpr (std::is_same_v<std::remove_reference_t<T>, AuString>) else if constexpr (AuIsSame_v<std::remove_reference_t<T>, AuString>)
{ {
out.resize(Read<AuUInt32>()); out.resize(Read<AuUInt32>());
Read(out.data(), out.size()); Read(out.data(), out.size());
@ -60,7 +60,7 @@ namespace Aurora::Memory
template<typename T> template<typename T>
bool ByteBuffer::Write(const T &in) bool ByteBuffer::Write(const T &in)
{ {
if constexpr (std::is_class_v<T>) if constexpr (AuIsClass_v<T>)
{ {
if constexpr (AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, std::remove_reference_t<T>>::value) if constexpr (AuIsBaseOfTemplate<AURORA_RUNTIME_AU_LIST, std::remove_reference_t<T>>::value)
{ {
@ -74,7 +74,7 @@ namespace Aurora::Memory
return !this->flagWriteError; return !this->flagWriteError;
} }
else if constexpr (std::is_same_v<std::remove_reference_t<T>, AuString>) else if constexpr (AuIsSame_v<std::remove_reference_t<T>, AuString>)
{ {
Write<AuUInt32>(AuUInt32(in.size())); Write<AuUInt32>(AuUInt32(in.size()));
Write(in.data(), in.size()); Write(in.data(), in.size());

10
Include/Aurora/Memory/ByteBuffer_Utils.inl
View File

@ -19,7 +19,7 @@ namespace Aurora::Memory
} }
else else
{ {
std::memcpy(vec.data(), base, length); AuMemcpy(vec.data(), base, length);
} }
return vec; return vec;
} }
@ -62,7 +62,7 @@ namespace Aurora::Memory
auto len = length - (writePtr - readPtr); auto len = length - (writePtr - readPtr);
vec.resize(len); vec.resize(len);
std::memcpy(vec.data(), readPtr, len); AuMemcpy(vec.data(), readPtr, len);
} }
else else
{ {
@ -70,8 +70,8 @@ namespace Aurora::Memory
auto toWriteOverhead = endAtWrite ? (writePtr - base) : (readPtr - base); auto toWriteOverhead = endAtWrite ? (writePtr - base) : (readPtr - base);
vec.resize(linearOverhead + toWriteOverhead); vec.resize(linearOverhead + toWriteOverhead);
std::memcpy(vec.data(), readPtr, linearOverhead); AuMemcpy(vec.data(), readPtr, linearOverhead);
std::memcpy(vec.data() + linearOverhead, base, linearOverhead); AuMemcpy(vec.data() + linearOverhead, base, linearOverhead);
} }
} }
else else
@ -87,7 +87,7 @@ namespace Aurora::Memory
} }
vec.resize(len); vec.resize(len);
std::memcpy(vec.data(), readPtr, len); AuMemcpy(vec.data(), readPtr, len);
} }
return vec; return vec;

2
Include/Aurora/Memory/Heap.hpp
View File

@ -106,7 +106,7 @@ namespace Aurora::Memory
return std::shared_ptr<T>(in, return std::shared_ptr<T>(in,
[heapHandle, in, this](T *delt) [heapHandle, in, this](T *delt)
{ {
if constexpr (std::is_class_v<T>) if constexpr (AuIsClass_v<T>)
{ {
delt->~T(); delt->~T();
} }

14
Include/Aurora/Memory/Memory.hpp
View File

@ -38,35 +38,35 @@ namespace Aurora::Memory
template<typename T> template<typename T>
T ZAlloc(Types::size_t length) T ZAlloc(Types::size_t length)
{ {
static_assert(!std::is_class<typename std::remove_pointer<T>::type>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<typename std::remove_pointer<T>::type>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T>(_ZAlloc(length)); return reinterpret_cast<T>(_ZAlloc(length));
} }
template<typename T> template<typename T>
T ZAlloc(Types::size_t length, Types::size_t align) T ZAlloc(Types::size_t length, Types::size_t align)
{ {
static_assert(!std::is_class<typename std::remove_pointer<T>::type>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<typename std::remove_pointer<T>::type>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T>(_ZAlloc(length, align)); return reinterpret_cast<T>(_ZAlloc(length, align));
} }
template<typename T> template<typename T>
T *NewArray(Types::size_t count) T *NewArray(Types::size_t count)
{ {
static_assert(!std::is_class<T>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<T>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T *>(_FAlloc(count * sizeof(T))); return reinterpret_cast<T *>(_FAlloc(count * sizeof(T)));
} }
template<typename T> template<typename T>
T *NewArray(Types::size_t count, Types::size_t align) T *NewArray(Types::size_t count, Types::size_t align)
{ {
static_assert(!std::is_class<T>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<T>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T *>(_FAlloc(count * sizeof(T)), align); return reinterpret_cast<T *>(_FAlloc(count * sizeof(T)), align);
} }
template<typename T> template<typename T>
AuSPtr<T> AllocateFastArray(Types::size_t length, Types::size_t align = sizeof(T)) AuSPtr<T> AllocateFastArray(Types::size_t length, Types::size_t align = sizeof(T))
{ {
static_assert(!std::is_class<typename std::remove_pointer<T>::type>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<typename std::remove_pointer<T>::type>, "Do not use heap/kmem apis with classes");
return AuSPtr<T>(reinterpret_cast<T *>(_FAlloc(length)), [](T *ptr) return AuSPtr<T>(reinterpret_cast<T *>(_FAlloc(length)), [](T *ptr)
{ {
_Free(ptr); _Free(ptr);
@ -102,14 +102,14 @@ namespace Aurora::Memory
template<typename T> template<typename T>
T FAlloc(Types::size_t length) T FAlloc(Types::size_t length)
{ {
static_assert(!std::is_class<typename std::remove_pointer<T>::type>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<typename std::remove_pointer<T>::type>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T>(_FAlloc(length)); return reinterpret_cast<T>(_FAlloc(length));
} }
template<typename T> template<typename T>
T FAlloc(Types::size_t length, Types::size_t align) T FAlloc(Types::size_t length, Types::size_t align)
{ {
static_assert(!std::is_class<typename std::remove_pointer<T>::type>::value, "Do not use heap/kmem apis with classes"); static_assert(!AuIsClass_v<typename std::remove_pointer<T>::type>, "Do not use heap/kmem apis with classes");
return reinterpret_cast<T>(_FAlloc(length, align)); return reinterpret_cast<T>(_FAlloc(length, align));
} }

4
Include/Aurora/Memory/MemoryView.hpp
View File

@ -15,7 +15,7 @@ namespace Aurora::Memory
using Void_t = std::conditional_t<Readonly_b, const void *, void *>; using Void_t = std::conditional_t<Readonly_b, const void *, void *>;
template<typename T, int Z> template<typename T, int Z>
using StdArray_t = std::conditional_t<Readonly_b, const std::array<T, Z>, std::array<T, Z>>; using StdArray_t = std::conditional_t<Readonly_b, const AuArray<T, Z>, AuArray<T, Z>>;
/* /*
YadaYada(MemoryView(tempstring/array/etc)) should be legal, right? YadaYada(MemoryView(tempstring/array/etc)) should be legal, right?
@ -59,7 +59,7 @@ namespace Aurora::Memory
constexpr MemoryView(T *start, T *end) constexpr MemoryView(T *start, T *end)
{ {
this->ptr = start; this->ptr = start;
if constexpr (std::is_same_v<T, Void_t>) if constexpr (AuIsSame_v<T, Void_t>)
{ {
this->length = reinterpret_cast<const AuUInt8 *>(end) - reinterpret_cast<const AuUInt8 *>(start); this->length = reinterpret_cast<const AuUInt8 *>(end) - reinterpret_cast<const AuUInt8 *>(start);
} }

8
Include/Aurora/Parse/LineParser.hpp
View File

@ -9,7 +9,7 @@
namespace Aurora::Parse namespace Aurora::Parse
{ {
static AuString SplitNewlines(const AuString &in, std::function<void(const AuString &)> lineCallback, bool returnRemaining) static AuString SplitNewlines(const AuString &in, AuFunction<void(const AuString &)> lineCallback, bool returnRemaining)
{ {
AuMach index = 0, startIdx = 0; AuMach index = 0, startIdx = 0;
@ -42,7 +42,7 @@ namespace Aurora::Parse
} }
} }
static void SplitNewlines(const AuString &in, std::function<void(const AuString &)> lineCallback) static void SplitNewlines(const AuString &in, AuFunction<void(const AuString &)> lineCallback)
{ {
SplitNewlines(in, lineCallback, false); SplitNewlines(in, lineCallback, false);
} }
@ -53,7 +53,7 @@ namespace Aurora::Parse
for (auto i = 0u; i < in.size(); i += characters) for (auto i = 0u; i < in.size(); i += characters)
{ {
auto start = i; auto start = i;
auto end = std::min(AuUInt32(in.size()), AuUInt32(i + characters)); auto end = AuMin(AuUInt32(in.size()), AuUInt32(i + characters));
auto len = end - start; auto len = end - start;
ret.push_back(in.substr(start, len)); ret.push_back(in.substr(start, len));
} }
@ -74,7 +74,7 @@ namespace Aurora::Parse
} }
start = i; start = i;
end = std::min(AuUInt32(in.size()), AuUInt32(i + characters)); end = AuMin(AuUInt32(in.size()), AuUInt32(i + characters));
len = end - start; len = end - start;
ret.insert(ret.size(), in.substr(start, len)); ret.insert(ret.size(), in.substr(start, len));

2
Include/Aurora/Parse/Parser.hpp
View File

@ -112,7 +112,7 @@ namespace Aurora::Parse
ParsedObject result; ParsedObject result;
}; };
using ConsumeStream_cb = std::function<bool(AuUInt8 &)>; using ConsumeStream_cb = AuFunction<bool(AuUInt8 &)>;
static ConsumeStream_cb StringToConsumable(const AuString &str, AuMach &index) static ConsumeStream_cb StringToConsumable(const AuString &str, AuMach &index)
{ {

6
Include/Aurora/Threading/LockGuard.hpp
View File

@ -19,7 +19,7 @@ namespace Aurora::Threading
LockGuard(T &lock) LockGuard(T &lock)
{ {
if constexpr (std::is_pointer_v<T>) if constexpr (AuIsPointer_v<T>)
{ {
annoying_ = lock; annoying_ = lock;
} }
@ -40,7 +40,7 @@ namespace Aurora::Threading
LockGuard(T &&lock) LockGuard(T &&lock)
{ {
if constexpr (std::is_pointer_v<T>) if constexpr (AuIsPointer_v<T>)
{ {
annoying_ = lock; annoying_ = lock;
} }
@ -72,7 +72,7 @@ namespace Aurora::Threading
} }
private: private:
std::conditional_t<std::is_pointer_v<T>, T, T*> annoying_; std::conditional_t<AuIsPointer_v<T>, T, T*> annoying_;
}; };
#define AU_LOCK_GUARD(variable) Aurora::Threading::LockGuard<decltype(variable)> AU_CONCAT(__stack_lock, __COUNTER__) (variable); #define AU_LOCK_GUARD(variable) Aurora::Threading::LockGuard<decltype(variable)> AU_CONCAT(__stack_lock, __COUNTER__) (variable);

6
Include/Aurora/Threading/LockGuardTry.hpp
View File

@ -20,7 +20,7 @@ namespace Aurora::Threading
TryLockGuard(T &lock) TryLockGuard(T &lock)
{ {
if constexpr (std::is_pointer_v<T>) if constexpr (AuIsPointer_v<T>)
{ {
annoying_ = lock; annoying_ = lock;
} }
@ -41,7 +41,7 @@ namespace Aurora::Threading
TryLockGuard(T &&lock) TryLockGuard(T &&lock)
{ {
if constexpr (std::is_pointer_v<T>) if constexpr (AuIsPointer_v<T>)
{ {
annoying_ = lock; annoying_ = lock;
} }
@ -82,7 +82,7 @@ namespace Aurora::Threading
return bLockSuccessful; return bLockSuccessful;
} }
private: private:
std::conditional_t<std::is_pointer_v<T>, T, T*> annoying_; std::conditional_t<AuIsPointer_v<T>, T, T*> annoying_;
}; };

4
Include/Aurora/Threading/Threads/TLSVariable.hpp
View File

@ -67,7 +67,7 @@ namespace Aurora::Threading::Threads
sizeof(T), sizeof(T),
[](void *buffer) -> void [](void *buffer) -> void
{ {
if constexpr (std::is_class_v<T>) if constexpr (AuIsClass_v<T>)
{ {
new (buffer) T(); new (buffer) T();
} }
@ -78,7 +78,7 @@ namespace Aurora::Threading::Threads
}, },
[](void *buffer) -> void [](void *buffer) -> void
{ {
if constexpr (std::is_class_v<T>) if constexpr (AuIsClass_v<T>)
{ {
reinterpret_cast<T *>(buffer)->~T(); reinterpret_cast<T *>(buffer)->~T();
} }

2
Include/Aurora/Threading/Threads/TLSView.hpp
View File

@ -17,7 +17,7 @@ namespace Aurora::Threading::Threads
class TLSView class TLSView
{ {
public: public:
using TlsCb = std::function<void(void *)>; using TlsCb = AuFunction<void(void *)>;
virtual void Remove(AuUInt64 key) = 0; virtual void Remove(AuUInt64 key) = 0;
virtual void *GetTLS(AuUInt64 key, AuMach length, bool noAutoCreate = false) = 0; virtual void *GetTLS(AuUInt64 key, AuMach length, bool noAutoCreate = false) = 0;

2
Include/Aurora/Time/DebugBenchmark.hpp
View File

@ -25,7 +25,7 @@ namespace Aurora::Time
void Finish() void Finish()
{ {
if (std::exchange(finished_, true)) return; if (AuExchange(finished_, true)) return;
auto time = timer_.End(); auto time = timer_.End();
Aurora::Console::Logging::LogDbg("[Benchmark] {} took {}", message_, ConvertMSToTimescaleEN(time)); Aurora::Console::Logging::LogDbg("[Benchmark] {} took {}", message_, ConvertMSToTimescaleEN(time));
} }

10
Include/Aurora/Time/Time.hpp
View File

@ -17,30 +17,30 @@ namespace Aurora::Time
if (ms < 1000) if (ms < 1000)
{ {
return std::to_string(ms) + "ms"; return AuToString(ms) + "ms";
} }
else if (ms >= 1000) else if (ms >= 1000)
{ {
auto s = msDiv1000; auto s = msDiv1000;
auto remMs = ms % 1000; auto remMs = ms % 1000;
return std::to_string(s) + "." + std::to_string(remMs) + "s"; return AuToString(s) + "." + AuToString(remMs) + "s";
} }
else if (ms > (1000 * 60)) else if (ms > (1000 * 60))
{ {
auto m = msDiv1000Div60; auto m = msDiv1000Div60;
auto remS = msDiv1000Mod60; auto remS = msDiv1000Mod60;
return std::to_string(m) + "m " + std::to_string(remS) + "s"; return AuToString(m) + "m " + AuToString(remS) + "s";
} }
else if (ms > (1000 * 60 * 60)) else if (ms > (1000 * 60 * 60))
{ {
auto h = msDiv1000Div60 / 60; auto h = msDiv1000Div60 / 60;
auto remM = msDiv1000Div60 % 60; auto remM = msDiv1000Div60 % 60;
auto remS = msDiv1000Mod60; auto remS = msDiv1000Mod60;
return std::to_string(h) + "h " + std::to_string(remM) + "m" + std::to_string(remS) + "s"; return AuToString(h) + "h " + AuToString(remM) + "m" + AuToString(remS) + "s";
} }
else else
{ {
return std::to_string(ms); // ? return AuToString(ms); // ?
} }
} }
} }

73
Include/AuroraTypedefs.hpp
View File

@ -22,6 +22,68 @@
#endif #endif
#endif #endif
template<bool v>
struct AuBoolType
{
static constexpr bool value = v;
using value_type = bool;
using type = AuBoolType;
constexpr operator value_type() const noexcept
{
return value;
}
constexpr value_type operator()() const noexcept
{
return value;
}
};
using AuFalseType = AuBoolType<false>;
using AuTrueType = AuBoolType<true>;
template<class T, class U>
struct AuIsSame : AuFalseType
{};
template<class T>
struct AuIsSame<T, T> : AuTrueType
{};
template< class T, class U >
inline constexpr bool AuIsSame_v = AuIsSame<T, U>::value;
namespace _audetail {
template <class T>
AuBoolType<!std::is_union<T>::value> test(int T:: *);
template <class>
AuFalseType test(...);
}
template<class T>
struct AuIsClass : decltype(_audetail::test<T>(nullptr))
{};
template<class T>
inline constexpr bool AuIsClass_v = AuIsClass<T>::value;
template <class>
inline constexpr bool AuIsPointer_v = false;
template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *> = true;
template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *const> = true;
template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *volatile> = true;
template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *const volatile> = true;
#if !defined(AURORA_RUNTIME_AU_LIST) #if !defined(AURORA_RUNTIME_AU_LIST)
#define AURORA_RUNTIME_AU_LIST std::vector #define AURORA_RUNTIME_AU_LIST std::vector
#endif #endif
@ -40,11 +102,10 @@ namespace Aurora::Memory
} }
template<typename T> template<typename T>
using AuList = typename std::conditional<std::is_class<T>::value, AURORA_RUNTIME_AU_LIST<T>, AURORA_RUNTIME_AU_LIST<T, Aurora::Memory::SpeedyArrayAllocator<T>>>::type; using AuList = typename std::conditional<AuIsClass_v<T>, AURORA_RUNTIME_AU_LIST<T>, AURORA_RUNTIME_AU_LIST<T, Aurora::Memory::SpeedyArrayAllocator<T>>>::type;
#endif #endif
#if !defined(AURORA_RUNTIME_AU_ARRAY) #if !defined(AURORA_RUNTIME_AU_ARRAY)
#define AURORA_RUNTIME_AU_ARRAY std::array #define AURORA_RUNTIME_AU_ARRAY std::array
#endif #endif
@ -113,6 +174,14 @@ using AuUPtr = AURORA_RUNTIME_AU_UNIQUE_PTR<T, Deleter_t>;
template<typename A_t, typename B_t> template<typename A_t, typename B_t>
using AuPair = AURORA_RUNTIME_AU_PAIR<A_t, B_t>; using AuPair = AURORA_RUNTIME_AU_PAIR<A_t, B_t>;
#if !defined(AURORA_RUNTIME_AU_TUPLE)
#define AURORA_RUNTIME_AU_TUPLE std::tuple
#endif
template<class... Types>
using AuTuple = AURORA_RUNTIME_AU_TUPLE<Types...>;
#if defined(AURORA_COMPILER_MSVC) #if defined(AURORA_COMPILER_MSVC)
using AuAtomicInt = long; using AuAtomicInt = long;
#else #else

164
Include/AuroraUtils.hpp
View File

@ -34,12 +34,101 @@ static auline auto AuMakePair(Args&&... args)
return AURORA_RUNTIME_MAKE_PAIR(std::forward<Args>(args)...); return AURORA_RUNTIME_MAKE_PAIR(std::forward<Args>(args)...);
} }
#if !defined(AURORA_RUNTIME_MAKE_TUPLE)
#define AURORA_RUNTIME_MAKE_TUPLE std::make_tuple
#endif
template<typename... Args>
static auline auto AuMakeTuple(Args&&... args)
{
return AURORA_RUNTIME_MAKE_TUPLE(std::forward<Args>(args)...);
}
#if !defined(AURORA_RUNTIME_TO_STRING)
#define AURORA_RUNTIME_TO_STRING std::to_string
#endif
template<class T>
AuString AuToString(const T &obj)
{
return AURORA_RUNTIME_TO_STRING(obj);
}
#if !defined(AURORA_RUNTIME_EXCHANGE)
#define AURORA_RUNTIME_EXCHANGE std::exchange
#endif
template<class T, class U = T>
T AuExchange(T &obj, U &&new_value)
{
return AURORA_RUNTIME_EXCHANGE(obj, new_value);
}
#if !defined(AURORA_RUNTIME_MIN)
#define AURORA_RUNTIME_MIN std::min
#endif
template< class T >
constexpr const T &AuMin(const T &a, const T &b)
{
return AURORA_RUNTIME_MIN(a, b);
}
#if !defined(AURORA_RUNTIME_MAX)
#define AURORA_RUNTIME_MAX std::max
#endif
template< class T >
constexpr const T &AuMax(const T &a, const T &b)
{
return AURORA_RUNTIME_MAX(a, b);
}
#if !defined(AURORA_RUNTIME_MEMCMP)
#define AURORA_RUNTIME_MEMCMP std::memcmp
#endif
static auline int AuMemcmp(const void *dest, const void *src, size_t n)
{
return AURORA_RUNTIME_MEMCMP(dest, src, n);
}
#if !defined(AURORA_RUNTIME_MEMSET)
#define AURORA_RUNTIME_MEMSET std::memset
#endif
static auline void *AuMemset(void *dest, AuUInt8 c, size_t n)
{
return AURORA_RUNTIME_MEMSET(dest, c, n);
}
#if !defined(AURORA_RUNTIME_MEMCPY)
#define AURORA_RUNTIME_MEMCPY std::memcpy
#endif
static auline void *AuMemcpy(void *dest, const void *src, size_t n)
{
return AURORA_RUNTIME_MEMCPY(dest, src, n);
}
#if !defined(AURORA_RUNTIME_MEMMOVE)
#define AURORA_RUNTIME_MEMMOVE std::memmove
#endif
static auline void *AuMemmove(void *dest, const void *src, size_t n)
{
return AURORA_RUNTIME_MEMMOVE(dest, src, n);
}
#if defined(AURORA_IS_MODERNNT_DERIVED) && (defined(_WINDOWS_) || defined(_OTHER_MS_MAIN_HEADER_GUARDS_HERE)) #if defined(AURORA_IS_MODERNNT_DERIVED) && (defined(_WINDOWS_) || defined(_OTHER_MS_MAIN_HEADER_GUARDS_HERE))
static auline void AuWin32CloseHandle(HANDLE &handle) static auline void AuWin32CloseHandle(HANDLE &handle)
{ {
HANDLE local; HANDLE local;
if ((local = std::exchange(handle, INVALID_HANDLE_VALUE)) != INVALID_HANDLE_VALUE) if ((local = AuExchange(handle, INVALID_HANDLE_VALUE)) != INVALID_HANDLE_VALUE)
{ {
CloseHandle(local); CloseHandle(local);
} }
@ -311,6 +400,19 @@ static auline bool AuTryFindGeneric(Map &map, const Key &key, Value *&ptr)
} }
} }
template<typename Map, class Key>
static auline bool AuTryFindGeneric(Map &map, const Key &key)
{
if (map.find(key) != map.end())
{
return true;
}
else
{
return false;
}
}
template<typename Map, class Key> template<typename Map, class Key>
static auline bool AuTryDelete(Map &map, const Key &key) static auline bool AuTryDelete(Map &map, const Key &key)
{ {
@ -470,7 +572,7 @@ static auline bool AuTryResize(T &list, AuUInt length)
{ {
try try
{ {
if constexpr (std::is_same_v<T, Aurora::Memory::ByteBuffer>) if constexpr (AuIsSame_v<T, Aurora::Memory::ByteBuffer>)
{ {
return list.Resize(length); return list.Resize(length);
} }
@ -491,7 +593,7 @@ static auline bool AuTryDownsize(T &list, AuUInt length)
{ {
try try
{ {
if constexpr (std::is_same_v<T, Aurora::Memory::ByteBuffer>) if constexpr (AuIsSame_v<T, Aurora::Memory::ByteBuffer>)
{ {
return list.Resize(length); return list.Resize(length);
} }
@ -649,31 +751,31 @@ static auline T AuReadGenericLE(const void *ptr, int offset)
return *reinterpret_cast<const T *>(reinterpret_cast<const AuUInt8 *>(ptr) + offset); return *reinterpret_cast<const T *>(reinterpret_cast<const AuUInt8 *>(ptr) + offset);
#else #else
T temp; T temp;
std::memcpy(&temp, reinterpret_cast<const AuUInt8 *>(ptr) + offset, sizeof(temp)); AuMemcpy(&temp, reinterpret_cast<const AuUInt8 *>(ptr) + offset, sizeof(temp));
#if !defined(AU_CPU_ENDIAN_LITTLE) #if !defined(AU_CPU_ENDIAN_LITTLE)
#if defined(AURORA_COMPILER_MSVC) #if defined(AURORA_COMPILER_MSVC)
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = _byteswap_ulong(temp); temp = _byteswap_ulong(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = _byteswap_uint64(temp); temp = _byteswap_uint64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = _byteswap_ushort(temp); temp = _byteswap_ushort(temp);
} }
#else #else
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = __builtin_bswap32(temp); temp = __builtin_bswap32(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = __builtin_bswap64(temp); temp = __builtin_bswap64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = (temp << 8) | ((temp >> 8) & 0xFF); temp = (temp << 8) | ((temp >> 8) & 0xFF);
} }
@ -690,31 +792,31 @@ static auline T AuReadGenericBE(const void *ptr, int offset)
return *reinterpret_cast<const T *>(reinterpret_cast<const AuUInt8 *>(ptr) + offset); return *reinterpret_cast<const T *>(reinterpret_cast<const AuUInt8 *>(ptr) + offset);
#else #else
T temp; T temp;
std::memcpy(&temp, reinterpret_cast<const AuUInt8 *>(ptr) + offset, sizeof(temp)); AuMemcpy(&temp, reinterpret_cast<const AuUInt8 *>(ptr) + offset, sizeof(temp));
#if defined(AU_CPU_ENDIAN_LITTLE) #if defined(AU_CPU_ENDIAN_LITTLE)
#if defined(AURORA_COMPILER_MSVC) #if defined(AURORA_COMPILER_MSVC)
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = _byteswap_ulong(temp); temp = _byteswap_ulong(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = _byteswap_uint64(temp); temp = _byteswap_uint64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = _byteswap_ushort(temp); temp = _byteswap_ushort(temp);
} }
#else #else
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = __builtin_bswap32(temp); temp = __builtin_bswap32(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = __builtin_bswap64(temp); temp = __builtin_bswap64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = (temp << 8) | ((temp >> 8) & 0xFF); temp = (temp << 8) | ((temp >> 8) & 0xFF);
} }
@ -885,34 +987,34 @@ static auline void AuWriteGenericLE(void *ptr, int offset, T value)
T temp = value; T temp = value;
#if !defined(AU_CPU_ENDIAN_LITTLE) #if !defined(AU_CPU_ENDIAN_LITTLE)
#if defined(AURORA_COMPILER_MSVC) #if defined(AURORA_COMPILER_MSVC)
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = _byteswap_ulong(temp); temp = _byteswap_ulong(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = _byteswap_uint64(temp); temp = _byteswap_uint64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = _byteswap_ushort(temp); temp = _byteswap_ushort(temp);
} }
#else #else
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = __builtin_bswap32(temp); temp = __builtin_bswap32(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = __builtin_bswap64(temp); temp = __builtin_bswap64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = (temp << 8) | ((temp >> 8) & 0xFF); temp = (temp << 8) | ((temp >> 8) & 0xFF);
} }
#endif #endif
#endif #endif
std::memcpy(reinterpret_cast<AuUInt8 *>(ptr) + offset, &temp, sizeof(temp)); AuMemcpy(reinterpret_cast<AuUInt8 *>(ptr) + offset, &temp, sizeof(temp));
#endif #endif
} }
@ -925,34 +1027,34 @@ static auline void AuWriteGenericBE(void *ptr, T value, int offset)
T temp = value; T temp = value;
#if defined(AU_CPU_ENDIAN_LITTLE) #if defined(AU_CPU_ENDIAN_LITTLE)
#if defined(AURORA_COMPILER_MSVC) #if defined(AURORA_COMPILER_MSVC)
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = _byteswap_ulong(temp); temp = _byteswap_ulong(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = _byteswap_uint64(temp); temp = _byteswap_uint64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = _byteswap_ushort(temp); temp = _byteswap_ushort(temp);
} }
#else #else
if constexpr (std::is_same_v<T, AuUInt32> || std::is_same_v<T, AuInt32>) if constexpr (AuIsSame_v<T, AuUInt32> || AuIsSame_v<T, AuInt32>)
{ {
temp = __builtin_bswap32(temp); temp = __builtin_bswap32(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt64> || std::is_same_v<T, AuInt64>) else if constexpr (AuIsSame_v<T, AuUInt64> || AuIsSame_v<T, AuInt64>)
{ {
temp = __builtin_bswap64(temp); temp = __builtin_bswap64(temp);
} }
else if constexpr (std::is_same_v<T, AuUInt16> || std::is_same_v<T, AuInt16>) else if constexpr (AuIsSame_v<T, AuUInt16> || AuIsSame_v<T, AuInt16>)
{ {
temp = (temp << 8) | ((temp >> 8) & 0xFF); temp = (temp << 8) | ((temp >> 8) & 0xFF);
} }
#endif #endif
#endif #endif
std::memcpy(reinterpret_cast<AuUInt8 *>(ptr) + offset, &temp, sizeof(temp)); AuMemcpy(reinterpret_cast<AuUInt8 *>(ptr) + offset, &temp, sizeof(temp));
#endif #endif
} }

12
Source/Async/AsyncRunnable.hpp
View File

@ -22,20 +22,20 @@ namespace Aurora::Async
{ {
public: public:
std::function<void()> callback; AuFunction<void()> callback;
std::function<void()> fail; AuFunction<void()> fail;
AuThreadPrimitives::SpinLock lock; AuThreadPrimitives::SpinLock lock;
AsyncFuncRunnable(std::function<void()> &&callback) : callback(std::move(callback)) AsyncFuncRunnable(AuFunction<void()> &&callback) : callback(std::move(callback))
{} {}
AsyncFuncRunnable(std::function<void()> &&callback, std::function<void()> &&fail) : callback(std::move(callback)), fail(std::move(fail)) AsyncFuncRunnable(AuFunction<void()> &&callback, AuFunction<void()> &&fail) : callback(std::move(callback)), fail(std::move(fail))
{} {}
AsyncFuncRunnable(const std::function<void()> &callback) : callback(callback) AsyncFuncRunnable(const AuFunction<void()> &callback) : callback(callback)
{} {}
AsyncFuncRunnable(const std::function<void()> &callback, const std::function<void()> &fail) : callback(callback), fail(fail) AsyncFuncRunnable(const AuFunction<void()> &callback, const AuFunction<void()> &fail) : callback(callback), fail(fail)
{} {}
void RunAsync() override void RunAsync() override

2
Source/Async/Schedular.cpp
View File

@ -96,7 +96,7 @@ namespace Aurora::Async
{ {
try try
{ {
if (!std::exchange(gLockedPump, true)) if (!AuExchange(gLockedPump, true))
{ {
NewWorkItem(AuWorkerId_t{0, 0}, AuMakeShared<BasicWorkStdFunc>(PumpSysThread))->Dispatch(); NewWorkItem(AuWorkerId_t{0, 0}, AuMakeShared<BasicWorkStdFunc>(PumpSysThread))->Dispatch();
} }

4
Source/Async/ThreadPool.cpp
View File

@ -357,7 +357,7 @@ namespace Aurora::Async
int runningTasks {}; int runningTasks {};
auto oldTlsHandle = std::exchange(gCurrentPool, AuSharedFromThis()); auto oldTlsHandle = AuExchange(gCurrentPool, AuSharedFromThis());
bool lowPrioCont {}; bool lowPrioCont {};
bool lowPrioContCached {}; bool lowPrioContCached {};
@ -540,7 +540,7 @@ namespace Aurora::Async
// Set shutdown flag // Set shutdown flag
{ {
AU_LOCK_GUARD(this->rwlock_->AsWritable()); AU_LOCK_GUARD(this->rwlock_->AsWritable());
if (std::exchange(this->shuttingdown_, true)) if (AuExchange(this->shuttingdown_, true))
{ {
return; return;
} }

4
Source/Async/WorkItem.cpp
View File

@ -171,7 +171,7 @@ namespace Aurora::Async
return; return;
} }
if (auto delay = std::exchange(delayTimeNs_, {})) if (auto delay = AuExchange(delayTimeNs_, {}))
{ {
this->dispatchTimeNs_ = delay + Time::CurrentClockNS(); this->dispatchTimeNs_ = delay + Time::CurrentClockNS();
Schedule(); Schedule();
@ -271,7 +271,7 @@ namespace Aurora::Async
{ {
failed = true; failed = true;
if (auto task_ = std::exchange(this->task_, {})) if (auto task_ = AuExchange(this->task_, {}))
{ {
task_->Shutdown(); task_->Shutdown();
} }

4
Source/Compression/BlockCompressor.cpp
View File

@ -36,7 +36,7 @@ namespace Aurora::Compression
{ {
while (this->_outbuffer.RemainingBytes() < minimumDeflated) while (this->_outbuffer.RemainingBytes() < minimumDeflated)
{ {
auto toRead = minimumDeflated ? std::min(AuUInt32(4096), AuUInt32(minimumDeflated - this->_outbuffer.RemainingBytes())) : 4096; auto toRead = minimumDeflated ? AuMin(AuUInt32(4096), AuUInt32(minimumDeflated - this->_outbuffer.RemainingBytes())) : 4096;
if (Ingest(toRead).second == 0) if (Ingest(toRead).second == 0)
{ {
if (!this->_outbuffer.RemainingBytes()) if (!this->_outbuffer.RemainingBytes())
@ -86,7 +86,7 @@ namespace Aurora::Compression
if (written != length) if (written != length)
{ {
auto increase = std::max(0, (int)length - (int)this->_outbuffer.RemainingWrite()); auto increase = AuMax(0, (int)length - (int)this->_outbuffer.RemainingWrite());
increase += this->_outbuffer.length; increase += this->_outbuffer.length;
if (increase > 64 * 1024 * 1024) if (increase > 64 * 1024 * 1024)

14
Source/Compression/BlockDecompressor.cpp
View File

@ -25,7 +25,7 @@ namespace Aurora::Compression
{ {
while (this->_outbuffer.RemainingBytes() < minimumInflated) while (this->_outbuffer.RemainingBytes() < minimumInflated)
{ {
auto toRead = minimumInflated ? std::min(AuUInt32(4096), AuUInt32(minimumInflated - this->_outbuffer.RemainingBytes())) : 4096; auto toRead = minimumInflated ? AuMin(AuUInt32(4096), AuUInt32(minimumInflated - this->_outbuffer.RemainingBytes())) : 4096;
if (Ingest(toRead).second == 0) if (Ingest(toRead).second == 0)
{ {
if (!this->_outbuffer.RemainingBytes()) if (!this->_outbuffer.RemainingBytes())
@ -69,7 +69,7 @@ namespace Aurora::Compression
if (written != length) if (written != length)
{ {
auto increase = std::max(0, (int)length - (int)this->_outbuffer.RemainingWrite()); auto increase = AuMax(0, (int)length - (int)this->_outbuffer.RemainingWrite());
increase += this->_outbuffer.length; increase += this->_outbuffer.length;
if (increase > 64 * 1024 * 1024) if (increase > 64 * 1024 * 1024)
@ -109,7 +109,7 @@ namespace Aurora::Compression
~ZSTDInflate() ~ZSTDInflate()
{ {
if (auto dctx = std::exchange(dctx_, {})) if (auto dctx = AuExchange(dctx_, {}))
{ {
ZSTD_freeDCtx(dctx); ZSTD_freeDCtx(dctx);
} }
@ -137,7 +137,7 @@ namespace Aurora::Compression
while (read != input) while (read != input)
{ {
AuUInt request = std::min(input, length); AuUInt request = AuMin(input, length);
if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone) if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone)
{ {
return AuMakePair(read, done); return AuMakePair(read, done);
@ -218,7 +218,7 @@ namespace Aurora::Compression
while (read < input) while (read < input)
{ {
AuUInt request = std::min(input, AuUInt32(AuArraySize(din_))); AuUInt request = AuMin(input, AuUInt32(AuArraySize(din_)));
if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone) if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone)
{ {
return AuMakePair(read, done); return AuMakePair(read, done);
@ -231,7 +231,7 @@ namespace Aurora::Compression
do do
{ {
this->ctx_.avail_out = AuArraySize(dout_); // std::min(AuUInt32(AuArraySize(dout_)), AuUInt32(this->_outbuffer.RemainingWrite())); this->ctx_.avail_out = AuArraySize(dout_); // AuMin(AuUInt32(AuArraySize(dout_)), AuUInt32(this->_outbuffer.RemainingWrite()));
this->ctx_.next_out = dout_; this->ctx_.next_out = dout_;
if (!this->ctx_.avail_out) if (!this->ctx_.avail_out)
@ -308,7 +308,7 @@ namespace Aurora::Compression
AuUInt32 done{}, read{}; AuUInt32 done{}, read{};
while (read < input) while (read < input)
{ {
AuUInt request = std::min(input, AuUInt32(AuArraySize(din_))); AuUInt request = AuMin(input, AuUInt32(AuArraySize(din_)));
if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone) if (this->reader_->Read(Memory::MemoryViewStreamWrite(din_, request)) != IO::EStreamError::eErrorNone)
{ {
return AuMakePair(read, done); return AuMakePair(read, done);

2
Source/Compression/StreamCompression.cpp
View File

@ -143,7 +143,7 @@ namespace Aurora::Compression
return false; return false;
} }
ret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, std::max(stream.threads, 1u)); ret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, AuMax(stream.threads, 1u));
if (ZSTD_isError(ret)) if (ZSTD_isError(ret))
{ {
SysPushErrorGen(); SysPushErrorGen();

4
Source/Console/Commands/Commands.cpp
View File

@ -153,7 +153,7 @@ namespace Aurora::Console::Commands
// process commands before async app termination // process commands before async app termination
if ((!target.has_value())) if ((!target.has_value()))
{ {
auto commands = std::exchange(gPendingCommands, {}); auto commands = AuExchange(gPendingCommands, {});
for (const auto &command : commands) for (const auto &command : commands)
{ {
command.callback->OnCommand(command.arguments); command.callback->OnCommand(command.arguments);
@ -176,7 +176,7 @@ namespace Aurora::Console::Commands
gMutex->Lock(); gMutex->Lock();
gPendingCommandsMutex->Lock(); gPendingCommandsMutex->Lock();
auto commands = std::exchange(gPendingCommands, {}); auto commands = AuExchange(gPendingCommands, {});
gPendingCommandsMutex->Unlock(); gPendingCommandsMutex->Unlock();
if ((gCommandDispatcher.pool == nullptr) || if ((gCommandDispatcher.pool == nullptr) ||

2
Source/Console/ConsoleMessage.cpp
View File

@ -10,7 +10,7 @@
namespace Aurora::Console namespace Aurora::Console
{ {
static std::array<std::string, static_cast<size_t>(EAnsiColor::eCount)> kAnsiCheats static AuArray<std::string, static_cast<size_t>(EAnsiColor::eCount)> kAnsiCheats
{ {
"\033[0;31m", "\033[0;31m",
"\033[1;31m", "\033[1;31m",

12
Source/Console/ConsoleStd/ConsoleStd.cpp
View File

@ -134,7 +134,7 @@ namespace Aurora::Console::ConsoleStd
void Start() void Start()
{ {
static bool gConsoleStarted = false; static bool gConsoleStarted = false;
if (std::exchange(gConsoleStarted, true)) return; if (AuExchange(gConsoleStarted, true)) return;
#if defined(AURORA_IS_MODERNNT_DERIVED) #if defined(AURORA_IS_MODERNNT_DERIVED)
@ -311,14 +311,14 @@ namespace Aurora::Console::ConsoleStd
Pump(); Pump();
gRingLock.Lock(); gRingLock.Lock();
auto readable = std::min(AuUInt32(length), AuUInt32(gEncodedIndex)); auto readable = AuMin(AuUInt32(length), AuUInt32(gEncodedIndex));
std::memcpy(data, gLineEncodedBuffer, readable); AuMemcpy(data, gLineEncodedBuffer, readable);
const auto remainingBytes = gEncodedIndex - readable; const auto remainingBytes = gEncodedIndex - readable;
if (remainingBytes) if (remainingBytes)
{ {
std::memmove(gLineEncodedBuffer, &gLineEncodedBuffer[readable], remainingBytes); AuMemmove(gLineEncodedBuffer, &gLineEncodedBuffer[readable], remainingBytes);
} }
gEncodedIndex = remainingBytes; gEncodedIndex = remainingBytes;
@ -362,7 +362,7 @@ namespace Aurora::Console::ConsoleStd
const auto remainingBytes = gLineIndex - startIdx; const auto remainingBytes = gLineIndex - startIdx;
if (remainingBytes) if (remainingBytes)
{ {
std::memmove(gLineBuffer.data(), &gLineBuffer.data()[startIdx], remainingBytes); AuMemmove(gLineBuffer.data(), &gLineBuffer.data()[startIdx], remainingBytes);
gLineIndex -= startIdx; gLineIndex -= startIdx;
} }
} }
@ -385,7 +385,7 @@ namespace Aurora::Console::ConsoleStd
const auto remainingBytes = gEncodedIndex - ret.first; const auto remainingBytes = gEncodedIndex - ret.first;
if (remainingBytes) if (remainingBytes)
{ {
std::memmove(gLineEncodedBuffer, &gLineEncodedBuffer[ret.first], remainingBytes); AuMemmove(gLineEncodedBuffer, &gLineEncodedBuffer[ret.first], remainingBytes);
} }
gEncodedIndex = remainingBytes; gEncodedIndex = remainingBytes;

10
Source/Console/ConsoleWxWidgets/ConsoleWxWidgets.cpp
View File

@ -53,7 +53,7 @@ public:
private: private:
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
std::optional<wxColor> _color; AuOptional<wxColor> _color;
}; };
wxBEGIN_EVENT_TABLE(WxSplitterLine, wxPanel) wxBEGIN_EVENT_TABLE(WxSplitterLine, wxPanel)
EVT_PAINT(WxSplitterLine::OnPaint) EVT_PAINT(WxSplitterLine::OnPaint)
@ -164,7 +164,7 @@ WxSplitterLine *ConsoleFrame::NewSplitter(wxSize splitter)
void ConsoleFrame::WriteLine(const Aurora::Console::ConsoleMessage &string) void ConsoleFrame::WriteLine(const Aurora::Console::ConsoleMessage &string)
{ {
static std::array<const wxColour, static_cast<size_t>(Aurora::Console::EAnsiColor::eCount)> ColorMap static AuArray<const wxColour, static_cast<size_t>(Aurora::Console::EAnsiColor::eCount)> ColorMap
{ {
*wxRED, // kRed, *wxRED, // kRed,
*wxRED, // kBoldRed, *wxRED, // kBoldRed,
@ -181,7 +181,7 @@ void ConsoleFrame::WriteLine(const Aurora::Console::ConsoleMessage &string)
*wxWHITE, // kReset *wxWHITE, // kReset
}; };
static std::array<bool, static_cast<size_t>(Aurora::Console::EAnsiColor::eCount)> HahaBald static AuArray<bool, static_cast<size_t>(Aurora::Console::EAnsiColor::eCount)> HahaBald
{ {
false, // kRed, false, // kRed,
true, // kBoldRed, true, // kBoldRed,
@ -769,7 +769,7 @@ namespace Aurora::Console::ConsoleWxWidgets
void Start() void Start()
{ {
if (std::exchange(gConsoleStarted, true)) return; if (AuExchange(gConsoleStarted, true)) return;
gMutex = AuThreadPrimitives::MutexUnique(); gMutex = AuThreadPrimitives::MutexUnique();
if (!gMutex) return; if (!gMutex) return;
@ -797,7 +797,7 @@ namespace Aurora::Console::ConsoleWxWidgets
AuList<Console::ConsoleMessage> lines; AuList<Console::ConsoleMessage> lines;
{ {
AU_LOCK_GUARD(gMutex); AU_LOCK_GUARD(gMutex);
lines = std::exchange(gPendingLines, {}); lines = AuExchange(gPendingLines, {});
} }
for (const auto& line : lines) for (const auto& line : lines)

2
Source/Console/Hooks/Hooks.cpp
View File

@ -39,7 +39,7 @@ namespace Aurora::Console::Hooks
static void WriteLoggerFailedWarning() static void WriteLoggerFailedWarning()
{ {
static std::string kLoggerError = "Something went from while dispatching a log line\n"; static AuString kLoggerError = "Something went from while dispatching a log line\n";
Console::WriteStdOut(kLoggerError.data(), kLoggerError.size()); Console::WriteStdOut(kLoggerError.data(), kLoggerError.size());
#if defined(AURORA_IS_MODERNNT_DERIVED) #if defined(AURORA_IS_MODERNNT_DERIVED)

2
Source/Crypto/AES/Aes.cpp
View File

@ -125,7 +125,7 @@ namespace Aurora::Crypto::AES
return false; return false;
} }
std::memcpy(pad, tptr + primaryLength, overhang); AuMemcpy(pad, tptr + primaryLength, overhang);
pad[127] = padding; pad[127] = padding;
ret = cbc_encrypt(pad, out.data() + primaryLength, 128, &cbc); ret = cbc_encrypt(pad, out.data() + primaryLength, 128, &cbc);

2
Source/Crypto/ECC/ECCGeneric.cpp
View File

@ -126,7 +126,7 @@ namespace Aurora::Crypto::ECC
return true; return true;
} }
std::optional<IECCPrivate *> GenerateNewGenericECC(EECCCurve curve) AuOptional<IECCPrivate *> GenerateNewGenericECC(EECCCurve curve)
{ {
ecc_key key = {}; ecc_key key = {};
const int prng_idx = register_prng(&sprng_desc); const int prng_idx = register_prng(&sprng_desc);

4
Source/Crypto/ECC/ECCGeneric.hpp
View File

@ -63,7 +63,7 @@ namespace Aurora::Crypto::ECC
pk_oid_str_to_num(ref.value()->OID, oid, &oidLength); pk_oid_str_to_num(ref.value()->OID, oid, &oidLength);
if (oidLength != in.dp.oidlen || if (oidLength != in.dp.oidlen ||
std::memcmp(in.dp.oid, oid, in.dp.oidlen * sizeof(unsigned long))) AuMemcmp(in.dp.oid, oid, in.dp.oidlen * sizeof(unsigned long)))
{ {
SysPushErrorParam("Improper curve type, expected {}, got {}, for ECCCurveType: {}", ref.value()->OID, AuList<unsigned long>(in.dp.oid, in.dp.oid + in.dp.oidlen), curve.value()); SysPushErrorParam("Improper curve type, expected {}, got {}, for ECCCurveType: {}", ref.value()->OID, AuList<unsigned long>(in.dp.oid, in.dp.oid + in.dp.oidlen), curve.value());
ecc_free(&in); ecc_free(&in);
@ -90,5 +90,5 @@ namespace Aurora::Crypto::ECC
return out; return out;
} }
std::optional<IECCPrivate *> GenerateNewGenericECC(EECCCurve curve); AuOptional<IECCPrivate *> GenerateNewGenericECC(EECCCurve curve);
} }

4
Source/Crypto/X509/x509.cpp
View File

@ -27,7 +27,7 @@
namespace Aurora::Crypto::X509 namespace Aurora::Crypto::X509
{ {
#pragma region functions copied from mbedtls, modified to do extract the asn fields we care about #pragma region functions copied from mbedtls, modified to do extract the asn fields we care about
static int x509_get_crt_ext(mbedtls_x509_crt *crt, const char *oid, int oidLength, std::function<void(mbedtls_x509_buf &ex, unsigned char **, unsigned char *)> cb); static int x509_get_crt_ext(mbedtls_x509_crt *crt, const char *oid, int oidLength, AuFunction<void(mbedtls_x509_buf &ex, unsigned char **, unsigned char *)> cb);
static int x509_get_ca_id(mbedtls_x509_crt *crt, AuList<AuUInt8> &key) static int x509_get_ca_id(mbedtls_x509_crt *crt, AuList<AuUInt8> &key)
{ {
@ -318,7 +318,7 @@ namespace Aurora::Crypto::X509
find_oid_value_in_name(&name, MBEDTLS_OID_AT_GIVEN_NAME, out.name); find_oid_value_in_name(&name, MBEDTLS_OID_AT_GIVEN_NAME, out.name);
} }
static bool ParseCert(const Certificate &der, std::function<void(mbedtls_x509_crt &crt)> cb) static bool ParseCert(const Certificate &der, AuFunction<void(mbedtls_x509_crt &crt)> cb)
{ {
bool ret = false; bool ret = false;
mbedtls_x509_crt crt {}; mbedtls_x509_crt crt {};

4
Source/Debug/ExceptionWatcher.Win32.cpp
View File

@ -110,7 +110,7 @@ namespace Aurora::Debug
if (SymGetLineFromAddr64(process, stack.AddrPC.Offset, &disp, &line)) if (SymGetLineFromAddr64(process, stack.AddrPC.Offset, &disp, &line))
{ {
frameCurrent.file = std::make_tuple(line.FileName, line.LineNumber, 0); frameCurrent.file = AuMakeTuple(line.FileName, line.LineNumber, 0);
} }
#endif #endif
@ -304,7 +304,7 @@ namespace Aurora::Debug
} }
else else
{ {
entry.wincxx.str = std::to_string(ExceptionInfo->ExceptionRecord->ExceptionCode); entry.wincxx.str = AuToString(ExceptionInfo->ExceptionRecord->ExceptionCode);
} }
} }
else else

4
Source/Debug/Panic.cpp
View File

@ -59,7 +59,7 @@ namespace Aurora::Debug
} }
static bool panicSingleshot = false; static bool panicSingleshot = false;
if (std::exchange(panicSingleshot, true)) if (AuExchange(panicSingleshot, true))
{ {
try try
{ {
@ -73,7 +73,7 @@ namespace Aurora::Debug
// //
static bool handlingFatal = false; static bool handlingFatal = false;
if (std::exchange(handlingFatal, true)) if (AuExchange(handlingFatal, true))
{ {
std::terminate(); std::terminate();
} }

4
Source/HWInfo/CpuInfo.cpp
View File

@ -336,8 +336,8 @@ namespace Aurora::HWInfo
{ {
// Credit: https://docs.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex?view=msvc-160 // Credit: https://docs.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex?view=msvc-160
#if defined(AURORA_ARCH_X64) || defined(AURORA_ARCH_X86) #if defined(AURORA_ARCH_X64) || defined(AURORA_ARCH_X86)
std::vector<CPUIdContext> data; AuList<CPUIdContext> data;
std::vector<CPUIdContext> extdata; AuList<CPUIdContext> extdata;
auto cpuInfo = cpuid(0); auto cpuInfo = cpuid(0);
auto nIds = cpuInfo.eax; auto nIds = cpuInfo.eax;

10
Source/Hashing/Digests.cpp
View File

@ -11,7 +11,7 @@
namespace Aurora::Hashing namespace Aurora::Hashing
{ {
AUKN_SYM void MD5(const void *buffer, AuMach length, std::array<AuUInt8, 16> &md5) AUKN_SYM void MD5(const void *buffer, AuMach length, AuArray<AuUInt8, 16> &md5)
{ {
hash_state md; hash_state md;
md5_init(&md); md5_init(&md);
@ -19,7 +19,7 @@ namespace Aurora::Hashing
md5_done(&md, md5.data()); md5_done(&md, md5.data());
} }
AUKN_SYM void SHA1(const void *buffer, AuMach length, std::array<AuUInt8, 20> &sha1) AUKN_SYM void SHA1(const void *buffer, AuMach length, AuArray<AuUInt8, 20> &sha1)
{ {
hash_state md; hash_state md;
sha1_init(&md); sha1_init(&md);
@ -27,7 +27,7 @@ namespace Aurora::Hashing
sha1_done(&md, sha1.data()); sha1_done(&md, sha1.data());
} }
AUKN_SYM void Tiger(const void *buffer, AuMach length, std::array<AuUInt8, 24> &tiger) AUKN_SYM void Tiger(const void *buffer, AuMach length, AuArray<AuUInt8, 24> &tiger)
{ {
hash_state md; hash_state md;
tiger_init(&md); tiger_init(&md);
@ -35,7 +35,7 @@ namespace Aurora::Hashing
tiger_done(&md, tiger.data()); tiger_done(&md, tiger.data());
} }
AUKN_SYM void SHA2(const void *buffer, AuMach length, std::array<AuUInt8, 32> &sha2) AUKN_SYM void SHA2(const void *buffer, AuMach length, AuArray<AuUInt8, 32> &sha2)
{ {
hash_state md; hash_state md;
sha256_init(&md); sha256_init(&md);
@ -43,7 +43,7 @@ namespace Aurora::Hashing
sha256_done(&md, sha2.data()); sha256_done(&md, sha2.data());
} }
AUKN_SYM void SHA2_64(const void *buffer, AuMach length, std::array<AuUInt8, 64> &sha2) AUKN_SYM void SHA2_64(const void *buffer, AuMach length, AuArray<AuUInt8, 64> &sha2)
{ {
hash_state md; hash_state md;
sha512_init(&md); sha512_init(&md);

10
Source/Hashing/HashStream.cpp
View File

@ -81,35 +81,35 @@ namespace Aurora::Hashing
{ {
case EHashType::eMD5: case EHashType::eMD5:
length = 16; length = 16;
if (!std::exchange(finished_, true)) if (!AuExchange(finished_, true))
{ {
md5_done(&state_, reinterpret_cast<unsigned char *>(buffer_)); md5_done(&state_, reinterpret_cast<unsigned char *>(buffer_));
} }
return buffer_; return buffer_;
case EHashType::eSHA1: case EHashType::eSHA1:
length = 20; length = 20;
if (!std::exchange(finished_, true)) if (!AuExchange(finished_, true))
{ {
sha1_done(&state_, reinterpret_cast<unsigned char *>(buffer_)); sha1_done(&state_, reinterpret_cast<unsigned char *>(buffer_));
} }
return buffer_; return buffer_;
case EHashType::eSHA2_32: case EHashType::eSHA2_32:
length = 32; length = 32;
if (!std::exchange(finished_, true)) if (!AuExchange(finished_, true))
{ {
sha256_done(&state_, reinterpret_cast<unsigned char *>(buffer_)); sha256_done(&state_, reinterpret_cast<unsigned char *>(buffer_));
} }
return buffer_; return buffer_;
case EHashType::eSHA2_64: case EHashType::eSHA2_64:
length = 64; length = 64;
if (!std::exchange(finished_, true)) if (!AuExchange(finished_, true))
{ {
sha512_done(&state_, reinterpret_cast<unsigned char *>(buffer_)); sha512_done(&state_, reinterpret_cast<unsigned char *>(buffer_));
} }
return buffer_; return buffer_;
case EHashType::eTiger: case EHashType::eTiger:
length = 24; length = 24;
if (!std::exchange(finished_, true)) if (!AuExchange(finished_, true))
{ {
tiger_done(&state_, reinterpret_cast<unsigned char *>(buffer_)); tiger_done(&state_, reinterpret_cast<unsigned char *>(buffer_));
} }

8
Source/IO/FS/Async.NT.cpp
View File

@ -183,7 +183,7 @@ namespace Aurora::IO::FS
bool NtAsyncFileTransaction::StartRead(AuUInt64 offset, void *buffer, AuUInt32 length) bool NtAsyncFileTransaction::StartRead(AuUInt64 offset, void *buffer, AuUInt32 length)
{ {
if (std::exchange(this->pin_, AuSharedFromThis())) if (AuExchange(this->pin_, AuSharedFromThis()))
{ {
return {}; return {};
} }
@ -197,7 +197,7 @@ namespace Aurora::IO::FS
bool NtAsyncFileTransaction::StartWrite(AuUInt64 offset, const void *buffer, AuUInt32 length) bool NtAsyncFileTransaction::StartWrite(AuUInt64 offset, const void *buffer, AuUInt32 length)
{ {
if (std::exchange(this->pin_, AuSharedFromThis())) if (AuExchange(this->pin_, AuSharedFromThis()))
{ {
return {}; return {};
} }
@ -211,12 +211,12 @@ namespace Aurora::IO::FS
void NtAsyncFileTransaction::DispatchCb() void NtAsyncFileTransaction::DispatchCb()
{ {
if (std::exchange(this->latch_, true)) if (AuExchange(this->latch_, true))
{ {
return; return;
} }
auto hold = std::exchange(this->pin_, {}); auto hold = AuExchange(this->pin_, {});
if (hold->sub_) if (hold->sub_)
{ {

4
Source/IO/FS/FS.NT.cpp
View File

@ -70,7 +70,7 @@ namespace Aurora::IO::FS
{ {
DWORD written; DWORD written;
int blockSize = std::min(static_cast<AuUInt64>(kFileCopyBlock), static_cast<AuUInt64>(length)); int blockSize = AuMin(static_cast<AuUInt64>(kFileCopyBlock), static_cast<AuUInt64>(length));
if (!::WriteFile(fileHandle, &reinterpret_cast<const char *>(data)[offset], blockSize, &written, NULL)) if (!::WriteFile(fileHandle, &reinterpret_cast<const char *>(data)[offset], blockSize, &written, NULL))
{ {
@ -129,7 +129,7 @@ namespace Aurora::IO::FS
{ {
DWORD read; DWORD read;
int blockSize = std::min(static_cast<AuUInt64>(kFileCopyBlock), static_cast<AuUInt64>(length.QuadPart)); int blockSize = AuMin(static_cast<AuUInt64>(kFileCopyBlock), static_cast<AuUInt64>(length.QuadPart));
if (!::ReadFile(fileHandle, &buffer[offset], blockSize, &read, NULL)) if (!::ReadFile(fileHandle, &buffer[offset], blockSize, &read, NULL))
{ {

4
Source/IO/FS/FileStream.NT.cpp
View File

@ -103,7 +103,7 @@ namespace Aurora::IO::FS
{ {
DWORD read; DWORD read;
int blockSize = std::min(kFileCopyBlock, length); int blockSize = AuMin(kFileCopyBlock, length);
if (!::ReadFile(handle_, reinterpret_cast<char *>(parameters.ptr) + offset, blockSize, &read, NULL)) if (!::ReadFile(handle_, reinterpret_cast<char *>(parameters.ptr) + offset, blockSize, &read, NULL))
{ {
@ -144,7 +144,7 @@ namespace Aurora::IO::FS
{ {
DWORD written; DWORD written;
int blockSize = std::min(kFileCopyBlock, length); int blockSize = AuMin(kFileCopyBlock, length);
if (!::WriteFile(handle_, reinterpret_cast<const char *>(parameters.ptr) + offset, blockSize, &written, NULL)) if (!::WriteFile(handle_, reinterpret_cast<const char *>(parameters.ptr) + offset, blockSize, &written, NULL))
{ {

4
Source/IO/FS/Resources.cpp
View File

@ -22,7 +22,7 @@
namespace Aurora::IO::FS namespace Aurora::IO::FS
{ {
#if defined(AURORA_PLATFORM_WIN32) #if defined(AURORA_PLATFORM_WIN32)
static void Win32FixGlobalAppDataAcl(const std::string &path); static void Win32FixGlobalAppDataAcl(const AuString &path);
#endif #endif
static AuString gHomeDirectory; static AuString gHomeDirectory;
@ -337,7 +337,7 @@ namespace Aurora::IO::FS
} }
#if defined(AURORA_PLATFORM_WIN32) #if defined(AURORA_PLATFORM_WIN32)
static void Win32FixGlobalAppDataAcl(const std::string &path) static void Win32FixGlobalAppDataAcl(const AuString &path)
{ {
BOOL bRetval = FALSE; BOOL bRetval = FALSE;

4
Source/IO/Net/SocketStatAverageBps.hpp
View File

@ -62,8 +62,8 @@ namespace Aurora::IO::Net
if (nextTick < timeNow) if (nextTick < timeNow)
{ {
frameLastEnd = timeNow; frameLastEnd = timeNow;
frameLastStart = std::exchange(frameStart, timeNow); frameLastStart = AuExchange(frameStart, timeNow);
lastBytesTransferred = std::exchange(bytesTransferred, bytes); lastBytesTransferred = AuExchange(bytesTransferred, bytes);
frameZero = true; frameZero = true;
} }
else else

12
Source/Locale/Encoding/ConvertInternal.cpp
View File

@ -142,7 +142,7 @@ namespace Aurora::Locale::Encoding
AuStreamReadWrittenPair_t EncodeUTF8Internal(const void *utf8, AuUInt32 utf8Length, void *binary, AuUInt32 binaryLength, ECodePage page) AuStreamReadWrittenPair_t EncodeUTF8Internal(const void *utf8, AuUInt32 utf8Length, void *binary, AuUInt32 binaryLength, ECodePage page)
{ {
AuStreamReadWrittenPair_t ret {}; AuStreamReadWrittenPair_t ret {};
auto readable = std::min(AuUInt(utf8Length), AuUInt(binaryLength)); auto readable = AuMin(AuUInt(utf8Length), AuUInt(binaryLength));
AuList<AuUInt8> temp; AuList<AuUInt8> temp;
if (!binary) if (!binary)
@ -168,7 +168,7 @@ namespace Aurora::Locale::Encoding
case ECodePage::eUTF8: case ECodePage::eUTF8:
if (utf8 && binary) if (utf8 && binary)
{ {
std::memcpy(binary, utf8, readable); AuMemcpy(binary, utf8, readable);
} }
ret = AuMakePair(utf8Length, binary ? binaryLength : utf8Length); ret = AuMakePair(utf8Length, binary ? binaryLength : utf8Length);
break; break;
@ -190,7 +190,7 @@ namespace Aurora::Locale::Encoding
} }
AuList<AuUInt8> rw(reinterpret_cast<const AuUInt8 *>(binary), reinterpret_cast<const AuUInt8 *>(binary) + binaryLength); AuList<AuUInt8> rw(reinterpret_cast<const AuUInt8 *>(binary), reinterpret_cast<const AuUInt8 *>(binary) + binaryLength);
auto readable = std::min(AuUInt(binaryLength), AuUInt(utf8Max)); auto readable = AuMin(AuUInt(binaryLength), AuUInt(utf8Max));
switch (page) switch (page)
{ {
@ -208,7 +208,7 @@ namespace Aurora::Locale::Encoding
case ECodePage::eUTF8: case ECodePage::eUTF8:
if (utf8 && binary) if (utf8 && binary)
{ {
std::memcpy(utf8, binary, readable); AuMemcpy(utf8, binary, readable);
} }
ret = AuMakePair(binaryLength, utf8 ? utf8Max : binaryLength); ret = AuMakePair(binaryLength, utf8 ? utf8Max : binaryLength);
break; break;
@ -229,7 +229,7 @@ namespace Aurora::Locale::Encoding
} }
AuList<AuUInt8> rw(reinterpret_cast<const AuUInt8 *>(binary), reinterpret_cast<const AuUInt8 *>(binary) + binaryLength); AuList<AuUInt8> rw(reinterpret_cast<const AuUInt8 *>(binary), reinterpret_cast<const AuUInt8 *>(binary) + binaryLength);
auto readable = std::min(AuUInt(binaryLength), AuUInt(utf8Max)); auto readable = AuMin(AuUInt(binaryLength), AuUInt(utf8Max));
switch (page) switch (page)
{ {
@ -247,7 +247,7 @@ namespace Aurora::Locale::Encoding
case ECodePage::eUTF8: case ECodePage::eUTF8:
if (utf8 && binary) if (utf8 && binary)
{ {
std::memcpy(utf8, binary, readable); AuMemcpy(utf8, binary, readable);
} }
ret = AuMakePair(binaryLength, utf8 ? utf8Max : binaryLength); ret = AuMakePair(binaryLength, utf8 ? utf8Max : binaryLength);
break; break;

8
Source/Locale/Encoding/EncoderAdapter.cpp
View File

@ -57,10 +57,10 @@ namespace Aurora::Locale::Encoding
{ {
length = CountUTF8Length({in, length}, true); length = CountUTF8Length({in, length}, true);
auto readable = std::min(length, utf8Max); auto readable = AuMin(length, utf8Max);
if (utf8 && in) if (utf8 && in)
{ {
std::memcpy(utf8, in, readable); AuMemcpy(utf8, in, readable);
} }
return {readable, readable}; return {readable, readable};
@ -110,10 +110,10 @@ namespace Aurora::Locale::Encoding
if (TestPage(ECodePage::eUTF8)) if (TestPage(ECodePage::eUTF8))
{ {
auto readable = std::min(utf8Length, cpLen); auto readable = AuMin(utf8Length, cpLen);
if (utf8 && cp) if (utf8 && cp)
{ {
std::memcpy(cp, utf8, readable); AuMemcpy(cp, utf8, readable);
} }
return {utf8Length, utf8 ? cpLen : utf8Length}; return {utf8Length, utf8 ? cpLen : utf8Length};
} }

2
Source/Locale/Encoding/Encoding.hpp
View File

@ -36,7 +36,7 @@ namespace Aurora::Locale::Encoding
if (!binary) return {}; if (!binary) return {};
if (!binaryLength) return {}; if (!binaryLength) return {};
if (!std::exchange(readHeader, true)) if (!AuExchange(readHeader, true))
{ {
if (page == ECodePage::eUnsupported) if (page == ECodePage::eUnsupported)
{ {

6
Source/Locale/Locale.cpp
View File

@ -135,7 +135,7 @@ namespace Aurora::Locale
} }
else else
{ {
gCodeset = "MS-" + std::to_string(acp); gCodeset = "MS-" + AuToString(acp);
gInternalCodePage = ECodePage::eSysUnk; gInternalCodePage = ECodePage::eSysUnk;
} }
} }
@ -206,7 +206,7 @@ namespace Aurora::Locale
{ {
#if 0 #if 0
// this doesn't seem to work with libc++ lol? // this doesn't seem to work with libc++ lol?
auto locale = std::locale("").name(); auto locale = -std::--locale("").name();
#else #else
setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
AuString locale = setlocale(LC_ALL, NULL); AuString locale = setlocale(LC_ALL, NULL);
@ -352,7 +352,7 @@ namespace Aurora::Locale
AUKN_SYM void RuntimeOverloadLocality(const AuPair<AuString, AuString> &locality) AUKN_SYM void RuntimeOverloadLocality(const AuPair<AuString, AuString> &locality)
{ {
SysAssert(!std::exchange(gLockLocale, true), "Locality has been locked"); SysAssert(!AuExchange(gLockLocale, true), "Locality has been locked");
gLanguageCode = AuToLower(locality.first); gLanguageCode = AuToLower(locality.first);
gCountryCode = AuToUpper(locality.second); gCountryCode = AuToUpper(locality.second);
} }

4
Source/Memory/Heap.cpp
View File

@ -182,7 +182,7 @@ namespace Aurora::Memory
auto prevLength = GetHeapSize(buffer); auto prevLength = GetHeapSize(buffer);
auto alloc = _ZAlloc(length); auto alloc = _ZAlloc(length);
if (!alloc) return nullptr; if (!alloc) return nullptr;
std::memcpy(alloc, buffer, std::min(prevLength, length)); AuMemcpy(alloc, buffer, AuMin(prevLength, length));
_Free(buffer); _Free(buffer);
return alloc; return alloc;
} }
@ -198,7 +198,7 @@ namespace Aurora::Memory
auto prevLength = GetHeapSize(buffer); auto prevLength = GetHeapSize(buffer);
auto alloc = _FAlloc(length); auto alloc = _FAlloc(length);
if (!alloc) return nullptr; if (!alloc) return nullptr;
std::memcpy(alloc, buffer, std::min(prevLength, length)); AuMemcpy(alloc, buffer, AuMin(prevLength, length));
_Free(buffer); _Free(buffer);
return alloc; return alloc;
} }

4
Source/Parse/Hex.cpp
View File

@ -44,7 +44,7 @@ namespace Aurora::Parse
AUKN_SYM bool HexToInt(const char *hex, AuUInt32 length, AuUInt64 &val) AUKN_SYM bool HexToInt(const char *hex, AuUInt32 length, AuUInt64 &val)
{ {
val = 0; val = 0;
length = std::min(AuUInt32(sizeof(AuUInt64) * 2), length); length = AuMin(AuUInt32(sizeof(AuUInt64) * 2), length);
for (auto i = 0u; i < length; i++) for (auto i = 0u; i < length; i++)
{ {
@ -247,7 +247,7 @@ namespace Aurora::Parse
in.insert(in.size(), " "); in.insert(in.size(), " ");
} }
rowMax = std::min(AuUInt32(i + 16), AuUInt32(length)); rowMax = AuMin(AuUInt32(i + 16), AuUInt32(length));
for (x = i; for (x = i;
x < rowMax; x < rowMax;

36
Source/Parse/Parser.cpp
View File

@ -26,7 +26,7 @@ namespace Aurora::Parse
bool Next(AuUInt8 &c) bool Next(AuUInt8 &c)
{ {
if (std::exchange(_hasNext, false)) if (AuExchange(_hasNext, false))
{ {
c = _next; c = _next;
return true; return true;
@ -50,7 +50,7 @@ namespace Aurora::Parse
}; };
template<size_t Z> template<size_t Z>
static std::function<bool(AuUInt8)> ContainedHerein(const AuUInt8(&arry)[Z]) static AuFunction<bool(AuUInt8)> ContainedHerein(const AuUInt8(&arry)[Z])
{ {
return [=](AuUInt8 c) -> bool return [=](AuUInt8 c) -> bool
{ {
@ -67,7 +67,7 @@ namespace Aurora::Parse
template<size_t Z> template<size_t Z>
static std::function<bool(AuUInt8)> IsTerminating(ParseState &state, const AuUInt8(&arry)[Z]) static AuFunction<bool(AuUInt8)> IsTerminating(ParseState &state, const AuUInt8(&arry)[Z])
{ {
return [&](AuUInt8 c) -> bool return [&](AuUInt8 c) -> bool
{ {
@ -131,7 +131,7 @@ namespace Aurora::Parse
if (isTerminating(next)) if (isTerminating(next))
{ {
// Make sure we aren't encapsulated by quotation marks // Make sure we aren't encapsulated by quotation marks
if ((!stringLevel) && (!std::exchange(escapedNewLine, false))) if ((!stringLevel) && (!AuExchange(escapedNewLine, false)))
{ {
state.hasLastToken = true; state.hasLastToken = true;
state.lastTokenCharacter = next; state.lastTokenCharacter = next;
@ -172,7 +172,7 @@ namespace Aurora::Parse
} }
// see above // see above
if ((next == '"') && (isString) && (std::exchange(escapedQuote, false))) if ((next == '"') && (isString) && (AuExchange(escapedQuote, false)))
{ {
out += "\""; out += "\"";
continue; continue;
@ -261,7 +261,7 @@ namespace Aurora::Parse
res *= 10; res *= 10;
res += static_cast<AuUInt>(*itr) - static_cast<AuUInt>('0'); res += static_cast<AuUInt>(*itr) - static_cast<AuUInt>('0');
if constexpr (std::is_same<T, AuUInt>::value) if constexpr (AuIsSame_v<T, AuUInt>)
{ {
if (old > res) if (old > res)
{ {
@ -269,7 +269,7 @@ namespace Aurora::Parse
return false; return false;
} }
} }
else if constexpr (std::is_same<T, AuSInt>::value) else if constexpr (AuIsSame_v<T, AuSInt>)
{ {
if (SignBit(old) != SignBit(res)) if (SignBit(old) != SignBit(res))
{ {
@ -548,32 +548,32 @@ namespace Aurora::Parse
{ {
case ParsableTag::kParseUInt: case ParsableTag::kParseUInt:
{ {
str += std::to_string(value.primitive.uint); str += AuToString(value.primitive.uint);
break; break;
} }
case ParsableTag::kParseSInt: case ParsableTag::kParseSInt:
{ {
str += std::to_string(value.primitive.sint); str += AuToString(value.primitive.sint);
break; break;
} }
case ParsableTag::kParseNumber: case ParsableTag::kParseNumber:
{ {
str += std::to_string(value.primitive.number); str += AuToString(value.primitive.number);
break; break;
} }
case ParsableTag::kParseVec3: case ParsableTag::kParseVec3:
{ {
str += std::to_string(value.primitive.vec3[0]) + " "; str += AuToString(value.primitive.vec3[0]) + " ";
str += std::to_string(value.primitive.vec3[1]) + " "; str += AuToString(value.primitive.vec3[1]) + " ";
str += std::to_string(value.primitive.vec3[2]); str += AuToString(value.primitive.vec3[2]);
break; break;
} }
case ParsableTag::kParseVec4: case ParsableTag::kParseVec4:
{ {
str += std::to_string(value.primitive.vec4[0]) + " "; str += AuToString(value.primitive.vec4[0]) + " ";
str += std::to_string(value.primitive.vec4[1]) + " "; str += AuToString(value.primitive.vec4[1]) + " ";
str += std::to_string(value.primitive.vec4[2]) + " "; str += AuToString(value.primitive.vec4[2]) + " ";
str += std::to_string(value.primitive.vec4[3]); str += AuToString(value.primitive.vec4[3]);
break; break;
} }
case ParsableTag::kParseString: case ParsableTag::kParseString:
@ -617,7 +617,7 @@ namespace Aurora::Parse
if (parsed.isArray) if (parsed.isArray)
{ {
ret += " "; ret += " ";
ret += std::to_string(parsed.count); ret += AuToString(parsed.count);
} }
bool isArray = parsed.count > 1 || parsed.isArray; bool isArray = parsed.count > 1 || parsed.isArray;

2
Source/Process/Paths.cpp
View File

@ -140,7 +140,7 @@ namespace Aurora::Process
static bool init = false; static bool init = false;
char spitter; char spitter;
if (std::exchange(init, true)) if (AuExchange(init, true))
{ {
if (!cachedModule.size()) if (!cachedModule.size())
{ {

4
Source/Processes/Process.Win32.cpp
View File

@ -219,7 +219,7 @@ namespace Aurora::Processes
bool ProcessImpl::Read(void *buffer, AuUInt32 &len, bool errorStream, bool nonblock) bool ProcessImpl::Read(void *buffer, AuUInt32 &len, bool errorStream, bool nonblock)
{ {
DWORD size = std::exchange(len, 0); DWORD size = AuExchange(len, 0);
auto handle = errorStream ? pipeStdErrRead_ : pipeStdOutRead_; auto handle = errorStream ? pipeStdErrRead_ : pipeStdOutRead_;
if (handle == INVALID_HANDLE_VALUE) if (handle == INVALID_HANDLE_VALUE)
@ -240,7 +240,7 @@ namespace Aurora::Processes
return true; return true;
} }
size = std::min(size, avail); size = AuMin(size, avail);
} }
auto ret = ReadFile(handle, buffer, size, &size, NULL); auto ret = ReadFile(handle, buffer, size, &size, NULL);

4
Source/RNG/WELL.cpp
View File

@ -101,14 +101,14 @@ void WELL_NextBytes(WELLRand *rand, void *in, AuUInt32 length)
for (; i < length; i += 4) for (; i < length; i += 4)
{ {
AuUInt32 rng = WELL_NextLong_Unlocked(rand); AuUInt32 rng = WELL_NextLong_Unlocked(rand);
std::memcpy(base + i, &rng, 4); AuMemcpy(base + i, &rng, 4);
} }
if (i > length) if (i > length)
{ {
i -= 4; i -= 4;
AuUInt32 padRng = WELL_NextLong_Unlocked(rand); AuUInt32 padRng = WELL_NextLong_Unlocked(rand);
std::memcpy(base + i, &padRng, length - i); AuMemcpy(base + i, &padRng, length - i);
} }
rand->lock.Unlock(); rand->lock.Unlock();

4
Source/Registry/Registry.cpp
View File

@ -227,12 +227,12 @@ namespace Aurora::Registry
json object {}; json object {};
AuString stringified; AuString stringified;
if (std::find(restrictedKeys_.begin(), restrictedKeys_.end(), key) != restrictedKeys_.end()) if (writeMode_ == EWriteMode::eWriteModeLocked)
{ {
return false; return false;
} }
if (writeMode_ == EWriteMode::eWriteModeLocked) if (AuExists(restrictedKeys_, key))
{ {
return false; return false;
} }

14
Source/Threading/Threads/OSThread.cpp
View File

@ -85,8 +85,8 @@ namespace Aurora::Threading::Threads
AU_LOCK_GUARD(this->tlsLock_); AU_LOCK_GUARD(this->tlsLock_);
AU_LOCK_GUARD(this->tlsReferenceThread_->tlsLock_); AU_LOCK_GUARD(this->tlsReferenceThread_->tlsLock_);
std::exchange(this->tlsReferenceThread_->tls_, this->tls_); AuExchange(this->tlsReferenceThread_->tls_, this->tls_);
std::exchange(this->tlsReferenceThread_->threadFeatures_, this->threadFeatures_); AuExchange(this->tlsReferenceThread_->threadFeatures_, this->threadFeatures_);
bDetachedSuccess = true; bDetachedSuccess = true;
} }
@ -160,7 +160,7 @@ namespace Aurora::Threading::Threads
SysPanic("::Run called on system thread"); SysPanic("::Run called on system thread");
} }
if (std::exchange(contextUsed_, true)) if (AuExchange(contextUsed_, true))
{ {
return false; return false;
} }
@ -299,7 +299,7 @@ namespace Aurora::Threading::Threads
return tls_; return tls_;
} }
bool OSThread::ExecuteNewOSContext(std::function<void()> task) bool OSThread::ExecuteNewOSContext(AuFunction<void()> task)
{ {
task_ = task; task_ = task;
@ -377,7 +377,7 @@ namespace Aurora::Threading::Threads
if (info_.stackSize) if (info_.stackSize)
{ {
ret = pthread_attr_setstacksize(&tattr, std::min(AuUInt32(PTHREAD_STACK_MIN), info_.stackSize)); ret = pthread_attr_setstacksize(&tattr, AuMin(AuUInt32(PTHREAD_STACK_MIN), info_.stackSize));
if (ret != 0) if (ret != 0)
{ {
SysPushErrorGen("Couldn't create thread: {}", GetName()); SysPushErrorGen("Couldn't create thread: {}", GetName());
@ -413,7 +413,7 @@ namespace Aurora::Threading::Threads
Exit(true); Exit(true);
} }
void OSThread::ExecuteInDeadThread(std::function<void()> callback) void OSThread::ExecuteInDeadThread(AuFunction<void()> callback)
{ {
auto old = HandleCurrent(); auto old = HandleCurrent();
@ -718,7 +718,7 @@ namespace Aurora::Threading::Threads
void OSThread::FreeOSContext() void OSThread::FreeOSContext()
{ {
#if defined(AURORA_IS_MODERNNT_DERIVED) #if defined(AURORA_IS_MODERNNT_DERIVED)
if (auto handle = std::exchange(handle_, {})) if (auto handle = AuExchange(handle_, {}))
{ {
CloseHandle(handle_); CloseHandle(handle_);
} }

6
Source/Threading/Threads/OSThread.hpp
View File

@ -32,7 +32,7 @@ namespace Aurora::Threading::Threads
AuSPtr<TLSView> GetTlsView() override; AuSPtr<TLSView> GetTlsView() override;
void ExecuteInDeadThread(std::function<void()> callback) override; void ExecuteInDeadThread(AuFunction<void()> callback) override;
AuSPtr<IWaitable> AsWaitable() override; AuSPtr<IWaitable> AsWaitable() override;
void AddLastHopeTlsHook(const AuSPtr<Threading::Threads::IThreadFeature> &feature) override; void AddLastHopeTlsHook(const AuSPtr<Threading::Threads::IThreadFeature> &feature) override;
@ -46,7 +46,7 @@ namespace Aurora::Threading::Threads
protected: protected:
bool Exit(bool willReturnToOS); bool Exit(bool willReturnToOS);
bool ExecuteNewOSContext(std::function<void()> task); bool ExecuteNewOSContext(AuFunction<void()> task);
void UpdatePrio(EThreadPrio prio); void UpdatePrio(EThreadPrio prio);
void UpdateAffinity(AuUInt32 mask); void UpdateAffinity(AuUInt32 mask);
void UpdateName(); void UpdateName();
@ -79,7 +79,7 @@ namespace Aurora::Threading::Threads
AuList<AuSPtr<IThreadFeature>> threadFeatures_; AuList<AuSPtr<IThreadFeature>> threadFeatures_;
std::function<void()> task_; AuFunction<void()> task_;
#if defined(AURORA_IS_MODERNNT_DERIVED) #if defined(AURORA_IS_MODERNNT_DERIVED)
HANDLE handle_ = INVALID_HANDLE_VALUE; HANDLE handle_ = INVALID_HANDLE_VALUE;

2
Source/Threading/Threads/TLSView.hpp
View File

@ -22,7 +22,7 @@ namespace Aurora::Threading::Threads
void ConsiderRehash(); void ConsiderRehash();
Primitives::SpinLock lock_; Primitives::SpinLock lock_;
AuHashMap<AuUInt64, std::pair<void*, TlsCb>> tls_; AuHashMap<AuUInt64, AuPair<void*, TlsCb>> tls_;
AuUInt64 fence_ = 0; AuUInt64 fence_ = 0;
}; };
} }

4
Source/Threading/WaitFor.cpp
View File

@ -113,7 +113,7 @@ namespace Aurora::Threading
{ {
#if defined(AURORA_IS_LINUX_DERIVED) #if defined(AURORA_IS_LINUX_DERIVED)
int alpha = getpriority(PRIO_PROCESS, 0); int alpha = getpriority(PRIO_PROCESS, 0);
int bravo = std::min(15, std::max(19, alpha + 5)); int bravo = AuMin(15, AuMax(19, alpha + 5));
#else #else
int alpha, bravo = 0; int alpha, bravo = 0;
#endif #endif
@ -133,7 +133,7 @@ namespace Aurora::Threading
{ {
#if defined(AURORA_IS_LINUX_DERIVED) #if defined(AURORA_IS_LINUX_DERIVED)
int alpha = getpriority(PRIO_PROCESS, 0); int alpha = getpriority(PRIO_PROCESS, 0);
int bravo = std::min(15, std::max(19, alpha + 5)); int bravo = AuMin(15, AuMax(19, alpha + 5));
#else #else
int alpha, bravo = 0; int alpha, bravo = 0;
#endif #endif