fix gitw

server/Makefile

@@ -0,0 +1,6 @@
+debug:
+	g++ -g3 -O0 server/server.cpp server/table.cpp  -o a.out -Wall -Wextra -Wpedantic -lpthread
+	
+test:
+	g++ --std=c++1z -g3 -O0 server.cpp table.cpp  -o a.out -Wall -Wextra -Wpedantic -lpthread
+	

server/aggregations.h

@@ -0,0 +1,158 @@
+#pragma once
+#include "types.h"
+#include <utility>
+#include <limits>
+#include <deque>
+template <class T, template<typename ...> class VT>
+size_t count(const VT<T>& v) {
+	return v.size;
+}
+
+template <class T>
+constexpr static inline size_t count(const T&) { return 1; }
+
+// TODO: Specializations for dt/str/none
+template<class T, template<typename ...> class VT>
+types::GetLongType<T> sum(const VT<T>& v) {
+	types::GetLongType<T> ret = 0;
+	for (const auto& _v : v)
+		ret += _v;
+	return ret;
+}
+template<class T, template<typename ...> class VT>
+types::GetFPType<T> avg(const VT<T>& v) {
+	return static_cast<types::GetFPType<T>>(
+		sum<T>(v) / static_cast<long double>(v.size));
+}
+template <class T, template<typename ...> class VT>
+T max(const VT<T>& v) {
+	T max_v = std::numeric_limits<T>::min();
+	for (const auto& _v : v)
+		max_v = max_v > _v ? max_v : _v;
+	return max_v;
+}
+template <class T, template<typename ...> class VT>
+T min(const VT<T>& v) {
+	T min_v = std::numeric_limits<T>::max();
+	for (const auto& _v : v)
+		min_v = min_v < _v ? min_v : _v;
+	return min_v;
+}
+template<class T, template<typename ...> class VT>
+decayed_t<VT,T> mins(const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	std::deque<std::pair<T, uint32_t>> cache;
+	decayed_t<VT,T> ret(len);
+	T min = std::numeric_limits<T>::max();
+	for (int i = 0; i < len; ++i) {
+		if (arr[i] < min)
+			min = arr[i];
+		ret[i] = min;
+	}
+	return ret;
+}
+template<class T, template<typename ...> class VT>
+decayed_t<VT,T> maxs(const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	decayed_t<VT,T> ret(len);
+	T max = std::numeric_limits<T>::min();
+	for (int i = 0; i < len; ++i) {
+		if (arr[i] > max)
+			max = arr[i];
+		ret[i] = max;
+	}
+	return ret;
+}
+
+template<class T, template<typename ...> class VT>
+decayed_t<VT,T> minw(uint32_t w, const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	decayed_t<VT,T> ret{len};
+	std::deque<std::pair<T, uint32_t>> cache;
+	for (int i = 0; i < len; ++i) {
+		if (!cache.empty() && cache.front().second == i - w) cache.pop_front();
+		while (!cache.empty() && cache.back().first > arr[i]) cache.pop_back();
+		cache.push_back({ arr[i], i });
+		ret[i] = cache.front().first;
+	}
+	return ret;
+}
+
+template<class T, template<typename ...> class VT>
+decayed_t<VT,T> maxw(uint32_t w, const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	decayed_t<VT, T> ret(len);
+	std::deque<std::pair<T, uint32_t>> cache;
+	for (int i = 0; i < len; ++i) {
+		if (!cache.empty() && cache.front().second == i - w) cache.pop_front();
+		while (!cache.empty() && cache.back().first > arr[i]) cache.pop_back();
+		cache.push_back({ arr[i], i });
+		arr[i] = cache.front().first;
+	}
+	return ret;
+}
+
+template<class T, template<typename ...> class VT>
+decayed_t<VT, types::GetLongType<T>> sums(const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	decayed_t<VT, types::GetLongType<T>> ret(len);
+	uint32_t i = 0;
+	if(len) ret[i++] = arr[0];
+	for (; i < len; ++i) 
+		ret[i] = ret[i-1] + arr[i];
+	return ret;
+}
+template<class T, template<typename ...> class VT>
+decayed_t<VT, types::GetFPType<T>> avgs(const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	typedef types::GetFPType<T> FPType;
+	decayed_t<VT, FPType> ret(len);
+	uint32_t i = 0;
+	types::GetLongType<T> s;
+	if(len) s = ret[i++] = arr[0];
+	for (; i < len; ++i) 
+		ret[i] = (s+=arr[i])/(FPType)(i+1);
+	return ret;
+}
+template<class T, template<typename ...> class VT>
+decayed_t<VT, types::GetLongType<T>> sumw(uint32_t w, const VT<T>& arr) {
+	const uint32_t& len = arr.size;
+	decayed_t<VT, types::GetLongType<T>> ret(len);
+	uint32_t i = 0;
+	w = w > len ? len : w;
+	if(len) ret[i++] = arr[0];
+	for (; i < w; ++i) 
+		ret[i] = ret[i-1] + arr[i];
+	for (; i < len; ++i) 
+		ret[i] = ret[i-1] + arr[i] - arr[i-w];
+	return ret;
+}
+template<class T, template<typename ...> class VT>
+decayed_t<VT, types::GetFPType<T>> avgw(uint32_t w, const VT<T>& arr) {
+	typedef types::GetFPType<T> FPType;
+	const uint32_t& len = arr.size;
+	decayed_t<VT, FPType> ret(len);
+	uint32_t i = 0;
+	types::GetLongType<T> s{};
+	w = w > len ? len : w;
+	if(len)	s = ret[i++] = arr[0];
+	for (; i < w; ++i) 
+		ret[i] = (s += arr[i])/(FPType)(i+1);
+	for (; i < len; ++i) 
+		ret[i] = ret[i-1] + (arr[i] - arr[i-w])/(FPType)w;
+	return ret;
+}
+
+template <class T> constexpr inline T count(const T& v) { return 1; }
+template <class T> constexpr inline T max(const T& v) { return v; }
+template <class T> constexpr inline T min(const T& v) { return v; }
+template <class T> constexpr inline T avg(const T& v) { return v; }
+template <class T> constexpr inline T sum(const T& v) { return v; }
+template <class T> constexpr inline T maxw(uint32_t, const T& v) { return v; }
+template <class T> constexpr inline T minw(uint32_t, const T& v) { return v; }
+template <class T> constexpr inline T avgw(uint32_t, const T& v) { return v; }
+template <class T> constexpr inline T sumw(uint32_t, const T& v) { return v; }
+template <class T> constexpr inline T maxs(const T& v) { return v; }
+template <class T> constexpr inline T mins(const T& v) { return v; }
+template <class T> constexpr inline T avgs(const T& v) { return v; }
+template <class T> constexpr inline T sums(const T& v) { return v; }

server/cpp.hint

@@ -0,0 +1,6 @@
+// Hint files help the Visual Studio IDE interpret Visual C++ identifiers
+// such as names of functions and macros.
+// For more information see https://go.microsoft.com/fwlink/?linkid=865984
+#define Ops(o) template<typename T> vector_type<typename types::Coercion<_Ty, T>::type> operator##o(const vector_type<T>& r) { [[likely]] if (r.size == size) { return add(r); } else if (r.size == 1 || size == 1) { const bool lr = size == 1; const uint32_t& _size = lr ? r.size : size; const auto& _container = lr ? r.container : container; const auto& scalar = *(lr ? container : r.container); vector_type<typename types::Coercion<_Ty, T>::type> ret(_size); for (int i = 0; i < _size; ++i) ret[i] = _container[i] o scalar; return ret; } }
+#define Op(o, x) template<typename T> vector_type<typename types::Coercion<_Ty, T>::type> inline x(const vector_type<T>& r) { vector_type<typename types::Coercion<_Ty, T>::type> ret(size); for (int i = 0; i < size; ++i) ret[i] = container[i] o r[i]; return ret; }
+#define _Make_Ops(M) M(+, add) M(-, minus) M(*, multi) M(/, div) M(%, mod) M(&, and) M(|, or) M(^, xor) 

server/gc.hpp

@@ -0,0 +1,54 @@
+#pragma once
+#include <vector>
+#include <utility>
+#include <thread>
+#include <chrono>
+class GC {
+	template<class T>
+	using vector = std::vector<T>;
+	template<class ...T>
+	using tuple = std::tuple<T...>;
+	size_t current_size, max_size, interval, forced_clean;
+	bool running, alive;
+//  ptr, dealloc, ref, sz
+	vector<tuple<void*, void (*)(void*), uint32_t, uint32_t>> q;
+	std::thread handle;
+	void gc()
+	{
+		
+	}
+	template <class T>
+	void reg(T* v, uint32_t ref, uint32_t sz, 
+		void(*f)(void*) = [](void* v) {delete[] ((T*)v); }) {
+		current_size += sz;
+		if (current_size > max_size)
+			gc();
+		q.push_back({ v, f, ref, sz });
+	}
+	void daemon() {
+		using namespace std::chrono;
+		while (alive) {
+			if (running) {
+				gc();
+				std::this_thread::sleep_for(microseconds(interval));
+			}
+			else {
+				std::this_thread::sleep_for(10ms);
+			}
+		}
+	}
+	void start_deamon() {
+		handle = std::thread(&daemon);
+		alive = true;
+	}
+	void terminate_daemon() {
+		running = false;
+		alive = false;
+		using namespace std::chrono;
+
+		if (handle.joinable()) {
+			std::this_thread::sleep_for(microseconds(1000 + std::max(static_cast<size_t>(10000), interval)));
+			handle.join();
+		}
+	}
+};

server/hasher.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <functional>
+#include <tuple>
+template <class ...Types>
+struct hasher {
+	template <size_t i = 0> typename std::enable_if< i == sizeof...(Types), 
+		size_t>::type hashi(const std::tuple<Types...>& record) const {
+		return 0;
+	}
+
+	template <size_t i = 0> typename std::enable_if< i < sizeof ...(Types), 
+		size_t>::type hashi(const std::tuple<Types...>& record) const {
+		using current_type = typename std::decay<typename std::tuple_element<i, std::tuple<Types...>>::type>::type;
+		return std::hash<current_type>()(std::get<i>(record)) ^ hashi<i+1>(record);
+	}
+	size_t operator()(const std::tuple<Types...>& record) const {
+		return hashi(record);
+	}
+};

server/io.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "types.h"
+#include <cstdio>
+#include <string>
+template <class ...Types>
+std::string generate_printf_string(const char* sep = " ", const char* end = "\n") {
+	std::string str;
+	((str += types::printf_str[types::Types<value_type_r<Types>>::getType()], str += sep), ...);
+	const auto trim = str.size() - strlen(sep);
+	if (trim > 0)
+		str.resize(trim);
+	str += end;
+	return str;
+}
+

server/libaquery.h

@@ -0,0 +1,48 @@
+#ifndef _AQUERY_H
+#define _AQUERY_H
+
+#include "table.h"
+#include <unordered_map>
+
+enum Log_level {
+	LOG_INFO,
+	LOG_ERROR,
+	LOG_SILENT
+};
+
+struct Config{
+    int running, new_query, server_mode, n_buffers;
+    int buffer_sizes[];
+};
+
+struct Context{
+    typedef int (*printf_type) (const char *format, ...);
+	std::unordered_map<const char*, void*> tables;
+    std::unordered_map<const char*, uColRef *> cols;
+
+	Config* cfg;
+
+	int n_buffers, *sz_bufs;
+	void **buffers;
+	
+	Log_level log_level = LOG_SILENT;
+	printf_type print = printf;
+	template <class ...Types>
+	void log(Types... args) {
+		if (log_level == LOG_INFO)
+			print(args...);
+	}
+	template <class ...Types>
+	void err(Types... args) {
+		if (log_level <= LOG_ERROR)
+			print(args...);
+	}
+};
+
+#ifdef _WIN32
+#define __DLLEXPORT__  __declspec(dllexport) __stdcall
+#else 
+#define __DLLEXPORT__
+#endif
+
+#endif

server/priority_vector.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include "vector_type.hpp"
+#include <algorithm>
+#include <stdint.h>
+template <class Comparator, typename T = uint32_t>
+class priority_vector : public vector_type<T> {
+	const Comparator comp;
+public:
+	priority_vector(Comparator comp = std::less<T>{}) : 
+		comp(comp), vector_type<T>(0) {}
+	void emplace_back(T val) {
+		vector_type<T>::emplace_back(val);
+		std::push_heap(container, container + size, comp);
+	}
+	void pop_back() {
+		std::pop_heap(container, container + size, comp);
+		--size;
+	}
+}; 

server/server.cpp

@@ -0,0 +1,135 @@
+#include "../csv.h"
+#include <iostream>
+#include <string>
+//#include <thread>
+#include <chrono>
+
+#include "libaquery.h"
+#ifdef _WIN32
+#include "winhelper.h"
+#else 
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+struct SharedMemory
+{
+    int hFileMap;
+    void* pData;
+    SharedMemory(const char* fname) {
+        hFileMap = open(fname, O_RDWR, 0);
+        if (hFileMap != -1)
+            pData = mmap(NULL, 8, PROT_READ | PROT_WRITE, MAP_SHARED, hFileMap, 0);
+        else 
+            pData = 0;
+    }
+    void FreeMemoryMap() {
+
+    }
+};
+#endif
+struct thread_context{
+
+}v;
+void daemon(thread_context* c) {
+
+}
+#include "aggregations.h"
+typedef int (*code_snippet)(void*);
+int test_main();
+
+int dll_main(int argc, char** argv, Context* cxt){
+    Config *cfg = reinterpret_cast<Config *>(argv[0]);
+
+    auto buf_szs = cfg->buffer_sizes;
+    void** buffers = (void**)malloc(sizeof(void*) * cfg->n_buffers);
+    for (int i = 0; i < cfg->n_buffers; i++) 
+        buffers[i] = static_cast<void *>(argv[i + 1]);
+
+    cxt->buffers = buffers;
+    cxt->cfg = cfg;
+    cxt->n_buffers = cfg->n_buffers;
+    cxt->sz_bufs = buf_szs;
+
+    while(cfg->running){
+        if (cfg->new_query) {
+            void* handle = dlopen("./dll.so", RTLD_LAZY);
+            code_snippet c = reinterpret_cast<code_snippet>(dlsym(handle, "dllmain"));
+            c(cxt);
+            dlclose(handle);
+            cfg->new_query = 0;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
+    return 0;
+}
+
+extern "C" int __DLLEXPORT__ main(int argc, char** argv) {
+    Context* cxt = new Context();
+    cxt->log("%d %s\n", argc, argv[1]);
+    
+    const char* shmname;
+    if (argc < 0)
+        return dll_main(argc, argv, cxt);
+    else if (argc <= 1)
+        return test_main();
+    else
+        shmname = argv[1];
+    SharedMemory shm = SharedMemory(shmname);
+    if (!shm.pData)
+        return 1;
+    bool &running = static_cast<bool*>(shm.pData)[0], 
+        &ready = static_cast<bool*>(shm.pData)[1];
+    using namespace std::chrono_literals;
+    cxt->log("running: %s\n", running? "true":"false");
+    cxt->log("ready: %s\n", ready? "true":"false");
+    while (running) {
+        std::this_thread::sleep_for(1ms);
+        if(ready){
+            cxt->log("running: %s\n", running? "true":"false");
+            cxt->log("ready: %s\n", ready? "true":"false");
+            void* handle = dlopen("./dll.so", RTLD_LAZY);
+            cxt->log("handle: %lx\n", handle);
+            if (handle) {
+                cxt->log("inner\n");
+                code_snippet c = reinterpret_cast<code_snippet>(dlsym(handle, "dllmain"));
+                cxt->log("routine: %lx\n", c);
+                if (c) {
+                    cxt->log("inner\n");
+                    cxt->err("return: %d\n", c(cxt));
+                }
+            }
+            ready = false;
+        }
+    }
+    shm.FreeMemoryMap();
+    return 0;
+}
+#include "utils.h"
+int test_main()
+{
+    //vector_type<int> t;
+    //t = 1;
+    //t.emplace_back(2);
+    //print(t);
+    //return 0;
+    Context* cxt = new Context();
+    cxt->log_level = LOG_INFO;
+    puts(cpp_17 ?"true":"false");
+    void* handle = dlopen("./dll.so", RTLD_LAZY);
+    cxt->log("handle: %llx\n", handle);
+    if (handle) {
+        cxt->log("inner\n");
+        code_snippet c = reinterpret_cast<code_snippet>(dlsym(handle, "dllmain"));
+        cxt->log("routine: %llx\n", c);
+        if (c) {
+            cxt->log("inner\n");
+            cxt->log("return: %d\n", c(cxt));
+        }
+        dlclose(handle);
+    }
+    //static_assert(std::is_same_v<decltype(fill_integer_array<5, 1>()), std::integer_sequence<bool, 1,1,1,1,1>>, "");
+    return 0;
+    std::unordered_map<int, int> a;
+}
+

server/server.sln

@@ -0,0 +1,62 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.2.32210.308
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "server", "server.vcxproj", "{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}"
+	ProjectSection(ProjectDependencies) = postProject
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81} = {8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "msc-plugin", "..\msc-plugin\msc-plugin.vcxproj", "{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}"
+EndProject
+Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "msvs-py", "..\msvs-py\msvs-py.pyproj", "{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|Any CPU.Build.0 = Debug|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|x64.ActiveCfg = Debug|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|x64.Build.0 = Debug|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|x86.ActiveCfg = Debug|Win32
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Debug|x86.Build.0 = Debug|Win32
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|Any CPU.ActiveCfg = Release|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|Any CPU.Build.0 = Release|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|x64.ActiveCfg = Release|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|x64.Build.0 = Release|x64
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|x86.ActiveCfg = Release|Win32
+		{031352C2-AFBB-45AA-9518-DBC1F9EF2AF3}.Release|x86.Build.0 = Release|Win32
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|Any CPU.Build.0 = Debug|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|x64.ActiveCfg = Debug|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|x64.Build.0 = Debug|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|x86.ActiveCfg = Debug|Win32
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Debug|x86.Build.0 = Debug|Win32
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|Any CPU.ActiveCfg = Release|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|Any CPU.Build.0 = Release|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|x64.ActiveCfg = Release|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|x64.Build.0 = Release|x64
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|x86.ActiveCfg = Release|Win32
+		{8081FDAA-4D13-4B7A-ADB2-8224AF7F1C81}.Release|x86.Build.0 = Release|Win32
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Release|x64.ActiveCfg = Release|Any CPU
+		{CCC243F5-663E-45B7-A6DE-B2468C58B3A7}.Release|x86.ActiveCfg = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {572EA821-8162-4161-9AC2-464C79F08B47}
+	EndGlobalSection
+EndGlobal

server/server.vcxproj

@@ -0,0 +1,188 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{031352c2-afbb-45aa-9518-dbc1f9ef2af3}</ProjectGuid>
+    <RootNamespace>server</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>false</EnableASAN>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>false</EnableASAN>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Media Include="..\out.cpp" />
+    <ClCompile Include="table.cpp" />
+    <ClCompile Include="server.cpp" />
+    <ClCompile Include="types.cpp" />
+    <ClCompile Include="utils.cpp" />
+    <ClCompile Include="vector_type.cpp" />
+    <ClCompile Include="winhelper.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="cpp.hint" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\csv.h" />
+    <ClInclude Include="aggregations.h" />
+    <ClInclude Include="gc.hpp" />
+    <ClInclude Include="hasher.h" />
+    <ClInclude Include="io.h" />
+    <ClInclude Include="libaquery.h" />
+    <ClInclude Include="priority_vector.hpp" />
+    <ClInclude Include="table.h" />
+    <ClInclude Include="types.h" />
+    <ClInclude Include="utils.h" />
+    <ClInclude Include="vector_type.hpp" />
+    <ClInclude Include="winhelper.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

server/table.cpp

@@ -0,0 +1 @@
+#include "table.h"

server/table.h

@@ -0,0 +1,481 @@
+// TODO: Replace `cout, printf` with sprintf&fputs and custom buffers
+
+#ifndef _TABLE_H
+#define _TABLE_H
+
+#include "types.h"
+#include "vector_type.hpp"
+#include <iostream>
+#include <string>
+#include "io.h"
+template <typename T>
+class vector_type;
+template <>
+class vector_type<void>;
+
+#ifdef _MSC_VER
+namespace types {
+	enum Type_t;
+	template <typename T>
+	struct Types;
+	template <class T1, class T2>
+	struct Coercion;
+}
+#endif
+template<typename _Ty>
+class ColView;
+template<typename _Ty>
+class ColRef : public vector_type<_Ty>
+{
+public:
+	typedef ColRef<_Ty> Decayed_t;
+	const char* name;
+	types::Type_t ty = types::ERROR;
+	ColRef() : vector_type<_Ty>(0), name("") {}
+	ColRef(const uint32_t& size, const char* name = "") : vector_type<_Ty>(size), name(name) {}
+	ColRef(const char* name) : name(name) {}
+	void init(const char* name = "") { ty = types::Types<_Ty>::getType();  this->size = this->capacity = 0; this->container = 0; this->name = name; }
+	ColRef(const char* name, types::Type_t ty) : name(name), ty(ty) {}
+	using vector_type<_Ty>::operator[];
+	using vector_type<_Ty>::operator=;
+	ColView<_Ty> operator [](const vector_type<uint32_t>&idxs) const {
+		return ColView<_Ty>(*this, idxs);
+	}
+
+	void out(uint32_t n = 4, const char* sep = " ") const {
+		n = n > this->size ? this->size : n;
+		std::cout << '(';
+		if (n > 0)
+		{
+			uint32_t i = 0;
+			for (; i < n - 1; ++i)
+				std::cout << this->operator[](i) << sep;
+			std::cout << this->operator[](i);
+		}
+		std::cout << ')';
+	}
+	template<typename T>
+	ColRef<T> scast();
+};
+
+template<typename _Ty>
+class ColView {
+public: 
+	typedef ColRef<_Ty> Decayed_t;
+	const vector_type<uint32_t>& idxs;
+	const ColRef<_Ty>& orig;
+	const uint32_t& size;
+	ColView(const ColRef<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig), idxs(idxs), size(idxs.size) {}
+	ColView(const ColView<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig.orig), idxs(idxs), size(idxs.size) {
+		for (uint32_t i = 0; i < size; ++i) 
+			idxs[i] = orig.idxs[idxs[i]];
+	}
+	_Ty& operator [](const uint32_t& i) const {
+		return orig[idxs[i]];
+	}
+	struct Iterator_t {
+		const uint32_t* val;
+		const ColRef<_Ty>& orig;
+		constexpr Iterator_t(const uint32_t* val, const ColRef<_Ty>& orig) noexcept : val(val), orig(orig) {}
+		_Ty& operator*() { return orig[*val]; }
+		bool operator != (const Iterator_t& rhs) { return rhs.val != val; }
+		Iterator_t& operator++ () {
+			++val;
+			return *this;
+		}
+		Iterator_t operator++ (int) {
+			Iterator_t tmp = *this;
+			++val;
+			return tmp;
+		}
+	};
+	Iterator_t begin() const {
+		return Iterator_t(idxs.begin(), orig);
+	}
+	Iterator_t end() const {
+		return Iterator_t(idxs.end(), orig);
+	}
+	void out(uint32_t n = 4, const char* sep = " ") const {
+		n = n > size ? size : n;
+		std::cout<<'(';
+		for (uint32_t i = 0; i < n; ++i) 
+			std::cout << this->operator[](i)<< sep;
+		std::cout << ')';
+	}
+	operator ColRef<_Ty>() {
+		auto ret = ColRef<_Ty>(size);
+		for (uint32_t i = 0; i < size; ++i)
+			ret[i] = orig[idxs[i]];
+		return ret;
+	}
+};
+template <template <class...> class VT, class T>
+std::ostream& operator<<(std::ostream& os, const VT<T>& v)
+{
+	v.out();
+	return os;
+}
+template <class Type>
+struct decayed_impl<ColView, Type> { typedef ColRef<Type> type; };
+template<typename _Ty>
+template<typename T>
+inline ColRef<T> ColRef<_Ty>::scast()
+{
+	this->ty = types::Types<T>::getType();
+	return *(ColRef<T> *)this;
+}
+using uColRef = ColRef<void>;
+
+template<class ...Types> struct TableInfo;
+template<class ...Types> struct TableView;
+
+template <long long _Index, bool order = true, class... _Types>
+constexpr inline auto& get(const TableInfo<_Types...>& table) noexcept {
+	if constexpr (order)
+		return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.colrefs[_Index]);
+	else 
+		return *(ColRef<std::tuple_element_t<-1-_Index, std::tuple<_Types...>>> *) & (table.colrefs[-1-_Index]);
+}
+
+template <long long _Index, class... _Types>
+constexpr inline ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>>& get(const TableView<_Types...>& table) noexcept {
+	return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.info.colrefs[_Index]);
+}
+
+template <class V>
+struct is_vector_impl<ColRef<V>> : std::true_type {};
+template <class V>
+struct is_vector_impl<ColView<V>> : std::true_type {};
+template <class V>
+struct is_vector_impl<vector_type<V>> : std::true_type {};
+
+template<class ...Types>
+struct TableView;
+template<class ...Types>
+struct TableInfo {
+	const char* name;
+	ColRef<void>* colrefs;
+	uint32_t n_cols;
+	typedef std::tuple<Types...> tuple_type;
+	void print(const char* __restrict sep, const char* __restrict end) const;
+
+	template <class ...Types2>
+	struct lineage_t {
+		TableInfo<Types...>* this_table;
+		TableInfo<Types2...>* table;
+		vector_type<uint32_t> rid;
+		constexpr lineage_t(TableInfo<Types...>*this_table, TableInfo<Types2...> *table) 
+			: this_table(this_table), table(table), rid(0) {}
+		constexpr lineage_t() : this_table(0), table(0), rid(0) {}
+
+		template <int col>
+		inline auto& get(uint32_t idx) {
+			return get<col>(*table)[rid[idx]];
+		}
+		void emplace_back(const uint32_t& v) {
+			rid.emplace_back(v);
+		}
+	};
+	template<class ...Types2>
+	auto bind(TableInfo<Types2...>* table2) {
+		return lineage_t(this, table2);
+	}
+	
+	template <size_t j = 0>
+	typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	template <size_t j = 0>
+	typename std::enable_if<j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	template <size_t ...Idxs>
+	struct GetTypes {
+		typedef typename std::tuple<typename std::tuple_element<Idxs, tuple_type>::type ...> type;
+	};
+	template <size_t ...Idxs>
+	using getRecordType = typename GetTypes<Idxs...>::type;
+	TableInfo(const char* name, uint32_t n_cols);
+	template <int prog = 0>
+	inline void materialize(const vector_type<uint32_t>& idxs, TableInfo<Types...>* tbl = nullptr) { // inplace materialize
+		if constexpr(prog == 0) tbl = (tbl == 0 ? this : tbl);
+		if constexpr (prog == sizeof...(Types)) return;
+		else {
+			auto& col = get<prog>(*this);
+			auto new_col = decays<decltype(col)>{idxs.size};
+			for(uint32_t i = 0; i < idxs.size; ++i)
+				new_col[i] = col[idxs[i]];
+			get<prog>(*tbl) = new_col;
+			materialize<prog + 1>(idxs, tbl);
+		}
+	}
+	inline TableInfo<Types...>* materialize_copy(const vector_type<uint32_t>& idxs) { 
+		auto tbl = new TableInfo<Types...>(this->name, sizeof...(Types));
+		materialize<0>(idxs, tbl);
+		return tbl;
+	}
+	template<int ...cols>
+	inline vector_type<uint32_t>* order_by(vector_type<uint32_t>* ord = nullptr) {
+		if (!ord) {
+			ord = new vector_type<uint32_t>(colrefs[0].size);
+			for (uint32_t i = 0; i < colrefs[0].size; ++i)
+				(*ord)[i] = i;
+		}
+		std::sort(ord->begin(), ord->end(), [this](const uint32_t& lhs, const uint32_t& rhs) {
+			return
+				std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[lhs] : -get<cols, (cols >= 0)>(*this)[lhs]) ...)
+				<
+				std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[rhs] : -get<cols, (cols >= 0)>(*this)[rhs]) ...);
+			});
+		return ord;
+	}
+	template <int ...cols>
+	auto order_by_view () {
+		return TableView<Types...>(order_by<cols...>(), *this);
+	}
+
+	// Print 2 -- generate printf string first, supports flattening, supports sprintf/printf/fprintf
+	template <int col, int ...rem_cols, class Fn, class ...__Types> 
+	inline void print2_impl(Fn func, const uint32_t& i, const __Types& ... args) const {
+		using this_type = typename std::tuple_element<col, tuple_type>::type;
+		const auto& this_value = get<col>(*this)[i];
+		const auto& next = [&](auto &v) {
+			if constexpr (sizeof...(rem_cols) == 0)
+				func(args..., v);
+			else
+				print2_impl<rem_cols...>(func, i, args ..., v);
+		};
+		if constexpr (is_vector_type<this_type>)
+			for (int j = 0; j < this_value.size; ++j)
+				next(this_value[j]);
+		else
+			next(this_value);
+	}
+	std::string get_header_string(const char* __restrict sep, const char* __restrict end) const{
+		std::string header_string = std::string();
+		for (int i = 0; i < sizeof...(Types); ++i)
+			header_string += std::string(this->colrefs[i].name) + sep;
+		const size_t l_sep = strlen(sep);
+		if (header_string.size() - l_sep >= 0)
+			header_string.resize(header_string.size() - l_sep);
+		header_string += end + std::string(header_string.size(), '=') + end;
+		return header_string;
+	}
+	template <int ...cols>
+	void print2(const char* __restrict sep = ",", const char* __restrict end = "\n",
+		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) const {
+		
+		std::string printf_string =
+			generate_printf_string<typename std::tuple_element<cols, tuple_type>::type ...>(sep, end);
+		
+		std::string header_string = std::string();
+		constexpr static int a_cols[] = { cols... };
+		for(int i = 0; i < sizeof...(cols); ++i)
+			header_string += std::string(this->colrefs[a_cols[i]].name) + sep;
+		const size_t l_sep = strlen(sep);
+		if(header_string.size() - l_sep >= 0)
+			header_string.resize(header_string.size() - l_sep);
+		
+		const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) {
+			if(view)
+				for (int i = 0; i < view->size; ++i)
+					print2_impl<cols...>(f, (*view)[i], printf_string.c_str());
+			else
+				for (int i = 0; i < colrefs[0].size; ++i)
+					print2_impl<cols...>(f, i, printf_string.c_str());		
+		};
+
+		if (fp)
+		{
+			fprintf(fp, "%s%s", header_string.c_str(), end);
+			prt_loop([&fp](auto... args) { fprintf(fp, args...); });
+		}
+		else {
+			printf("%s%s", header_string.c_str(), end);
+			prt_loop(printf);
+		}
+	}
+	template <int ...vals> struct applier {
+	inline constexpr static void apply(const TableInfo<Types...>& t, const char* __restrict sep = ",", const char* __restrict end = "\n",
+		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr)
+	{ t.template print2<vals ...>(sep, end, view, fp); }};
+	
+	inline void printall(const char* __restrict sep = ",", const char* __restrict end = "\n",
+		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) {
+		applyIntegerSequence<sizeof...(Types), applier>::apply(*this, sep, end, view, fp);
+	}
+};
+
+
+template<class ...Types>
+struct TableView {
+	const vector_type<uint32_t>* idxs;
+	const TableInfo<Types...>& info;
+	constexpr TableView(const vector_type<uint32_t>* idxs, const TableInfo<Types...>& info) noexcept : idxs(idxs), info(info) {}
+	void print(const char* __restrict sep, const char* __restrict end) const;
+	template <size_t j = 0>
+	typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	template <size_t j = 0>
+	typename std::enable_if < j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	
+	~TableView() {
+		delete idxs;
+	}
+};
+
+template <class T>
+constexpr static inline bool is_vector(const ColRef<T>&) {
+	return true;
+}
+template <class T>
+constexpr static inline bool is_vector(const vector_type<T>&) {
+	return true;
+}
+
+template<class ...Types>
+TableInfo<Types...>::TableInfo(const char* name, uint32_t n_cols) : name(name), n_cols(n_cols) {
+	this->colrefs = (ColRef<void>*)malloc(sizeof(ColRef<void>) * n_cols);
+}
+template <class ...Types>
+template <size_t j>
+inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
+TableView<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
+	std::cout << (get<j>(*this))[(*idxs)[i]];
+}
+
+template<class ...Types>
+template<size_t j>
+inline typename std::enable_if < j < sizeof...(Types) - 1, void>::type
+	TableView<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
+{
+	std::cout << (get<j>(*this))[(*idxs)[i]] << sep;
+	print_impl<j + 1>(i, sep);
+}
+
+template<class ...Types>
+inline void TableView<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
+	std::string header_string = info.get_header_string(sep, end);
+	std::cout << header_string.c_str();
+	
+	int n_rows = 0;
+	if (info.colrefs[0].size > 0)
+		n_rows = info.colrefs[0].size;
+	for (int i = 0; i < n_rows; ++i) {
+		print_impl(i);
+		std::cout << end;
+	}
+}
+template <class ...Types>
+template <size_t j>
+inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
+	TableInfo<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
+	std::cout << (get<j>(*this))[i];
+}
+
+template<class ...Types>
+template<size_t j>
+inline typename std::enable_if<j < sizeof...(Types) - 1, void>::type 
+	TableInfo<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
+{
+	std::cout << (get<j>(*this))[i] << sep;
+	print_impl<j+1>(i, sep);
+}
+
+template<class ...Types>
+inline void TableInfo<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
+	
+	std::string header_string = get_header_string(sep, end);
+	std::cout << header_string.c_str();
+	
+	int n_rows = 0;
+	if (n_cols > 0 && colrefs[0].size > 0)
+		n_rows = colrefs[0].size;
+	for (int i = 0; i < n_rows; ++i) {
+		print_impl(i);
+		std::cout << end;
+	}
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] - rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] - rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] + rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] + rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] * rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] * rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] / rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] / rhs;
+	return ret;
+}
+
+template <class ...Types>
+void print(const TableInfo<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
+	v.print(delimiter, endline);
+}
+template <class ...Types>
+void print(const TableView<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
+	v.print(delimiter, endline);
+}
+template <class T>
+void print(const T& v, const char* delimiter = " ") {
+	std::cout<< v;
+	// printf(types::printf_str[types::Types<T>::getType()], v);
+}
+template <class T>
+void inline print_impl(const T& v, const char* delimiter, const char* endline) {
+	for (const auto& vi : v) {
+		print(vi);
+		std::cout << delimiter;
+		// printf("%s", delimiter);
+	}
+	std::cout << endline;
+	//printf("%s", endline);
+}
+
+template <class T, template<typename> class VT>
+typename std::enable_if<!std::is_same<VT<T>, TableInfo<T>>::value>::type 
+print(const VT<T>& v, const char* delimiter = " ", const char* endline = "\n") {
+	print_impl(v, delimiter, endline);
+}
+ 
+#endif

server/types.cpp

@@ -0,0 +1,20 @@
+#include "types.h"
+#include <string>
+#include <iostream>
+#include <chrono>
+#include <ctime>
+namespace types {
+	using namespace std;
+	using namespace chrono;
+	string date_t::toString() const {
+		uint32_t curr_v = val;
+		tm;
+		time_t;
+		return string() + string("/") + string() + string("/") + string();
+	}
+	string time_t::toString() const {
+		uint32_t curr_v = val;
+		
+		return string() + string("/") + string() + string("/") + string();
+	}
+}

server/types.h

@@ -0,0 +1,192 @@
+#ifndef _TYPES_H
+#define _TYPES_H
+#include <typeinfo>
+#include <functional>
+#include <cstdint>
+#include <type_traits>
+#include <string>
+
+#ifdef _MSC_VER
+#define __restrict__ __restrict
+#endif
+
+template <class T>
+constexpr static inline bool is_vector(const T&) {
+	return false;
+}
+template <class T>
+struct is_vector_impl : std::false_type {};
+template <class T>
+constexpr static bool is_vector_type = is_vector_impl<T>::value;
+
+namespace types {
+	enum Type_t {
+		AINT, AFLOAT, ASTR, ADOUBLE, ALDOUBLE, ALONG, ASHORT, ADATE, ATIME, ACHAR,
+		AUINT, AULONG, AUSHORT, AUCHAR, VECTOR, NONE, ERROR
+	};
+	static constexpr const char* printf_str[] = { "%d", "%f", "%s", "%lf", "%llf", "%ld", "%hi", "%s", "%s", "%c",
+		"%u", "%lu", "%hu", "%hhu", "Vector<%s>", "NULL", "ERROR" };
+	// TODO: deal with data/time <=> str/uint conversion
+	struct date_t {
+		uint32_t val;
+		date_t(const char* d) {
+		}
+		std::string toString() const;
+	};
+	struct time_t {
+		uint32_t val;
+		time_t(const char* d) {
+		}
+		std::string toString() const;
+	};
+	template <typename T>
+	struct Types {
+		typedef T type;
+		constexpr Types() noexcept = default;
+#define ConnectTypes(f) \
+		f(int, AINT) \
+		f(float, AFLOAT) \
+		f(const char*, ASTR) \
+		f(double, ADOUBLE) \
+		f(long double, ALDOUBLE) \
+		f(long, ALONG) \
+		f(short, ASHORT) \
+		f(date_t, ADATE) \
+		f(time_t, ATIME) \
+		f(unsigned char, ACHAR) \
+		f(unsigned int, AUINT) \
+		f(unsigned long, AULONG) \
+		f(unsigned short, AUSHORT) \
+		f(unsigned char, AUCHAR) 
+
+		inline constexpr static Type_t getType() {
+#define	TypeConnect(x, y) if constexpr(std::is_same<x, T>::value) return y; else
+			ConnectTypes(TypeConnect)
+			if constexpr (is_vector_type<T>) 
+				return VECTOR;
+			else
+				return NONE;
+		}
+	};
+#define ATypeSize(t, at) sizeof(t),
+	static constexpr size_t AType_sizes[] = { ConnectTypes(ATypeSize) 1 };
+#define Cond(c, x, y) typename std::conditional<c, x, y>::type
+#define Comp(o) (sizeof(T1) o sizeof(T2))
+#define Same(x, y) (std::is_same_v<x, y>)
+#define _U(x) std::is_unsigned<x>::value
+#define Fp(x) std::is_floating_point<x>::value
+	template <class T1, class T2>
+	struct Coercion {
+		using t1 = Cond(Comp(<= ), Cond(Comp(== ), Cond(Fp(T1), T1, Cond(Fp(T2), T2, Cond(_U(T1), T2, T1))), T2), T1);
+		using t2 = Cond(Same(T1, T2), T1, Cond(Same(T1, const char*) || Same(T2, const char*), const char*, void));
+		using type = Cond(Same(t2, void), Cond(Same(T1, date_t) && Same(T2, time_t) || Same(T1, time_t) && Same(T2, time_t), void, t1), t2);
+	};
+#define __Eq(x) (sizeof(T) == sizeof(x))
+	template<class T>
+	struct GetFPTypeImpl {
+		using type = Cond(__Eq(float), float, Cond(__Eq(double), double, long double));
+	};
+	template<class T>
+	using GetFPType = typename GetFPTypeImpl<typename std::decay<T>::type>::type;
+	template<class T>
+	struct GetLongTypeImpl {
+		using type = Cond(_U(T), unsigned long long, Cond(Fp(T), long double, long long));
+	};
+	template<class T>
+	using GetLongType = typename GetLongTypeImpl<typename std::decay<T>::type>::type;
+}
+
+#define getT(i, t) std::tuple_element_t<i, std::tuple<t...>>
+template <template<typename ...> class T, typename ...Types>
+struct applyTemplates {
+	using type = T<Types...>;
+};
+
+template <class lT, template <typename ...> class rT>
+struct transTypes_s;
+template <template<typename ...> class lT, typename ...T, template<typename ...> class rT>
+struct transTypes_s<lT<T...>, rT> {
+	using type = rT<T...>;
+};
+
+// static_assert(std::is_same<transTypes<std::tuple<int, float>, std::unordered_map>, std::unordered_map<int, float>>::value);
+template <class lT, template <typename ...> class rT>
+using transTypes = typename transTypes_s<lT, rT>::type;
+
+template <class ...Types>
+struct record_types {};
+
+template <class ...Types>
+using record = std::tuple<Types...>;
+
+template <class T>
+struct decayS {
+	using type = typename std::decay<T>::type;
+};
+template<template<typename ...> class T, typename ...Types>
+struct decayS <T<Types...>>{
+	using type = T<typename std::decay<Types>::type ...>;
+};
+template <class T>
+using decays = typename decayS<typename std::decay<T>::type>::type;
+template <class T>
+using decay_inner = typename decayS<T>::type;
+
+template <class, template <class...> class T>
+struct instance_of_impl : std::false_type {};
+template <class ...T1, template <class ...> class T2>
+struct instance_of_impl<T2<T1...>, T2> : std::true_type {};
+
+template <class T1, class T2>
+struct same_class_impl : std::false_type {};
+template <class ...T1s, class ...T2s, template <class...> class T1>
+struct same_class_impl<T1<T1s...>, T1<T2s...>> : std::true_type {};
+
+template <class T1, class T2>
+bool same_class = same_class_impl<T1, T2>::value;
+template <class T1, template <class...> class T2>
+bool instance_of = instance_of_impl<T1, T2>::value;
+
+template <class lT, template <typename ...> class rT>
+using transTypes = typename transTypes_s<lT, rT>::type;
+
+template <class lT, class vT, template <vT ...> class rT>
+struct transValues_s;
+template <class vT, template<class, vT ...> class lT, vT ...T, template<vT ...> class rT>
+struct transValues_s<lT<vT, T...>, vT, rT> {
+	using type = rT<T...>;
+};
+
+#include <utility>
+template <class vT, int i, template <vT ...> class rT>
+using transValues = typename transValues_s<std::make_integer_sequence<vT, i>, vT, rT>::type;
+template <int i, template <int ...> class rT>
+using applyIntegerSequence = typename transValues_s<std::make_integer_sequence<int, i>, int, rT>::type;
+template <template <class ...> class T, class ...Types>
+struct decayed_impl{ typedef T<Types...> type;};
+template <template <typename ...> class VT, class ...Types>
+using decayed_t = typename decayed_impl<VT, Types...>::type;
+
+template <class First = void, class...Rest>
+struct get_first_impl {
+	typedef First first;
+	constexpr static size_t rest_len = sizeof...(Rest);
+	typedef get_first_impl<Rest...> rest;
+};
+template <class ...T>
+using get_first = typename get_first_impl<T...>::first;
+template <class T>
+struct value_type_impl { typedef T type; };
+template <template <class...> class VT, class ...V>
+struct value_type_impl<VT<V...>> { typedef get_first<V...> type; };
+template <class T>
+using value_type = typename value_type_impl<T>::type;
+template <class ...T>
+using get_first = typename get_first_impl<T...>::first;
+template <class T>
+struct value_type_rec_impl { typedef T type; };
+template <template <class...> class VT, class ...V>
+struct value_type_rec_impl<VT<V...>> { typedef typename value_type_rec_impl<get_first<int>>::type type; };
+template <class T>
+using value_type_r = typename value_type_rec_impl<T>::type;
+#endif // !_TYPES_H

server/utils.cpp

@@ -0,0 +1,18 @@
+#include "utils.h"
+#include <random>
+#include <chrono>
+using std::string;
+string base62uuid(int l = 8) {
+    using namespace std;
+    constexpr static const char* base62alp = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    static mt19937_64 engine(chrono::system_clock::now().time_since_epoch().count());
+    static uniform_int_distribution<uint64_t> u(0x10000, 0xfffff);
+    uint64_t uuid = (u(engine) << 32ull) + (chrono::system_clock::now().time_since_epoch().count() & 0xffffffff);
+    printf("%llx\n", uuid);
+    string ret;
+    while (uuid && l-- >= 0) {
+        ret = string("") + base62alp[uuid % 62] + ret;
+        uuid /= 62;
+    }
+    return ret;
+}

server/utils.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <string>
+#include <ctime>
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+constexpr static bool cpp_17 = true;
+#else
+constexpr static bool cpp_17 = false;
+#endif
+template <class T>
+inline const char* str(const T& v) {
+	return "";
+}
+template <>
+inline const char* str(const bool& v) {
+	return v ? "true" : "false";
+}

server/vector_type.cpp

@@ -0,0 +1,15 @@
+#include "vector_type.hpp"
+#include <iostream>
+template<typename _Ty>
+inline void vector_type<_Ty>::out(uint32_t n, const char* sep) const
+{
+	n = n > size ? size : n;
+	std::cout << '(';
+	{	
+		uint32_t i = 0;
+		for (; i < n - 1; ++i)
+			std::cout << this->operator[](i) << sep;
+		std::cout << this->operator[](i);
+	}
+	std::cout << ')';
+}

server/vector_type.hpp

@@ -0,0 +1,278 @@
+/*
+* Bill Sun 2022
+*/
+
+
+#ifndef _VECTOR_TYPE
+#define _VECTOR_TYPE
+
+#include <cstring>
+#include <cstdlib>
+#include <cstdint>
+
+#include <algorithm>
+#include <initializer_list>
+#include <vector>
+#include <stdarg.h>
+#include <limits>
+#include <deque>
+#include "types.h"
+
+#pragma pack(push, 1)
+template <typename _Ty>
+class vector_type {
+public:
+	typedef vector_type<_Ty> Decayed_t;
+	void inline _copy(const vector_type<_Ty>& vt) {
+		// quick init while using malloc
+		//if (capacity > 0) free(container);
+		
+		this->size = vt.size;
+		this->capacity = vt.capacity;
+		this->container = (_Ty*)malloc(size * sizeof(_Ty));
+
+		memcpy(container, vt.container, sizeof(_Ty) * size);
+	}
+	void inline _move(vector_type<_Ty>&& vt) {
+		if (capacity > 0) free(container);
+		
+		this->size = vt.size;
+		this->capacity = vt.capacity;
+		this->container = vt.container;
+
+		vt.size = vt.capacity = 0;	
+		vt.container = 0;
+	}
+public:
+	_Ty* container;
+	uint32_t size, capacity;
+	typedef _Ty* iterator_t;
+	vector_type(const uint32_t& size) : size(size), capacity(size) {
+		container = (_Ty*)malloc(size * sizeof(_Ty));
+	}
+	constexpr vector_type(std::initializer_list<_Ty> _l) {
+		size = capacity = _l.size();
+		_Ty* _container = this->container = (_Ty*)malloc(sizeof(_Ty) * _l.size());
+		for (const auto& l : _l) {
+			*(_container++) = l;
+		}
+	}
+	constexpr vector_type() noexcept : size(0), capacity(0), container(0) {};
+	constexpr vector_type(const vector_type<_Ty>& vt) noexcept : capacity(0) {
+		_copy(vt);
+	}
+	constexpr vector_type(vector_type<_Ty>&& vt) noexcept : capacity(0) {
+		_move(std::move(vt));
+	}
+	vector_type<_Ty> operator =(const _Ty& vt) {
+		if (!container) { 
+			container = (_Ty*)malloc(sizeof(_Ty)); 
+			capacity = 1; 
+		}
+		size = 1;
+		container[0] = vt;
+		return *this;
+	}
+	vector_type<_Ty> operator =(const vector_type<_Ty>& vt) {
+		_copy(vt);
+		return *this;
+	}
+	vector_type<_Ty> operator =(vector_type<_Ty>&& vt) {
+		_move(std::move(vt));
+		return *this;
+	}
+	template <template <class> class VT>
+	vector_type<_Ty> operator =(const VT<_Ty>& vt) {
+		if (capacity > 0) free(container);
+		container = static_cast<_Ty*>(malloc(vt.size * sizeof(_Ty)));
+		
+		size = vt.size;
+		capacity = size;
+		for(uint32_t i = 0; i < size; ++i)
+			container[i] = vt[i];
+		
+		return *this;
+	}
+	void emplace_back(_Ty _val) {
+		if (size >= capacity) { // geometric growth
+			capacity += 1 + (capacity >> 1);
+			_Ty* n_container = (_Ty*)malloc(capacity * sizeof(_Ty));
+			memcpy(n_container, container, sizeof(_Ty) * size);
+			free(container);
+			container = n_container;
+		}
+		container[size++] = _val;
+	}
+	iterator_t erase(iterator_t _it) {
+#ifdef DEBUG 
+		// Do bound checks 
+		if (!(size && capicity && container &&
+			_it >= container && (_it - container) < size))
+			return 0;
+#endif
+		iterator_t curr = _it + 1, end = _it + --size;
+		while (curr < end)
+			*(curr - 1) = *(curr++);
+		return _it;
+	}
+
+	iterator_t begin() const {
+		return container;
+	}
+	iterator_t end() const {
+		return container + size;
+	}
+
+	iterator_t find(const _Ty item) const {
+		iterator_t curr = begin(), _end = end();
+		while (curr != _end && *(curr++) != item);
+		return curr;
+	}
+
+	_Ty& operator[](const uint32_t _i) const {
+		return container[_i];
+	}
+
+	void shrink_to_fit() {
+		if (size && capacity != size) {
+			capacity = size;
+			_Ty* _container = (_Ty*)malloc(sizeof(_Ty) * size);
+			memcpy(_container, container, sizeof(_Ty) * size);
+			free(container);
+			container = _container;
+		}
+	}
+
+	_Ty& back() {
+		return container[size - 1];
+	}
+	void qpop() {
+		size = size ? size - 1 : size;
+	}
+	void pop() {
+		if (size) {
+			--size;
+			if (capacity > (size << 1))
+			{
+				_Ty* new_container = (_Ty*)malloc(sizeof(_Ty) * size);
+				memcpy(new_container, container, sizeof(_Ty) * size);
+				free(container);
+				container = new_container;
+				capacity = size;
+			}
+		}
+	}
+	_Ty pop_back() {
+		return container[--size];
+	}
+	void merge(vector_type<_Ty>& _other) {
+		if (capacity < this->size + _other.size)
+		{
+			_Ty* new_container = (_Ty*)malloc(sizeof(_Ty) * (_other.size + this->size));
+			capacity = this->size + _other.size;
+			memcpy(new_container, container, sizeof(_Ty) * this->size);
+			memcpy(new_container + this->size, _other.container, sizeof(_Ty) * _other.size);
+			free(container);
+			container = new_container;
+		}
+		else
+			memcpy(container + this->size, _other.container, sizeof(_Ty) * _other.size);
+		size = this->size + _other.size;
+	}
+	template<class _Iter>
+	void merge(_Iter begin, _Iter end) {
+		unsigned int dist = static_cast<unsigned int>(std::distance(begin, end));
+		if (capacity < this->size + dist) {
+			_Ty* new_container = (_Ty*)malloc(sizeof(_Ty) * (dist + this->size));
+			capacity = this->size + dist;
+			memcpy(new_container, container, sizeof(_Ty) * this->size);
+			free(container);
+			container = new_container;
+		}
+
+		for (int i = 0; i < dist; ++i) {
+			container[i + this->size] = *(begin + i);
+		}
+		size = this->size + dist;
+	}
+	void out(uint32_t n = 4, const char* sep = " ") const;
+	~vector_type() {
+		if (capacity > 0) free(container);
+		container = 0; size = capacity = 0;
+	}
+#define Op(o, x) \
+	template<typename T>\
+	vector_type<typename types::Coercion<_Ty, T>::type> inline x(const vector_type<T>& r) const {\
+		vector_type<typename types::Coercion<_Ty, T>::type> ret(size);\
+		for (int i = 0; i < size; ++i)\
+			ret[i] = container[i] o r[i];\
+		return ret;\
+	}
+
+#define Opeq(o, x) \
+	template<typename T>\
+	vector_type<typename types::Coercion<_Ty, T>::type> inline x##eq(const vector_type<T>& r) {\
+		for (int i = 0; i < size; ++i)\
+			container[i] = container[i] o##= r[i];\
+		return *this;\
+	}
+
+#define Ops(o, x) \
+	template<typename T>\
+	vector_type<typename types::Coercion<_Ty, T>::type> operator o (const vector_type<T>& r) const {\
+		[[likely]] if (r.size == size) {\
+			return x(r);\
+		}\
+	}
+
+#define Opseq(o, x) \
+	template<typename T>\
+	vector_type<typename types::Coercion<_Ty, T>::type> operator o##= (const vector_type<T>& r) {\
+		[[likely]] if (r.size == size) {\
+			return x##eq(r);\
+		}\
+	}
+
+#define _Make_Ops(M) \
+	M(+, add) \
+	M(-, minus) \
+	M(*, multi) \
+	M(/, div) \
+	M(%, mod) 
+
+	_Make_Ops(Op)
+	_Make_Ops(Opeq)
+	_Make_Ops(Ops)
+	_Make_Ops(Opseq)
+};
+
+
+template <>
+class vector_type<void> {
+public:
+	void* container;
+	uint32_t size, capacity;
+	typedef void* iterator_t;
+
+	vector_type(uint32_t size) : size(size), capacity(size) {
+		container = (void*)malloc(size);
+	}
+	template<typename _Ty>
+	constexpr vector_type(std::initializer_list<_Ty> _l) {
+		size = capacity = _l.size();
+		this->container = malloc(sizeof(_Ty) * _l.size());
+		_Ty* _container = (_Ty*)this->container;
+		for (const auto& l : _l) {
+			*(_container++) = l;
+		}
+	}
+	constexpr vector_type() : size(0), capacity(0), container(0) {};
+	void* get(uint32_t i, types::Type_t atype){
+		return static_cast<void*>(static_cast<char*>(container) + (i * types::AType_sizes[atype]));
+	}
+	void operator[](const uint32_t& i) {
+		
+	}
+};
+#pragma pack(pop)
+#endif

server/winhelper.cpp

@@ -0,0 +1,36 @@
+#include "winhelper.h"
+#include <Windows.h>
+
+
+void* dlopen(const char* lib, int)
+{
+	return LoadLibraryA(lib);
+}
+
+void* dlsym(void* handle, const char* proc)
+{
+	return reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(handle), proc));
+}
+
+int dlclose(void* handle)
+{
+	return FreeLibrary(static_cast<HMODULE>(handle));
+}
+
+SharedMemory::SharedMemory(const char* fname)
+{
+    this->hFileMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 2, fname);
+    if (this->hFileMap)
+        this->pData = MapViewOfFile(this->hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, 2);
+    else
+        this->pData = NULL;
+}
+
+void SharedMemory::FreeMemoryMap()
+{
+    if (this->hFileMap) 
+        if (this->pData)
+            UnmapViewOfFile(this->pData);
+        if (this->hFileMap)
+            CloseHandle(this->hFileMap);
+}

server/winhelper.h

@@ -0,0 +1,14 @@
+#ifndef _WINHELPER_H
+#define _WINHELPER_H
+static constexpr int RTLD_LAZY = 1;
+void* dlopen(const char*, int);
+void* dlsym(void*, const char*);
+int dlclose(void*);
+struct SharedMemory
+{
+    void* hFileMap;
+    void* pData;
+    SharedMemory(const char*);
+    void FreeMemoryMap();
+};
+#endif