serializertools.h

//===========================================================================
#ifndef comfrm_unt_SerializerToolsH
#define comfrm_unt_SerializerToolsH
//===========================================================================
// Заготовка модуля SerializerTools была сгенерирована специальным средством 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 "comfrm_unt_StreamTools.h"

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

namespace std
{
    template < typename >
    struct is_std_vector : std::false_type {};
    template< typename T >
    struct is_std_vector< std::vector< T > > : std::true_type {};

    template < typename >
    struct is_std_list : std::false_type {};
    template< typename T >
    struct is_std_list< std::list< T > > : std::true_type {};

    template < typename >
    struct is_std_deque : std::false_type {};
    template< typename T >
    struct is_std_deque< std::deque< T > > : std::true_type {};

    template < typename >
    struct is_std_forward_list : std::false_type {};
    template< typename T >
    struct is_std_forward_list< std::forward_list< T > > : std::true_type {};

    template < typename >
    struct is_std_queue : std::false_type {};
    template< typename T >
    struct is_std_queue< std::queue< T > > : std::true_type {};

    template < typename >
    struct is_std_set : std::false_type {};
    template< typename T >
    struct is_std_set< std::set< T > > : std::true_type {};

    template < typename >
    struct is_std_stack : std::false_type {};
    template< typename T >
    struct is_std_stack< std::stack< T > > : std::true_type {};

    template < typename >
    struct is_std_unordered_set : std::false_type {};
    template< typename T >
    struct is_std_unordered_set< std::unordered_set< T > > : std::true_type {};



    template < typename >
    struct is_std_map : std::false_type {};
    template< typename K, typename V >
    struct is_std_map< std::map< K, V > > : std::true_type {};

    template < typename >
    struct is_std_unordered_map : std::false_type {};
    template< typename K, typename V >
    struct is_std_unordered_map< std::unordered_map< K, V > > : std::true_type {};

    template< typename T >
    struct is_simple_stl_container : std::integral_constant < bool,
                std::is_std_vector<T>::value ||
                std::is_std_list<T>::value ||
                std::is_std_deque<T>::value ||
                std::is_std_forward_list<T>::value ||
                std::is_std_queue<T>::value ||
                std::is_std_stack<T>::value > {};
                // !std::is_base_of< std::basic_string< char >, T >::value > {};
}

namespace com
{
    namespace srl
    {
        template < typename T >
        bool serializeBaseType(std::ostream& o_out, T p_member)
        {
            o_out.write((const char*) &p_member, sizeof(p_member));
            return true;
        }

        template < typename T >
        bool serializeBaseType(std::ostream& o_out, const T* p_member, size_t p_elemCount)
        {
            // Кол-во элементов в массиве
            o_out.write((const char*) &p_elemCount, sizeof(p_elemCount));

            // Сам массив
            o_out.write((const char*) p_member, p_elemCount*sizeof(T));

            return true;
        }

        bool serializeStdString(std::ostream& o_out, const std::string& p_member)
        {
            // Кол-во элементов в массиве
            size_t elemCount = p_member.size();
            o_out.write((const char*) &elemCount, sizeof(elemCount));

            // Сам массив
            o_out.write(p_member.c_str(), elemCount);

            return true;
        }

        template < typename T >
        const T* getPointer(const T& p_t)
        {
            return &p_t;
        }

        template < typename T >
        const T* getPointer(const T* p_t)
        {
            return p_t;
        }
    }
}
//===========================================================================
#endif
//===========================================================================