SERIALIZER

#include <iostream>
#include <fstream>
#include <sstream>
#include <unordered_map>
#include <vector>
#include <algorithm>

class MiObjeto {
public:
    std::unordered_map<std::string, std::string> datos;

    // Método para serializar el objeto
    void serializar(std::ostream& out) const {
        // Crear un vector de pares ordenados por clave
        std::vector<std::pair<std::string, std::string>> sortedDatos(datos.begin(), datos.end());
        // Ordenar el vector por clave
        std::sort(sortedDatos.begin(), sortedDatos.end());

        // Serializar los datos ordenados
        for (const auto& par : sortedDatos) {
            out << par.first << "::\"" << par.second << "\"\n";
        }
    }

    // Método para deserializar el objeto
    void deserializar(std::istream& in) {
        std::string linea;
        while (std::getline(in, linea)) {
            std::istringstream iss(linea);
            std::string clave, token, valor;

            if (std::getline(iss, clave, ':') && std::getline(iss, token, '\"') && std::getline(iss, valor, '\"')) {
                datos[clave] = valor;
            }
        }
    }

    // Operador de índice para facilitar la asignación
    std::string& operator[](const std::string& clave) {
        return datos[clave];
    }

    // Operador de índice constante para permitir la búsqueda sin modificar
    const std::string& operator[](const std::string& clave) const {
        static const std::string valorPredeterminado = "";
        auto iter = datos.find(clave);
        if (iter != datos.end()) {
            return iter->second;
        } else {
            return valorPredeterminado;
        }
    }
};

int main() {
    // Crear un objeto
    MiObjeto DatosAGuardar;


    MiObjeto miObjeto;
    // Asignar valores usando el operador de índice
    miObjeto["personaje"] = "GOKU";
    miObjeto["edad"] = "25";
    miObjeto["pais"] = "NO";

    DatosAGuardar["gokuprueba"] = miObjeto;

    // Serializar el objeto y escribirlo en un archivo
    std::ofstream archivoSalida("datos.txt");
    if (archivoSalida.is_open()) {
        miObjeto.serializar(archivoSalida);
        archivoSalida.close();
    } else {
        std::cerr << "Error al abrir el archivo de salida\n";
        return 1;
    }

    // Leer el archivo y deserializar el objeto
    MiObjeto objetoLeido;
    std::ifstream archivoEntrada("datos.txt");
    if (archivoEntrada.is_open()) {
        objetoLeido.deserializar(archivoEntrada);
        archivoEntrada.close();
    } else {
        std::cerr << "Error al abrir el archivo de entrada\n";
        return 1;
    }

    // Buscar un valor específico
    std::string valor = objetoLeido["Dato2"];
    std::cout << "Valor de Dato2: " << valor << "\n";

    // Intentar buscar una clave que no existe
    std::string valorNoExistente = objetoLeido["Dato3"];
    std::cout << "Valor de Dato4: " << valorNoExistente << "\n";

    return 0;
}