EmsiaetKadosh
275 lines
15 KiB
C++
275 lines
15 KiB
C++
//
|
|
// Created by EmsiaetKadosh on 25-1-14.
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#define __CARLBEKS_DEBUG__
|
|
#define __CARLBEKS_MEMORY__ 1
|
|
|
|
#pragma warning(disable: 4819)
|
|
|
|
#include <typeinfo>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <list>
|
|
#include <string>
|
|
#include <map>
|
|
#include <atomic>
|
|
#include <thread>
|
|
#include <fstream>
|
|
|
|
using wchar = wchar_t;
|
|
using QWORD = unsigned long long int;
|
|
using String = std::wstring;
|
|
using Thread = std::thread;
|
|
template<typename K, typename V, typename Cmp = std::less<K>, typename Alloc = std::allocator<std::pair<const K, V>>> using Map = std::map<K, V, Cmp, Alloc>;
|
|
template<typename T, typename Alloc = std::allocator<T>> using List = std::list<T, Alloc>;
|
|
template<typename F> using Function = std::function<F>;
|
|
|
|
#define Success() { return 0; }
|
|
#define Failed() { return 1; }
|
|
#define Error() { return -1; }
|
|
|
|
#define _WINSOCKAPI_ /* 防止winsock.h被引入。winsock.h和winsock2.h冲突。 */
|
|
#if false
|
|
#include <WinSock2.h>
|
|
#endif
|
|
|
|
#define NOMINMAX
|
|
#include <Windows.h>
|
|
#include <Windowsx.h>
|
|
#include <minwindef.h>
|
|
#include <windef.h>
|
|
#include <wingdi.h>
|
|
#include <WinUser.h>
|
|
#include <Uxtheme.h>
|
|
#include <iostream>
|
|
#include <dwmapi.h>
|
|
|
|
#define WM_APP_LBUTTONUP (WM_APP + 1)
|
|
#define WM_APP_MBUTTONDOWN (WM_APP + 2)
|
|
|
|
#pragma comment(lib, "Msimg32.lib")
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
#pragma comment(lib, "dwmapi.lib")
|
|
#pragma comment(lib, "Uxtheme.lib")
|
|
#pragma comment(lib, "winmm.lib")
|
|
|
|
template<typename T>
|
|
concept Copyable = requires(const T& t) { T(t); };
|
|
template<typename T>
|
|
concept NewCopyable = requires(const T& t) { delete new T(t); };
|
|
template<typename T>
|
|
concept Moveable = requires(T&& t) { T(std::move(t)); };
|
|
template<typename T>
|
|
concept NewMoveable = requires(T&& t) { delete new T(std::move(t)); };
|
|
template<typename T>
|
|
concept NonreferenceType = !std::is_reference_v<T>;
|
|
template<typename T>
|
|
concept NonpointerType = !std::is_pointer_v<T>;
|
|
template<typename T>
|
|
concept ReferenceType = std::is_reference_v<T>;
|
|
template<typename T>
|
|
concept PointerType = std::is_pointer_v<T>;
|
|
template<typename T>
|
|
concept TypeName = NonreferenceType<T> && NonpointerType<T>;
|
|
|
|
inline std::wfstream& MainLogFile = *new std::wfstream(L"log.txt", std::ios::out | std::ios::trunc);
|
|
|
|
struct MemoryManager {
|
|
struct MemoryInfo {
|
|
std::size_t size;
|
|
const String msg;
|
|
};
|
|
|
|
Map<void*, MemoryInfo> allocated;
|
|
} inline memoryManager;
|
|
|
|
void requireNonnull(const void* value) noexcept(false);
|
|
inline String ptrtow(QWORD value);
|
|
|
|
#if defined __CARLBEKS_DEBUG__ || defined __CARLBEKS_MEMORY__
|
|
void printAllocate(void* value, std::size_t size, const String&);
|
|
void printDeallocate(void* value, std::size_t size, const String&);
|
|
extern String atow(const char* chars);
|
|
|
|
template<typename T> T* _allocatedFor(T* value, const String& msg = L"", std::size_t size = sizeof(T)) {
|
|
requireNonnull(value);
|
|
const auto& k = memoryManager.allocated.emplace(value, MemoryManager::MemoryInfo{ size, L"[" + atow(typeid(T).name()) + L"] " + msg }).first;
|
|
#if __CARLBEKS_MEMORY__ > 1
|
|
printAllocate(value, k->second.size, k->second.msg);
|
|
#endif
|
|
return value;
|
|
}
|
|
|
|
template<typename T> T* _deallocating(T* value) {
|
|
#if __CARLBEKS_MEMORY__ > 1
|
|
const MemoryManager::MemoryInfo* info = nullptr;
|
|
if (memoryManager.allocated.contains(value)) info = &memoryManager.allocated.at(value);
|
|
printDeallocate(value, info ? info->size : 0, info ? info->msg : L"???");
|
|
#endif
|
|
if (value) memoryManager.allocated.erase(value);
|
|
return value;
|
|
}
|
|
|
|
#if __CARLBEKS_MEMORY__ > 3
|
|
#define allocatedFor(val, ...) _allocatedFor(val, L"\n From " __FUNCSIG__ "\n At " __FILE__ ":" _STL_STRINGIZE(__LINE__) __VA_OPT__(,) __VA_ARGS__)
|
|
#else
|
|
#define allocatedFor(val, ...) _allocatedFor(val, L"" __VA_OPT__(,) __VA_ARGS__)
|
|
#endif
|
|
#define deallocating(val) _deallocating(val)
|
|
#else
|
|
#define allocatedFor(val, ...) val
|
|
#define deallocating(val) val
|
|
#endif
|
|
|
|
|
|
template<TypeName Base> class ObjectHolder {
|
|
Base* value;
|
|
bool hasValue;
|
|
char padding[7]{};
|
|
|
|
public:
|
|
/**
|
|
* 用于延迟初始化。
|
|
*/
|
|
ObjectHolder() : value(nullptr), hasValue(false) {}
|
|
|
|
// ReSharper disable once CppNonExplicitConvertingConstructor
|
|
ObjectHolder(Base* value) : value(value), hasValue(false) {}
|
|
|
|
// ReSharper disable once CppNonExplicitConvertingConstructor
|
|
template<NewCopyable T> requires (std::is_base_of_v<Base, T> || std::is_same_v<Base, T>) && TypeName<T>
|
|
ObjectHolder(const T& value) : value(allocatedFor(new T(value))), hasValue(true) {}
|
|
|
|
// ReSharper disable once CppNonExplicitConvertingConstructor
|
|
template<NewMoveable T> requires (std::is_base_of_v<Base, T> || std::is_same_v<Base, T>) && TypeName<T>
|
|
ObjectHolder(T&& value) : value(allocatedFor(new T(std::forward<T>(value)))), hasValue(true) {}
|
|
|
|
ObjectHolder(const ObjectHolder& other) noexcept: value(other.value), hasValue(false) {}
|
|
|
|
ObjectHolder(ObjectHolder&& other) noexcept: value(other.value), hasValue(other.hasValue) {
|
|
other.value = nullptr;
|
|
other.hasValue = false;
|
|
}
|
|
|
|
template<NewCopyable T> requires std::is_base_of_v<Base, T> && TypeName<T>
|
|
void set(const T& value);
|
|
|
|
template<NewMoveable T> requires std::is_base_of_v<Base, T> && TypeName<T>
|
|
void set(T&& value);
|
|
|
|
~ObjectHolder() {
|
|
if (hasValue) delete deallocating(value);
|
|
value = nullptr;
|
|
}
|
|
|
|
[[nodiscard]] Base* operator->() noexcept(false) {
|
|
requireNonnull(value);
|
|
return value;
|
|
}
|
|
|
|
[[nodiscard]] const Base* operator->() const noexcept(false) {
|
|
requireNonnull(value);
|
|
return value;
|
|
}
|
|
|
|
[[nodiscard]] Base& operator*() noexcept(false) {
|
|
requireNonnull(value);
|
|
return *value;
|
|
}
|
|
|
|
[[nodiscard]] const Base& operator*() const noexcept(false) {
|
|
requireNonnull(value);
|
|
return *value;
|
|
}
|
|
|
|
[[nodiscard]] Base& get() noexcept(false) {
|
|
requireNonnull(value);
|
|
return *value;
|
|
}
|
|
|
|
[[nodiscard]] const Base& get() const noexcept(false) {
|
|
requireNonnull(value);
|
|
return *value;
|
|
}
|
|
|
|
// ReSharper disable once CppNonExplicitConversionOperator
|
|
Base* ptr() const noexcept { return value; }
|
|
operator bool() const noexcept { return value; }
|
|
bool operator!() const noexcept { return value == nullptr; }
|
|
bool isManager() const noexcept { return hasValue; }
|
|
};
|
|
|
|
template<TypeName Base> class SynchronizedHolder {
|
|
mutable Base* newValue = nullptr;
|
|
mutable Base* value = nullptr;
|
|
mutable bool isOk = false;
|
|
|
|
public:
|
|
SynchronizedHolder() = default;
|
|
|
|
~SynchronizedHolder() {
|
|
if (newValue == value) { if (value) delete deallocating(value); } else {
|
|
if (newValue) delete deallocating(newValue);
|
|
if (value) delete deallocating(value);
|
|
}
|
|
newValue = nullptr;
|
|
value = nullptr;
|
|
}
|
|
|
|
|
|
template<NewCopyable T> requires std::is_base_of_v<Base, T> && TypeName<T>
|
|
void setNew(const Base& other) noexcept {
|
|
isOk = false;
|
|
if (newValue && newValue != value) deleteNew();
|
|
newValue = allocatedFor(new T(other));
|
|
}
|
|
|
|
template<NewMoveable T> requires std::is_base_of_v<Base, T> && TypeName<T>
|
|
void setNew(T&& val) noexcept {
|
|
isOk = false;
|
|
if (newValue && newValue != value) deleteNew();
|
|
newValue = allocatedFor(new T(std::forward<T>(val)));
|
|
}
|
|
|
|
void ok() const noexcept { isOk = true; }
|
|
|
|
Base& get() const noexcept(false) {
|
|
requireNonnull(value);
|
|
return *value;
|
|
}
|
|
|
|
Base& getNew() const noexcept(false) {
|
|
requireNonnull(newValue); // 用于抛错
|
|
return *newValue;
|
|
}
|
|
|
|
Base* ptr() const noexcept { return value; }
|
|
Base* ptrNew() const noexcept { return newValue; }
|
|
Base* ptrs() const noexcept { return newValue ? newValue : value; }
|
|
|
|
void async() const noexcept {
|
|
if (newValue == value) return;
|
|
if (!isOk) return;
|
|
Base* nuv = newValue;
|
|
newValue = nullptr;
|
|
if (nuv) {
|
|
if (value && value != nuv) deleteOld();
|
|
value = nuv;
|
|
}
|
|
}
|
|
|
|
private:
|
|
void deleteOld() const noexcept {
|
|
delete deallocating(value);
|
|
value = nullptr;
|
|
}
|
|
|
|
void deleteNew() const noexcept {
|
|
delete deallocating(newValue);
|
|
newValue = nullptr;
|
|
}
|
|
};
|