Ho bisogno di gestire diversi elementi in un vettore, ogni elemento possiede un parametro specifico (intero o stringa), così posso facilmente gestire la codifica / decodifica di una serie di elementi.
-
La codifica di un elenco di elementi serializza gli elementi, inserendo un separatore tra loro.
-
La decodifica di una stringa consiste nel trovare i separatori per ciascuna sottostringa, estraendo l'ID e il valore specifico del tipo. Esempio (sapendo che "FOO" è associato a un numero intero e "BAR" è associato a una stringa): "FOO = 54, BAR = ciao" restituisce {{ID_FOO, 54}, {ID_BAR, "ciao"}}.
Ho il seguente design semplice:
#include <cstdint>
#include <cstdlib>
#include <string>
#include <memory>
enum eID { /*...*/ };
// Base class
class Base {
private:
enum eID m_Id;
public:
Base(enum eID = 0): m_Id(eID) {}
virtual std::string Encode() {
// Return encoding of m_Id
}
static Base* Decode(const std::string &str) {
Base *ptr;
// Extract id
// According to the kind of id, create a new Derived<T>
// giving the substring to the constructor
// ptr = new Derived<...>(id, str.substr(...));
return ptr;
}
};
template <class T>
class Derived<T> : public Base {
private:
T m_Value;
public:
Derived(enum eID id, const std::string &str); // participates to decoding
std::string Encode();
};
template<>
Derived<std::string>::Derived(enum eID id, const std::string &str) {
m_Value = str; // easy
}
template<>
std::string Derived<std::string>::Encode() {
return static_cast<Base*>(this)->Encode() + m_Value;
}
template<>
Derived<long>::Derived(enum eID id, const std::string &str) {
m_Value = strtol(str.c_str(), nullptr, 10);
}
template<>
std::string Derived<long>::Encode() {
// Encode id and integer param to a string
}
class BaseList {
private:
std::vector<std::unique_ptr<Base>> m_List;
public:
void Append(Base *ptr) {
m_List.push_back(std::unique_ptr<Base>(ptr));
}
std::string Encode() {
// Call each Encode() function and concatenate strings together
// Insert a delimiter in-between substrings
}
void Decode(const std::string &sToDecode) {
// Look for delimiters in sToDecode
// For each delimited substring:
// - call Base::Decode() to allocate a new type-specific object
// - push back into m_List
}
}
(Questo non è un esempio di compilazione completo.)
È un progetto logico? Come potrebbe essere ottimizzato in modo che possa corrispondere a qualsiasi modello di progetto esistente? In particolare, mi occupo della tecnica di decodifica, che qui è suddivisa in BaseList :: Decode () e il metodo statico Base :: Decode ().