upload and download simulations

imgui.ini

@@ -260,14 +260,19 @@ Collapsed=0
 
 [Window][Browser]
 Pos=274,112
-Size=800,387
+Size=850,387
 Collapsed=0
 
 [Window][Login]
 Pos=749,421
 Size=268,171
 Collapsed=0
 
+[Window][Upload simulation]
+Pos=733,403
+Size=400,218
+Collapsed=0
+
 [Table][0xFB3C2B09,3]
 RefScale=13
 Column 0  Sort=0v

source/EngineInterface/Serializer.cpp

@@ -209,7 +209,7 @@ namespace cereal
 
 }
 
-bool Serializer::serializeSimulationToFile(std::string const& filename, DeserializedSimulation const& data)
+bool Serializer::serializeSimulationToFiles(std::string const& filename, DeserializedSimulation const& data)
 {
     try {
 
@@ -220,11 +220,11 @@ bool Serializer::serializeSimulationToFile(std::string const& filename, Deserial
         symbolsFilename.replace_extension(std::filesystem::path(".symbols.json"));
 
         {
-            zstr::ofstream fileStream(filename, std::ios::binary);
-            if (!fileStream) {
+            zstr::ofstream stream(filename, std::ios::binary);
+            if (!stream) {
                 return false;
             }
-            serializeDataDescription(data.content, fileStream);
+            serializeDataDescription(data.content, stream);
         }
         {
             std::ofstream stream(settingsFilename.string(), std::ios::binary);
@@ -248,7 +248,7 @@ bool Serializer::serializeSimulationToFile(std::string const& filename, Deserial
     }
 }
 
-bool Serializer::deserializeSimulationFromFile(std::string const& filename, DeserializedSimulation& data)
+bool Serializer::deserializeSimulationFromFiles(DeserializedSimulation& data, std::string const& filename)
 {
     try {
         std::filesystem::path settingsFilename(filename);
@@ -282,6 +282,127 @@ bool Serializer::deserializeSimulationFromFile(std::string const& filename, Dese
     }
 }
 
+bool Serializer::serializeSimulationToStrings(
+    std::string& content,
+    std::string& timestepAndSettings,
+    std::string& symbolMap,
+    DeserializedSimulation const& data)
+{
+    try {
+        {
+            std::stringstream stdStream;
+            zstr::ostream stream(stdStream, std::ios::binary);
+            if (!stream) {
+                return false;
+            }
+            serializeDataDescription(data.content, stream);
+            stream.flush();
+            content = stdStream.str();
+        }
+        {
+            std::stringstream stream;
+            serializeTimestepAndSettings(data.timestep, data.settings, stream);
+            timestepAndSettings = stream.str();
+        }
+        {
+            std::stringstream stream;
+            serializeSymbolMap(data.symbolMap, stream);
+            symbolMap = stream.str();
+        }
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool Serializer::deserializeSimulationFromStrings(
+    DeserializedSimulation& data,
+    std::string const& content,
+    std::string const& timestepAndSettings,
+    std::string const& symbolMap)
+{
+    try {
+        {
+            std::stringstream stdStream(content);
+            zstr::istream stream(stdStream, std::ios::binary);
+            if (!stream) {
+                return false;
+            }
+            deserializeDataDescription(data.content, stream);
+        }
+        {
+            std::stringstream stream(timestepAndSettings);
+            deserializeTimestepAndSettings(data.timestep, data.settings, stream);
+        }
+        {
+            std::stringstream stream(symbolMap);
+            deserializeSymbolMap(data.symbolMap, stream);
+        }
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+/*
+bool Serializer::serializeSimulationToSingleString(std::string& output, DeserializedSimulation const& data)
+{
+    try {
+        std::stringstream stream;
+        zstr::ostream zstrStream(stream);
+        if (!zstrStream) {
+            return false;
+        }
+        serializeDataDescription(data.content, zstrStream);
+        {
+            std::stringstream auxStream;
+            serializeTimestepAndSettings(data.timestep, data.settings, auxStream);
+            auto auxData = auxStream.str();
+            zstrStream << auxData;
+        }
+        {
+            std::stringstream auxStream;
+            serializeSymbolMap(data.symbolMap, auxStream);
+            auto auxData = auxStream.str();
+            zstrStream << auxData;
+        }
+        zstrStream.flush();
+        output = stream.str();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool Serializer::deserializeSimulationFromSingleString(DeserializedSimulation& data, std::string const& input)
+{
+    try {
+        std::stringstream stream(input);
+        zstr::istream zstrStream(stream);
+        if (!zstrStream) {
+            return false;
+        }
+        deserializeDataDescription(data.content, zstrStream);
+        {
+            std::string auxData;
+            zstrStream >> auxData;
+            std::stringstream auxStream(auxData);
+            deserializeTimestepAndSettings(data.timestep, data.settings, zstrStream);
+        }
+        {
+            std::string auxData;
+            zstrStream >> auxData;
+            std::stringstream auxStream(auxData);
+            deserializeSymbolMap(data.symbolMap, zstrStream);
+        }
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+*/
+
+
 bool Serializer::serializeContentToFile(std::string const& filename, ClusteredDataDescription const& content)
 {
     try {
@@ -297,7 +418,7 @@ bool Serializer::serializeContentToFile(std::string const& filename, ClusteredDa
     }
 }
 
-bool Serializer::deserializeContentFromFile(std::string const& filename, ClusteredDataDescription& content)
+bool Serializer::deserializeContentFromFile(ClusteredDataDescription& content, std::string const& filename)
 {
     try {
         if (!deserializeDataDescription(content, filename)) {
@@ -324,7 +445,7 @@ bool Serializer::serializeSymbolsToFile(std::string const& filename, SymbolMap c
     }
 }
 
-bool Serializer::deserializeSymbolsFromFile(std::string const& filename, SymbolMap& symbolMap)
+bool Serializer::deserializeSymbolsFromFile(SymbolMap& symbolMap, std::string const& filename)
 {
     try {
         std::ifstream stream(filename, std::ios::binary);

source/EngineInterface/Serializer.h

@@ -20,14 +20,30 @@ struct DeserializedSimulation
 class Serializer
 {
 public:
-    static bool serializeSimulationToFile(std::string const& filename, DeserializedSimulation const& data);
-    static bool deserializeSimulationFromFile(std::string const& filename, DeserializedSimulation& data);
+    static bool serializeSimulationToFiles(std::string const& filename, DeserializedSimulation const& data);
+    static bool deserializeSimulationFromFiles(DeserializedSimulation& data, std::string const& filename);
+
+    static bool serializeSimulationToStrings(
+        std::string& content,
+        std::string& timestepAndSettings,
+        std::string& symbolMap,
+        DeserializedSimulation const& data);
+    static bool deserializeSimulationFromStrings(
+        DeserializedSimulation& data,
+        std::string const& content,
+        std::string const& timestepAndSettings,
+        std::string const& symbolMap);
+
+/*
+    static bool serializeSimulationToSingleString(std::string& output, DeserializedSimulation const& data);
+    static bool deserializeSimulationFromSingleString(DeserializedSimulation& data, std::string const& input);
+*/
 
     static bool serializeContentToFile(std::string const& filename, ClusteredDataDescription const& content);
-    static bool deserializeContentFromFile(std::string const& filename, ClusteredDataDescription& content);
+    static bool deserializeContentFromFile(ClusteredDataDescription& content, std::string const& filenam);
 
     static bool serializeSymbolsToFile(std::string const& filename, SymbolMap const& symbolMap);
-    static bool deserializeSymbolsFromFile(std::string const& filename, SymbolMap& symbolMap);
+    static bool deserializeSymbolsFromFile(SymbolMap& symbolMap, std::string const& filename);
 
 private:
     static void serializeDataDescription(ClusteredDataDescription const& data, std::ostream& stream);

source/Gui/AlienImGui.cpp

@@ -151,7 +151,12 @@ bool AlienImGui::InputText(InputTextParameters const& parameters, char* buffer,
     if (parameters._password) {
         flags |= ImGuiInputTextFlags_Password;
     }
-    auto result = ImGui::InputText(("##" + parameters._name).c_str(), buffer, bufferSize, flags);
+    auto result = [&] {
+        if(!parameters._hint.empty()) {
+            return ImGui::InputTextWithHint(("##" + parameters._hint).c_str(), parameters._hint.c_str(), buffer, bufferSize, flags);
+        }
+        return ImGui::InputText(("##" + parameters._name).c_str(), buffer, bufferSize, flags);
+    }();
     if (parameters._monospaceFont) {
         ImGui::PopFont();
     }
@@ -163,24 +168,35 @@ bool AlienImGui::InputText(InputTextParameters const& parameters, char* buffer,
 
 bool AlienImGui::InputText(InputTextParameters const& parameters, std::string& text)
 {
-    char buffer[1024];
+    static char buffer[1024];
     StringHelper::copy(buffer, IM_ARRAYSIZE(buffer), text);
     auto result = InputText(parameters, buffer, IM_ARRAYSIZE(buffer));
     text = std::string(buffer);
 
     return result;
 }
 
-void AlienImGui::InputTextMultiline(InputTextMultilineParameters const& parameters, char* buffer, int bufferSize)
+void AlienImGui::InputTextMultiline(InputTextMultilineParameters const& parameters, std::string& text)
 {
+    static char buffer[1024*16];
+    StringHelper::copy(buffer, IM_ARRAYSIZE(buffer), text);
+
     auto textWidth = StyleRepository::getInstance().scaleContent(parameters._textWidth);
-    ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - textWidth);
     auto height = parameters._height == 0
         ? ImGui::GetContentRegionAvail().y
         : StyleRepository::getInstance().scaleContent(parameters._height);
-    ImGui::InputTextMultiline(("##" + parameters._name).c_str(), buffer, bufferSize, {0, height});
+    auto id = parameters._hint.empty() ? ("##" + parameters._name).c_str() : ("##" + parameters._hint).c_str();
+    ImGui::InputTextEx(
+        ("##" + parameters._name).c_str(),
+        parameters._hint.c_str(),
+        buffer,
+        IM_ARRAYSIZE(buffer),
+        {ImGui::GetContentRegionAvail().x - textWidth, height},
+        ImGuiInputTextFlags_Multiline);
     ImGui::SameLine();
     ImGui::TextUnformatted(parameters._name.c_str());
+
+    text = std::string(buffer);
 }
 
 namespace

source/Gui/AlienImGui.h

@@ -67,6 +67,7 @@ class AlienImGui
     struct InputTextParameters
     {
         MEMBER_DECLARATION(InputTextParameters, std::string, name, "");
+        MEMBER_DECLARATION(InputTextParameters, std::string, hint, "");
         MEMBER_DECLARATION(InputTextParameters, int, textWidth, 100);
         MEMBER_DECLARATION(InputTextParameters, bool, monospaceFont, false);
         MEMBER_DECLARATION(InputTextParameters, bool, readOnly, false);
@@ -78,10 +79,11 @@ class AlienImGui
     struct InputTextMultilineParameters
     {
         MEMBER_DECLARATION(InputTextMultilineParameters, std::string, name, "");
+        MEMBER_DECLARATION(InputTextMultilineParameters, std::string, hint, "");
         MEMBER_DECLARATION(InputTextMultilineParameters, int, textWidth, 100);
         MEMBER_DECLARATION(InputTextMultilineParameters, float, height, 100.0f);
     };
-    static void InputTextMultiline(InputTextMultilineParameters const& parameters, char* buffer, int bufferSize);
+    static void InputTextMultiline(InputTextMultilineParameters const& parameters, std::string& text);
 
     struct ComboParameters
     {

source/Gui/AutosaveController.cpp

@@ -59,5 +59,5 @@ void _AutosaveController::onSave()
     sim.settings = _simController->getSettings();
     sim.symbolMap = _simController->getSymbolMap();
     sim.content = _simController->getClusteredSimulationData();
-    Serializer::serializeSimulationToFile(Const::AutosaveFile, sim);
+    Serializer::serializeSimulationToFiles(Const::AutosaveFile, sim);
 }