serializer

#include <string.h>
#include<iostream>
#include <sstream>

enum class Error
{
    NoError,
    CorruptedArchive,
    IncorrectType
};


struct Data
{
    uint64_t a;
    bool b;
    uint64_t c;

    template <class Serializer>
    Error serialize(Serializer& serializer)
    {
        return serializer(a, b, c);
    }

    template <class Deserializer>
    Error deserialize(Deserializer& deserializer)
    {
        return deserializer(a, b, c);
        }
  // serializer.h
//#pragma once

};
template <class T1, class T2>
struct IsSame
{
    static constexpr bool value = false;
};

template <class T>
struct IsSame<T, T>
{
    static constexpr bool value = true;
};

class Serializer
{
    std::ostream &out_;
    static constexpr char Separator = ' ';

public:
    explicit Serializer(std::ostream& out)
        : out_(out)
    {
    }

    template <class T>
    Error save(T& object)
    {
        return object.serialize(*this);
    }

    template <class... ArgsT>
    Error operator()(ArgsT... args)
    {
        return process(args...);
    }

private:

    template<class T>
    Error process(T value){
        if(IsSame<bool,decltype(value)>::value){
            out_ << (value ? "true" : "false") << Separator;
            return Error::NoError;
        } else if(IsSame<uint64_t,decltype(value)>::value){
            out_ << value << Separator;
            return Error::NoError;
        } else{
            return Error::IncorrectType;
        }
    }

    template <class T, class... ArgsT>
    Error process(T value, ArgsT... args){
        if(IsSame<bool,decltype(value)>::value){
            out_ << (value ? "true" : "false") << Separator;
        } else if(IsSame<uint64_t,decltype(value)>::value){
            out_ << value << Separator;
        } else{
            return Error::IncorrectType;
        }
        return process(args...);
    }
    // process использует variadic templates
};
/////////////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////
//-------------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////

class Deserializer
{
    std::istream &in_;
    static constexpr char Separator = ' ';

    static bool isNumber(const std::string &str){
        for(auto ch : str){
            //std::cout<< ch;
            if((ch < 48 )||(ch > 57)){
                return false;
            }
            return true;
        }
    }

public:
    explicit Deserializer(std::istream& in)
        : in_(in)
    {
    }

    template <class T>
    Error load(T& object)
    {
        return object.deserialize(*this);
    }

    template <class... ArgsT>
    Error operator()(ArgsT... args)
    {
        return process(args...);
    }

private:

    template<class T>
    Error process(T &value){

        std::string str;
        std::stringstream str_stream;
        uint64_t temp;
        if(IsSame<bool&,decltype(value)>::value){
            in_>> str;
            if(str == "true"){
                value =  true;
                return Error :: NoError;
            } else if(str == "false"){
                value = false;
                return Error :: NoError;
            } else{
                return Error::CorruptedArchive;
            }
        } else if(IsSame<uint64_t&,decltype(value)>::value){
            std::cout<< "uint64_t"<<std::endl;
            in_>> str;
            std::cout<< "Str : "<<str<<std::endl;
            if(isNumber(str)){
                std::cout << "True"<<std::endl;
                str_stream << str << Separator;
                str_stream >> temp;
                std::cout<< temp <<std::endl;
                value = temp;
                return Error :: NoError;
            } else{
                return Error::CorruptedArchive;
            }
        } else{
            return Error::IncorrectType;
        }
    }

    template <class T, class... ArgsT>
    Error process(T &value, ArgsT&... args){
        std::string str;
        std::stringstream str_stream;
        uint64_t temp ;
        if(IsSame<bool&,decltype(value)>::value){
            std::cout<< "Bool"<<std::endl;
            in_>> str;
            if(str == "true"){
                value =  true;
                return process(args...);
            } else if(str == "false"){
                value = false;
                return process(args...);
            } else{
                return Error::CorruptedArchive;
            }
        } else if(IsSame<uint64_t&,decltype(value)>::value){
            std::cout<< "uint64_t"<<std::endl;
            in_>> str;
            std::cout<< "Str : "<<str<<std::endl;
            if(isNumber(str)){
                std::cout << "True"<<std::endl;
                str_stream << str << Separator;
                str_stream >> temp;
                std::cout<< temp<<std::endl;
                value = temp;
                return process(args...);
            } else{
                return Error::CorruptedArchive;
            }
        } else{
            return Error::IncorrectType;
        }
        return process(args...);
    }
    // process использует variadic templates
};
 int main(int argc, char const *argv[]) {
     int a  = 5;
     Data x { 1, true, 2};
     Data y {1, false, 4};
     Error res;

     std::stringstream save_stream;


     Serializer serializer(save_stream);
     Deserializer deserializer(save_stream);
     res = serializer.save(x);
     switch (res) {
         case Error::NoError:{
             std::cout<< "NoError"<<std::endl;
             break;
         }
         case Error::IncorrectType:{
             std::cout<< "IncorrectType"<<std::endl;
             break;
         }
         case Error::CorruptedArchive:{
             std::cout<< "CorruptedArchive"<<std::endl;
             break;
         }
     }
     std::string result;
     y.c = 5;
     res = deserializer.load(y);
     switch (res) {
         case Error::NoError:{
             std::cout<< "NoError"<<std::endl;
             break;
         }
         case Error::IncorrectType:{
             std::cout<< "IncorrectType"<<std::endl;
             break;
         }
         case Error::CorruptedArchive:{
             std::cout<< "CorruptedArchive"<<std::endl;
             break;
         }
     }
     std::cout<< "y.c = "<< y.c<<std::endl;
     res = serializer.save(y);
     while(save_stream >> result){
        std::cout<< result +' ';
     }

     return 0;
 }