C++ - boost :: qualsiasi serializzazione

Question

Per quanto ho capito, non esiste alcuna serializzazione (boost::serialization, in realtà) supporto per segnaposto boost::any.

Qualcuno sa se esiste un modo per serializzare un'entità personalizzata boost::any?

Il problema qui è ovvio: boost::any utilizza segnaposto basati su modello per memorizzare oggetti e typeid per verificare se boost::any_cast è appropriato.

Quindi, c'è un astratti personalizzato classi derivate basate su template superclasse placeholder e personalizzati, che vengono creati nel seguente modo:

template <T> custom_placeholder : public placeholder { 
    virtual std::type_info type() const { return typeid(T); } 
    virtual ... 
}; 

Ovviamente, questo porta qualche problema quando nemmeno pensarci serializzazione questa roba. Forse qualcuno conosce qualche trucco per realizzare un tale tipo di serializzazione (e, naturalmente, una deserializzazione appropriata)?

Grazie

Answer 1

Non è possibile a tutti, almeno per i tipi arbitrari. Nota che potresti serializzare usando un codice complicato (come trovare la dimensione degli elementi contenuti in qualsiasi), ma il codice si basa sul compilatore che inserisce staticamente qualsiasi tipo_code e il tipo corretto all'interno del segnaposto. Sicuramente non è possibile farlo in deserializzazione in C++, poiché il tipo che si otterrebbe dalla deserializzazione non è noto in fase di compilazione (come richiesto dal neo formato boost::any).

La soluzione migliore consiste nel creare un tipo di specialista di qualsiasi tipo per i tipi esatti di elementi che verranno serializzati. Quindi, è possibile avere casi speciali per il tipo effettivo di elemento che viene deserializzato, ma si noti che ogni serializzazione/deserializzazione di ogni elemento deve essere scritta fisicamente come codice C++ statico.

PD. Alcuni altri hanno suggerito di utilizzare boost::variant come una rappresentazione di questo tipo specializzato che contiene i tipi esatti da serializzare. Tuttavia, è necessario un modo per discernere il tipo esatto sulla deserializzazione (magari assegnando identificatori ai tipi nella variante).

Answer 2

Supponendo che sia necessario utilizzare boost::any e non è possibile passare a variant, una soluzione basata su potrebbe farvi fare.

È necessario inizializzare in fase di esecuzione tale map con tutti i tipi che si prevede di utilizzare. Naturalmente, è possibile utilizzare qualcosa sulla falsariga di

template <typename T> 
struct any_serializer 
{ 
    static string perform(any a) 
    { 
     T const& x = any_cast<T const&>(a); 
     stringstream out; 
     out << x; 
     return out.str(); 
    } 
}; 

e popolare la mappa con gli indirizzi di any_serializer<T>::perform sotto la chiave &typeid(T). È possibile specializzare la classe any_serializer e utilizzare alcuni (brutti) macro per popolare la mappa.

Più difficile è ovviamente la deserializzazione. Non ho dato un'occhiata a boost::lexical_cast per un po ', forse può fornire un aiuto. Temo che questo sia totalmente dipendente dal problema. Tuttavia, è necessaria solo una funzione, che prende uno string e restituisce uno any. Si potrebbe anche voler anteporre la stringa di output con un identificatore di tipo personalizzato.

Answer 3

Se si desidera attenersi a boost :: any non sono sicuro, ma è possibile scrivere il proprio "boost :: any". Sto usando questo codice per i metodi proxy per passare i parametri.

#include <iostream> 
#include <boost\smart_ptr\scoped_ptr.hpp> 
#include <boost/shared_ptr.hpp> 
#include <boost/serialization/access.hpp> 
#include <boost/serialization/shared_ptr.hpp> 
#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/export.hpp> 
#include <sstream> 
class my_placeholder 
{ 
public: 
    virtual ~my_placeholder(){} 
    my_placeholder(){} 
private: 
    friend class boost::serialization::access; 
    template<class Archive> 
    void serialize(Archive & ar, const unsigned int version) 
    { 
     // serialize base class information 
     //ar & boost::serialization::base_object<bus_stop>(*this); 
     //ar & m_placeholder; 

    } 

}; 




template<typename T> 
class my_derivedplaceholder: 
    public my_placeholder 
{ 
    public: 
     my_derivedplaceholder() 
     { 

     } 
     my_derivedplaceholder(T &value) 
     { 
      m_value=value; 
     } 
    T m_value; 

private: 
    friend class boost::serialization::access; 
    template<class Archive> 
    void serialize(Archive & ar, const unsigned int version) 
    { 
     // serialize base class information 
     ar & boost::serialization::base_object<my_placeholder>(*this); 
     ar & m_value; 

    } 
}; 


BOOST_CLASS_EXPORT_GUID(my_derivedplaceholder<int>, "p<int>"); 


class my_any 
{ 
public: 

    my_any() 
    { 

    } 

    template<typename T> 
    my_any(const T &value) 
    { 
     m_placeholder.reset(new my_derivedplaceholder<T>(const_cast<T&>(value))); 
    } 

    template<typename T> 
    void operator=(const T &value) 
    { 
     m_placeholder.reset(new my_derivedplaceholder<T>(const_cast<T&>(value))); 
    } 



protected: 

    friend class boost::serialization::access; 
    template<class Archive> 
    void serialize(Archive & ar, const unsigned int version) 
    { 
     // serialize base class information 
     //ar & boost::serialization::base_object<bus_stop>(*this); 
     ar & m_placeholder; 

    } 

    template<typename T> 
    friend T my_anycast(my_any &val); 

    boost::shared_ptr<my_placeholder> m_placeholder; 
}; 

template<typename T> 
T my_anycast(my_any &val) 
{ 
    boost::shared_ptr<my_derivedplaceholder<T>> concrete=boost::dynamic_pointer_cast<my_derivedplaceholder<T>>(val.m_placeholder); 
    if (concrete.get()==NULL) 
     throw std::invalid_argument("Not convertible"); 

    return concrete->m_value; 
} 

void main() 
{ 
    my_any m=10; 

    int a=my_anycast<int>(m); 

    std::cout << a << std::endl; 

    std::stringstream ss,ss2; 
    boost::archive::text_oarchive oa(ss); 

    oa << m; 

    boost::archive::text_iarchive ia(ss); 

    my_any m2; 
    ia >> m2; 

    std::cout << my_anycast<int>(m2) << std::endl; 
} 

Answer 4

Non è necessario creare una nuova classe. Prova ad usare xany https://sourceforge.net/projects/extendableany/?source=directory xany class permette di aggiungere nuovi metodi alle funzionalità esistenti. Tra l'altro c'è un esempio nella documentazione che fa esattamente quello che vuoi.