variant.h

#pragma once

typedef union _variant {
	bool b;
	const bool cb;
	bool* pb;
	const bool* pcb;

	char c;
	char* pc;
	char** ppc;
	char _c[8];

	const char cc;
	const char* pcc;
	const char** ppcc;
	const char _cc[8];

	unsigned char uc;
	unsigned char* puc;
	unsigned char** ppuc;
	unsigned char _uc[8];

	const unsigned char cuc;
	const unsigned char* pcuc;
	const unsigned char** ppcuc;
	const unsigned char _cuc[8];

	wchar_t wc;
	wchar_t* pwc;
	wchar_t** ppwc;
	wchar_t _wc[4];

	const wchar_t cwc;
	const wchar_t* pcwc;
	const wchar_t** ppcwc;
	const wchar_t _cwc[4];

	short s;
	short* ps;
	short** pps;
	short _s[4];

	const short cs;
	const short* pcs;
	const short** ppcs;
	const short _cs[4];

	unsigned short us;
	unsigned short* pus;
	unsigned short** ppus;
	unsigned short _us[4];

	const unsigned short cus;
	const unsigned short* pcus;
	const unsigned short** ppcus;
	const unsigned short _cus[4];

	long l;
	long* pl;
	long** ppl;
	long _l[2];

	const long cl;
	const long* pcl;
	const long** ppcl;
	const long _cl[2];

	unsigned long ul;
	unsigned long* pul;
	unsigned long** ppul;
	unsigned long _ul[2];

	const unsigned long cul;
	const unsigned long* pcul;
	const unsigned long** ppcul;
	const unsigned long _cul[2];

	long long ll;
	long long* pll;
	long long** ppll;

	const long long cll;
	const long long* pcll;
	const long long** ppcll;

	unsigned long long ull;
	unsigned long long* pull;
	unsigned long long** ppull;

	const unsigned long long cull;
	const unsigned long long* pcull;
	const unsigned long long** ppcull;

	float f;
	float* pf;
	float** ppf;
	float _f[2];

	const float cf;
	const float* pcf;
	const float** ppcf;
	const float _cf[2];

	double d;
	double* pd;
	double** ppd;

	const double cd;
	const double* pcd;
	const double** ppcd;

	void* p;
	void** pp;

	const void* cp;
	const void** cpp;

#ifdef _WIN64
	long long lptr;
	long long* plptr;
	long long** pplptr;
	const long long clptr;
	const long long* pclptr;
	const long long** ppclptr;
	unsigned long long ulptr;
	unsigned long long* pulptr;
	unsigned long long** ppulptr;
	const unsigned long long culptr;
	const unsigned long long* pculptr;
	const unsigned long long** ppculptr;
#else
	long lptr;
	long* plptr;
	long** pplptr;
	const long clptr;
	const long* pclptr;
	const long** ppclptr;
	unsigned long ulptr;
	unsigned long* pulptr;
	unsigned long** ppulptr;
	const unsigned long culptr;
	const unsigned long* pculptr;
	const unsigned long** ppculptr;
#endif

	struct {
		int b0 : 1;
		int b1 : 1;
		int b2 : 1;
		int b3 : 1;
		int b4 : 1;
		int b5 : 1;
		int b6 : 1;
		int b7 : 1;
		int b8 : 1;
		int b9 : 1;
		int b10 : 1;
		int b11 : 1;
		int b12 : 1;
		int b13 : 1;
		int b14 : 1;
		int b15 : 1;
		int b16 : 1;
		int b17 : 1;
		int b18 : 1;
		int b19 : 1;
		int b20 : 1;
		int b21 : 1;
		int b22 : 1;
		int b23 : 1;
		int b24 : 1;
		int b25 : 1;
		int b26 : 1;
		int b27 : 1;
		int b28 : 1;
		int b29 : 1;
		int b30 : 1;
		int b31 : 1;
		int b32 : 1;
		int b33 : 1;
		int b34 : 1;
		int b35 : 1;
		int b36 : 1;
		int b37 : 1;
		int b38 : 1;
		int b39 : 1;
		int b40 : 1;
		int b41 : 1;
		int b42 : 1;
		int b43 : 1;
		int b44 : 1;
		int b45 : 1;
		int b46 : 1;
		int b47 : 1;
		int b48 : 1;
		int b49 : 1;
		int b50 : 1;
		int b51 : 1;
		int b52 : 1;
		int b53 : 1;
		int b54 : 1;
		int b55 : 1;
		int b56 : 1;
		int b57 : 1;
		int b58 : 1;
		int b59 : 1;
		int b60 : 1;
		int b61 : 1;
		int b62 : 1;
		int b63 : 1;
	};

	inline _variant& operator= (const _variant& v) noexcept {
		ll = v.ll;
		return *this;
	}
	inline operator const bool() const noexcept {
		return ll;
	}
	inline operator void* () const noexcept {
		return p;
	}

	inline bool operator= (const bool& v) noexcept { return b = v; }
	inline char operator= (const char& v) noexcept { return c = v; }
	inline unsigned char operator= (const unsigned char& v) noexcept { return uc = v; }
	inline short operator= (const short& v) noexcept { return s = v; }
	inline unsigned short operator= (const unsigned short& v) noexcept { return us = v; }
	inline int operator= (const int& v) noexcept { return l = v; }
	inline unsigned int operator= (const unsigned int& v) noexcept { return ul = v; }
	inline long operator= (const long& v) noexcept { return l = v; }
	inline unsigned long operator= (const unsigned long& v) noexcept { return ul = v; }
	inline long long operator= (const long long& v) noexcept { return ll = v; }
	inline unsigned long long operator= (const unsigned long long& v) noexcept { return ull = v; }
	inline float operator= (const float& v) noexcept { return f = v; }
	inline double operator= (const double& v) noexcept { return d = v; }
	inline void* operator= (const void*& v) noexcept { return p = (void*)v; }

	inline char& operator+= (const char& v) noexcept { return c += v; }
	inline unsigned char& operator+= (const unsigned char& v) noexcept { return uc += v; }
	inline short& operator+= (const short& v) noexcept { return s += v; }
	inline unsigned short& operator+= (const unsigned short& v) noexcept { return us += v; }
	inline int& operator+= (const int& v) noexcept { return (int&)(l += v); }
	inline unsigned int& operator+= (const unsigned int& v) noexcept { return (unsigned int&)(ul += v); }
	inline long& operator+= (const long& v) noexcept { return l += v; }
	inline unsigned long& operator+= (const unsigned long& v) noexcept { return ul += v; }
	inline long long& operator+= (const long long& v) noexcept { return ll += v; }
	inline unsigned long long& operator+= (const unsigned long long& v) noexcept { return ull += v; }
	inline float& operator+= (const float& v) noexcept { return f += v; }
	inline double& operator+= (const double& v) noexcept { return d += v; }

	inline char& operator-= (const char& v) noexcept { return c -= v; }
	inline unsigned char& operator-= (const unsigned char& v) noexcept { return uc -= v; }
	inline short& operator-= (const short& v) noexcept { return s -= v; }
	inline unsigned short& operator-= (const unsigned short& v) noexcept { return us -= v; }
	inline int& operator-= (const int& v) noexcept { return (int&)(l -= v); }
	inline unsigned int& operator-= (const unsigned int& v) noexcept { return (unsigned int&)(ul -= v); }
	inline long& operator-= (const long& v) noexcept { return l -= v; }
	inline unsigned long& operator-= (const unsigned long& v) noexcept { return ul -= v; }
	inline long long& operator-= (const long long& v) noexcept { return ll -= v; }
	inline unsigned long long& operator-= (const unsigned long long& v) noexcept { return ull -= v; }
	inline float& operator-= (const float& v) noexcept { return f -= v; }
	inline double& operator-= (const double& v) noexcept { return d -= v; }

	inline char& operator*= (const char& v) noexcept { return c *= v; }
	inline unsigned char& operator*= (const unsigned char& v) noexcept { return uc *= v; }
	inline short& operator*= (const short& v) noexcept { return s *= v; }
	inline unsigned short& operator*= (const unsigned short& v) noexcept { return us *= v; }
	inline int& operator*= (const int& v) noexcept { return (int&)(l *= v); }
	inline unsigned int& operator*= (const unsigned int& v) noexcept { return (unsigned int&)(ul *= v); }
	inline long& operator*= (const long& v) noexcept { return l *= v; }
	inline unsigned long& operator*= (const unsigned long& v) noexcept { return ul *= v; }
	inline long long& operator*= (const long long& v) noexcept { return ll *= v; }
	inline unsigned long long& operator*= (const unsigned long long& v) noexcept { return ull *= v; }
	inline float& operator*= (const float& v) noexcept { return f *= v; }
	inline double& operator*= (const double& v) noexcept { return d *= v; }

	inline char& operator/= (const char& v) noexcept { return c /= v; }
	inline unsigned char& operator/= (const unsigned char& v) noexcept { return uc /= v; }
	inline short& operator/= (const short& v) noexcept { return s /= v; }
	inline unsigned short& operator/= (const unsigned short& v) noexcept { return us /= v; }
	inline int& operator/= (const int& v) noexcept { return (int&)(l /= v); }
	inline unsigned int& operator/= (const unsigned int& v) noexcept { return (unsigned int&)(ul /= v); }
	inline long& operator/= (const long& v) noexcept { return l /= v; }
	inline unsigned long& operator/= (const unsigned long& v) noexcept { return ul /= v; }
	inline long long& operator/= (const long long& v) noexcept { return ll /= v; }
	inline unsigned long long& operator/= (const unsigned long long& v) noexcept { return ull /= v; }
	inline float& operator/= (const float& v) noexcept { return f /= v; }
	inline double& operator/= (const double& v) noexcept { return d /= v; }

	inline char operator+ (const char& v) const noexcept { return c + v; }
	inline unsigned char operator+ (const unsigned char& v) const noexcept { return uc + v; }
	inline short operator+ (const short& v) const noexcept { return s + v; }
	inline unsigned short operator+ (const unsigned short& v) const noexcept { return us + v; }
	inline int operator+ (const int& v) const noexcept { return (int)(l + v); }
	inline unsigned int operator+ (const unsigned int& v) const noexcept { return (unsigned int)(ul + v); }
	inline long operator+ (const long& v) const noexcept { return l + v; }
	inline unsigned long operator+ (const unsigned long& v) const noexcept { return ul + v; }
	inline long long operator+ (const long long& v) const noexcept { return ll + v; }
	inline unsigned long long operator+ (const unsigned long long& v) const noexcept { return ull + v; }
	inline float operator+ (const float& v) const noexcept { return f + v; }
	inline double operator+ (const double& v) const noexcept { return d + v; }

	inline char operator- (const char& v) const noexcept { return c - v; }
	inline unsigned char operator- (const unsigned char& v) const noexcept { return uc - v; }
	inline short operator- (const short& v) const noexcept { return s - v; }
	inline unsigned short operator- (const unsigned short& v) const noexcept { return us - v; }
	inline int operator- (const int& v) const noexcept { return (int)(l - v); }
	inline unsigned int operator- (const unsigned int& v) const noexcept { return (unsigned int)(ul - v); }
	inline long operator- (const long& v) const noexcept { return l - v; }
	inline unsigned long operator- (const unsigned long& v) const noexcept { return ul - v; }
	inline long long operator- (const long long& v) const noexcept { return ll - v; }
	inline unsigned long long operator- (const unsigned long long& v) const noexcept { return ull - v; }
	inline float operator- (const float& v) const noexcept { return f - v; }
	inline double operator- (const double& v) const noexcept { return d - v; }

	inline char operator* (const char& v) const noexcept { return c * v; }
	inline unsigned char operator* (const unsigned char& v) const noexcept { return uc * v; }
	inline short operator* (const short& v) const noexcept { return s * v; }
	inline unsigned short operator* (const unsigned short& v) const noexcept { return us * v; }
	inline int operator* (const int& v) const noexcept { return (int)(l * v); }
	inline unsigned int operator* (const unsigned int& v) const noexcept { return (unsigned int)(ul * v); }
	inline long operator* (const long& v) const noexcept { return l * v; }
	inline unsigned long operator* (const unsigned long& v) const noexcept { return ul * v; }
	inline long long operator* (const long long& v) const noexcept { return ll * v; }
	inline unsigned long long operator* (const unsigned long long& v) const noexcept { return ull * v; }
	inline float operator* (const float& v) const noexcept { return f * v; }
	inline double operator* (const double& v) const noexcept { return d * v; }

	inline char operator/ (const char& v) const noexcept { return c / v; }
	inline unsigned char operator/ (const unsigned char& v) const noexcept { return uc / v; }
	inline short operator/ (const short& v) const noexcept { return s / v; }
	inline unsigned short operator/ (const unsigned short& v) const noexcept { return us / v; }
	inline int operator/ (const int& v) const noexcept { return (int)(l / v); }
	inline unsigned int operator/ (const unsigned int& v) const noexcept { return (unsigned int)(ul / v); }
	inline long operator/ (const long& v) const noexcept { return l / v; }
	inline unsigned long operator/ (const unsigned long& v) const noexcept { return ul / v; }
	inline long long operator/ (const long long& v) const noexcept { return ll / v; }
	inline unsigned long long operator/ (const unsigned long long& v) const noexcept { return ull / v; }
	inline float operator/ (const float& v) const noexcept { return f / v; }
	inline double operator/ (const double& v) const noexcept { return d / v; }

	inline auto operator<=>(const _variant& rhs) const noexcept { return ll <=> rhs.ll; }

	_variant() = default;
	_variant(const bool& v) noexcept { b = v; }
	_variant(bool&& v) noexcept { b = v; }
	_variant(const char& v) noexcept { c = v; }
	_variant(char&& v) noexcept { c = v; }
	_variant(const unsigned char& v) noexcept { uc = v; }
	_variant(unsigned char&& v) noexcept { uc = v; }
	_variant(const short& v) noexcept { s = v; }
	_variant(short&& v) noexcept { s = v; }
	_variant(const unsigned short& v) noexcept { us = v; }
	_variant(unsigned short&& v) noexcept { us = v; }
	_variant(const int& v) noexcept { l = v; }
	_variant(int&& v) noexcept { l = v; }
	_variant(const unsigned int& v) noexcept { ul = v; }
	_variant(unsigned int&& v) noexcept { ul = v; }
	_variant(const long& v) noexcept { l = v; }
	_variant(long&& v) noexcept { l = v; }
	_variant(const unsigned long& v) noexcept { ul = v; }
	_variant(unsigned long&& v) noexcept { ul = v; }
	_variant(const long long& v) noexcept { ll = v; }
	_variant(long long&& v) noexcept { ll = v; }
	_variant(const unsigned long long& v) noexcept { ull = v; }
	_variant(unsigned long long&& v) noexcept { ull = v; }
	_variant(const float& v) noexcept { f = v; }
	_variant(float&& v) noexcept { f = v; }
	_variant(const double& v) noexcept { d = v; }
	_variant(double&& v) noexcept { d = v; }
	_variant(const void*& v) noexcept { p = (void*)v; }
	_variant(void*&& v) noexcept { p = (void*)v; }
}variant_t, * pvariant_t;