Return to serializable.h CVS log

Up to [truecrypt] / truecrypt / platform

Annotation of truecrypt/platform/serializable.h, revision 1.1.1.6

1.1       root        1: /*
1.1.1.6 ! root        2:  Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.
1.1       root        3: 
1.1.1.6 ! root        4:  Governed by the TrueCrypt License 2.8 the full text of which is contained in
        !             5:  the file License.txt included in TrueCrypt binary and source code distribution
        !             6:  packages.
1.1       root        7: */
                      8: 
                      9: #ifndef TC_HEADER_Platform_Serializable
                     10: #define TC_HEADER_Platform_Serializable
                     11: 
                     12: #include <stdexcept>
                     13: #include "PlatformBase.h"
                     14: #include "ForEach.h"
                     15: #include "Serializer.h"
                     16: #include "SerializerFactory.h"
                     17: 
                     18: namespace TrueCrypt
                     19: {
                     20:        class Serializable
                     21:        {
                     22:        public:
                     23:                virtual ~Serializable () { }
                     24: 
                     25:                virtual void Deserialize (shared_ptr <Stream> stream) = 0;
                     26:                static string DeserializeHeader (shared_ptr <Stream> stream);
                     27:                static Serializable *DeserializeNew (shared_ptr <Stream> stream);
                     28:                
                     29:                template <class T> 
                     30:                static shared_ptr <T> DeserializeNew (shared_ptr <Stream> stream)
                     31:                {
                     32:                        shared_ptr <T> p (dynamic_cast <T *> (DeserializeNew (stream)));
                     33:                        if (!p)
                     34:                                throw std::runtime_error (SRC_POS);
                     35:                        return p;
                     36:                }
                     37: 
                     38:                template <class T> 
                     39:                static void DeserializeList (shared_ptr <Stream> stream, list < shared_ptr <T> > &dataList)
                     40:                {
                     41:                        if (DeserializeHeader (stream) != string ("list<") + SerializerFactory::GetName (typeid (T)) + ">")
                     42:                                throw std::runtime_error (SRC_POS);
                     43: 
                     44:                        Serializer sr (stream);
                     45:                        uint64 listSize;
                     46:                        sr.Deserialize ("ListSize", listSize);
                     47: 
1.1.1.5   root       48:                        for (size_t i = 0; i < listSize; i++)
1.1       root       49:                        {
                     50:                                shared_ptr <T> p (dynamic_cast <T *> (DeserializeNew (stream)));
                     51:                                if (!p)
                     52:                                        throw std::runtime_error (SRC_POS);
                     53:                                dataList.push_back (p);
                     54:                        }
                     55:                }
                     56: 
                     57:                virtual void Serialize (shared_ptr <Stream> stream) const;
                     58: 
                     59:                template <class T>
                     60:                static void SerializeList (shared_ptr <Stream> stream, const list < shared_ptr <T> > &dataList)
                     61:                {
                     62:                        Serializer sr (stream);
                     63:                        SerializeHeader (sr, string ("list<") + SerializerFactory::GetName (typeid (T)) + ">");
                     64: 
                     65:                        sr.Serialize ("ListSize", (uint64) dataList.size());
                     66:                        foreach_ref (const T &item, dataList)
                     67:                                item.Serialize (stream);
                     68:                }
                     69: 
                     70:                static void SerializeHeader (Serializer &serializer, const string &name);
                     71: 
                     72:        protected:
                     73:                Serializable () { }
                     74:        };
                     75: }
                     76: 
                     77: #define TC_SERIALIZABLE(TYPE) \
                     78:        static Serializable *GetNewSerializable () { return new TYPE(); } \
                     79:        virtual void Deserialize (shared_ptr <Stream> stream); \
                     80:        virtual void Serialize (shared_ptr <Stream> stream) const
                     81: 
                     82: #endif // TC_HEADER_Platform_Serializable

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.