serializer.h

//===========================================================================
#ifndef comfrm_ifc_SerializerH
#define comfrm_ifc_SerializerH
//===========================================================================
// Заготовка модуля Serializer была сгенерирована специальным средством RAD разработки SA2-DE.
// Все права защищены. (2016)
//
// В данном файле представлен исходный текст основного заголовочного файла модуля.
//
//  В данном файле представлен паттерн класса.
//  Описание класса:
//  Отображение, сопоставляющее строкам произвольные типы данных
// ======================================= //
//       Параметры новой разработки.      
// ======================================= //
// Имя комплекса:  GCAD  (gcd)
// Имя решения:    GCAD_2 (gc3)
// Имя проекта:    Default  (def)
// Полный SID:     defgc3
// Время создания: 13:29:19    
// Дата создания:  2016-03-10
// ======================================= //
// ============================================================================================ //
// [prd]Period:                     03/2016
// [aut]Author:                     Першин Антон
// [did]DeveloperID:                ap
// [pid]ProblemID:                  00001
// [rvs = did.date.pid]Revision:    //#ap.2016-03-10.00001
// [dsc]Description:                Создание файла.
// [ccm]CodeComment:                rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
// ============================================================================================ //

//========================================================================
// ДОПОЛНИТЕЛЬНЫЕ ПОДКЛЮЧЕНИЯ (Типы и модули, необходимые для .h - файла)
//------------------------------------------------------------------------
#include "libtools.h"
#include "serializertools.h"

#include <vector>
#include <forward_list>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <type_traits>

#define INIT_SERIALIZER(n)                          \
    protected:                                      \
        const char* __internal_ClassName__() const  \
        {                                           \
            return #n;                              \
        }


//========================================================================
namespace com {
    namespace srl {
        template < typename T >
        struct stc_TypeName
        {
            static const char* get()
            {
                return "UNKNOWN";
            }
        };

        //template < typename T >
        class MAC_DLLEXPORT Serializer
        {
        public:
            Serializer(){}

            std::string getClassName()
            {
                return __internal_ClassName__();
            }

            virtual bool serialize(std::ostream& o_out) const = 0;
            virtual bool deserialize(std::ostream& o_in) = 0;

            template < class T >
            bool serializeMember(std::ostream& o_out, const T& p_member) const;

        protected:
            virtual const char* __internal_ClassName__() const = 0;
        };

        template < typename T >
        class tmp_TypeSerializer
        {
        public:
            template < class Q = T >
            typename std::enable_if<std::is_fundamental< Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                o_ok = com::srl::serializeBaseType(o_out, p_member);
            }

            template < class Q = T >
            //typename std::enable_if<std::is_same< std::string, Q >::value>::type
            typename std::enable_if<std::is_base_of< std::basic_string< char >, Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                o_ok = com::srl::serializeStdString(o_out, p_member);
            }

            template < class Q = T >
            typename std::enable_if<std::is_simple_stl_container< Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                //o_ok = com::srl::serializeSTLContainer(o_out, p_member, );
                o_ok = serializeSimpleSTLContainer(o_out, p_member);
            }

            template < class Q = T >
            typename std::enable_if<std::is_std_set< Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                //o_ok = com::srl::serializeSTLContainer(o_out, p_member, );
                o_ok = serializeSTLSet(o_out, p_member);
            }

            template < class Q = T >
            typename std::enable_if<std::is_std_map< Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                //o_ok = com::srl::serializeSTLContainer(o_out, p_member, );
                o_ok = serializeSTLMap(o_out, p_member);
            }

            template < class Q = T >
            typename std::enable_if<std::is_std_unordered_map< Q >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                //o_ok = com::srl::serializeSTLContainer(o_out, p_member, );
                o_ok = serializeSTLUnorderedMap(o_out, p_member);
            }

            template < class Q = T >
            typename std::enable_if<std::is_base_of< Serializer, typename std::remove_pointer< Q >::type >::value>::type
            serializeType(std::ostream& o_out, const Q& p_member, bool& o_ok)
            {
                try
                {
                    const Serializer& memberIfc = dynamic_cast< const Serializer& >(p_member);
                    o_ok = memberIfc.serialize(o_out);
                }
                catch(std::bad_cast p_exc)
                {
                    o_ok = false;
                }
            }

            template < class Q = T >
            typename std::enable_if<std::is_base_of< Serializer, typename std::remove_pointer< Q >::type >::value>::type
            //typename std::enable_if<std::is_pointer< Q >::value>::type
            serializeType(std::ostream& o_out, Q* const p_member, bool& o_ok)
            {
                try
                {
                    const Serializer* memberIfc = dynamic_cast< const Serializer* >(p_member);
                    o_ok = memberIfc->serialize(o_out);
                }
                catch(std::bad_cast p_exc)
                {
                    o_ok = false;
                }
            }

            template <template <typename VT, typename AT> class Container, class Value, class Alloc>
            bool serializeSimpleSTLContainer(std::ostream& o_out, const Container< Value, Alloc >& p_member)
            {
                return serializeValueLikedContainer< Container< Value, Alloc >, Value >(o_out, p_member);
            }

            template <template <typename VT, typename CT, typename AT> class Set, class Value, class Comp, class Alloc>
            bool serializeSTLSet(std::ostream& o_out, const Set< Value, Comp, Alloc >& p_member)
            {
                return serializeValueLikedContainer< Set< Value, Comp, Alloc >, Value >(o_out, p_member);
            }

            template <template <typename KT, typename VT, typename CT, typename AT> class Map, class Key, class Value, class Comp, class Alloc>
            bool serializeSTLMap(std::ostream& o_out, const Map< Key, Value, Comp, Alloc >& p_member)
            {
                return serializeKeyValueLikedContainer<Map< Key, Value, Comp, Alloc >, Key, Value>(o_out, p_member);
            }

            template <template <typename KT, typename VT, typename HT, typename PT, typename AT> class UnorderedMap, class Key, class Value, class Hash, class Pred, class Alloc>
            bool serializeSTLUnorderedMap(std::ostream& o_out, const UnorderedMap< Key, Value, Hash, Pred, Alloc >& p_member)
            {
                return serializeKeyValueLikedContainer<UnorderedMap< Key, Value, Hash, Pred, Alloc >, Key, Value>(o_out, p_member);
            }

        private:
            template <class Container, class Value>
            bool serializeValueLikedContainer(std::ostream& o_out, const Container& p_member)
            {
                bool ok = true;
                tmp_TypeSerializer< Value > ts;
                for (auto it = p_member.begin(); it != p_member.end(); ++it)
                {
                    bool iterOk = false;
                    ts.serializeType(o_out, *it, iterOk);
                    ok &= iterOk;
                }

                return ok;
            }

            template <class Container, class Key, class Value>
            bool serializeKeyValueLikedContainer(std::ostream& o_out, const Container& p_member)
            {
                bool ok = true;
                tmp_TypeSerializer< Key > keyTS;
                tmp_TypeSerializer< Value > valTS;
                for (auto it = p_member.begin(); it != p_member.end(); ++it)
                {
                    bool iterOk = false;
                    keyTS.serializeType(o_out, it->first, iterOk);
                    ok &= iterOk;
                    valTS.serializeType(o_out, it->second, iterOk);
                    ok &= iterOk;
                }

                return ok;
            }
        };

        template < class T >
        bool Serializer::serializeMember(std::ostream& o_out, const T& p_member) const
        {
            tmp_TypeSerializer< T > ts;
            bool ok = false;
            ts.serializeType(o_out, p_member, ok);
            return ok;
        }
    }
}

//===========================================================================
#endif
//===========================================================================