Public release of the DLU server code!

Have fun!
2025-08-09 20:24:16 +00:00 · 2021-12-05 18:54:36 +01:00
parent 5f7270e4ad
commit 0545adfac3
1146 changed files with 368646 additions and 1 deletions
--- a/dCommon/LDFFormat.cpp
+++ b/dCommon/LDFFormat.cpp
@@ -0,0 +1,134 @@
+#include "LDFFormat.h"
+
+// Custom Classes
+#include "GeneralUtils.h"
+
+// C++
+#include <sstream>
+#include <vector>
+
+//! Returns a pointer to a LDFData value based on string format
+LDFBaseData * LDFBaseData::DataFromString(const std::string& format) {
+    
+    // First, check the format
+    std::istringstream ssFormat(format);
+    std::string token;
+    
+    std::vector<std::string> keyValueArray;
+    while (std::getline(ssFormat, token, '=')) {
+        keyValueArray.push_back(token);
+    }
+    
+    if (keyValueArray.size() == 2) {
+        std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
+        
+        std::vector<std::string> dataArray;
+        std::istringstream ssData(keyValueArray[1]);
+        while (std::getline(ssData, token, ':')) {
+            dataArray.push_back(token);
+        }
+
+		if (dataArray.size() > 2) { // hacky fix for strings with colons in them
+			std::vector<std::string> newDataArray;
+			newDataArray.push_back(dataArray[0]);
+			std::string value = "";
+			for (size_t i = 1; i < dataArray.size(); ++i) {
+				value += dataArray[i] + ':';
+			}
+			value.pop_back(); // remove last colon
+			newDataArray.push_back(value);
+			dataArray = newDataArray;
+		}
+        
+        if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
+            dataArray.push_back("");
+        }
+        
+        if (dataArray.size() == 2) {
+            eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
+            
+            switch (type) {
+                case LDF_TYPE_UTF_16: {
+                    std::u16string data = GeneralUtils::ASCIIToUTF16(dataArray[1]);
+                    return new LDFData<std::u16string>(key, data);
+                }
+                    
+                case LDF_TYPE_S32: {
+                    int32_t data = static_cast<int32_t>(stol(dataArray[1]));
+                    return new LDFData<int32_t>(key, data);
+                }
+                    
+                case LDF_TYPE_FLOAT: {
+                    float data = static_cast<float>(stof(dataArray[1]));
+                    return new LDFData<float>(key, data);
+                }
+                    
+                case LDF_TYPE_DOUBLE: {
+                    double data = static_cast<float>(stod(dataArray[1]));
+                    return new LDFData<double>(key, data);
+                }
+                    
+                case LDF_TYPE_U32:
+            	{
+                    uint32_t data;
+                	
+                	if (dataArray[1] == "true")
+                	{
+                        data = 1;
+                	}
+                    else if (dataArray[1] == "false")
+                    {
+                        data = 0;
+                    }
+                    else
+                    {
+	                    data = static_cast<uint32_t>(stoul(dataArray[1]));
+                    }
+                	
+                    return new LDFData<uint32_t>(key, data);
+                }
+                    
+                case LDF_TYPE_BOOLEAN: {
+                    bool data;
+                	
+                	if (dataArray[1] == "true")
+                	{
+                        data = true;
+                	}
+                    else if (dataArray[1] == "false")
+                    {
+                        data = false;
+                    }
+                    else
+                    {
+	                    data = static_cast<bool>(stoi(dataArray[1]));
+                    }
+                	
+                    return new LDFData<bool>(key, data);
+                }
+                    
+                case LDF_TYPE_U64: {
+                    uint64_t data = static_cast<uint64_t>(stoull(dataArray[1]));
+                    return new LDFData<uint64_t>(key, data);
+                }
+                    
+                case LDF_TYPE_OBJID: {
+                    LWOOBJID data = static_cast<LWOOBJID>(stoll(dataArray[1]));
+                    return new LDFData<LWOOBJID>(key, data);
+                }
+                    
+                case LDF_TYPE_UTF_8: {
+                    std::string data = dataArray[1];
+                    return new LDFData<std::string>(key, data);
+                }
+                    
+                case LDF_TYPE_UNKNOWN: {
+                    return nullptr;
+                }
+            }
+        }
+    }
+    
+    return nullptr;
+    
+}