source: dev/trunk/jenga/include/common/BoostSerializationSupport.h@ 213

#pragma once

#include <vector>
#include <string>
#include <fstream>
#include <sstream>

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/level.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/is_abstract.hpp>

#include <windows.h>

namespace Jenga{
namespace Common{

using namespace std;

template<class T_xml_schema> class BoostSerializationSupport{
    virtual const char *RootTagName() const = 0;

    void echo( const char *msg ) const
    {
        MessageBox( NULL, msg, "XMLシリアライズの例外", MB_OK );
    }

public:
    bool ReadXml( istream& ifs, bool isShowExceptionMessage = true )
    {
        bool isSuccessful = false;

        try{
            boost::archive::xml_iarchive ia(ifs);

            // ファイルから読込
            ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            isSuccessful = true;
        }
        catch( boost::archive::archive_exception e )
        {
            if( isShowExceptionMessage )
            {
                echo( e.what() );
            }
        }
        catch(...){
            if( isShowExceptionMessage )
            {
                echo( "archive_exception以外の不明な例外" );
            }
        }

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }

    bool WriteXml( ostream& ofs, bool isShowExceptionMessage = true ) const
    {
        bool isSuccessful = false;

        try{
            boost::archive::xml_oarchive oa(ofs);

            // ファイルに書き出し
            oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            isSuccessful = true;
        }
        catch( boost::archive::archive_exception e )
        {
            if( isShowExceptionMessage )
            {
                echo( e.what() );
            }
        }
        catch(...){
            if( isShowExceptionMessage )
            {
                echo( "archive_exception以外の不明な例外" );
            }
        }

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }

    bool ReadXml( const string &xmlFilePath, bool isShowExceptionMessage = true )
    {
        // 入力アーカイブの作成
        std::ifstream ifs( xmlFilePath.c_str() );
        
        bool result = ReadXml(ifs,isShowExceptionMessage);

        // 入力を閉じる
        ifs.close();

        return result;
    }
    bool WriteXml( const string &xmlFilePath, bool isShowExceptionMessage = true ) const
    {
        // 出力アーカイブの作成
        std::ofstream ofs( xmlFilePath.c_str() );

        bool result = WriteXml(ofs,isShowExceptionMessage);

        // 出力を閉じる
        ofs.close();

        return result;
    }

    bool ReadBinaly( const string &xmlFilePath, bool isShowExceptionMessage = true )
    {
        // 入力アーカイブの作成
        std::ifstream ifs( xmlFilePath.c_str() );

        bool isSuccessful = false;
        try{
            boost::archive::binary_iarchive ia(ifs);

            // ファイルから読込
            ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            isSuccessful = true;
        }
        catch( boost::archive::archive_exception e )
        {
            if( isShowExceptionMessage )
            {
                echo( e.what() );
            }
        }
        catch(...){
            if( isShowExceptionMessage )
            {
                echo( "archive_exception以外の不明な例外" );
            }
        }

        // 入力を閉じる
        ifs.close();

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }
    bool WriteBinaly( const string &xmlFilePath, bool isShowExceptionMessage = true ) const
    {
        // 出力アーカイブの作成
        std::ofstream ofs( xmlFilePath.c_str() );

        bool isSuccessful = false;
        try{
            boost::archive::binary_oarchive oa(ofs);

            // ファイルに書き出し
            oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            isSuccessful = true;
        }
        catch( boost::archive::archive_exception e )
        {
            if( isShowExceptionMessage )
            {
                echo( e.what() );
            }
        }
        catch(...){
            if( isShowExceptionMessage )
            {
                echo( "archive_exception以外の不明な例外" );
            }
        }

        // 出力を閉じる
        ofs.close();

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }

    bool ReadXmlFromString( const string &xmlBuffer )
    {
        bool isSuccessful = false;

        // 入力アーカイブの作成
        std::istringstream iss( xmlBuffer );

        try{
            boost::archive::xml_iarchive ia(iss);

            // 文字列ストリームから読込
            ia >> boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            isSuccessful = true;
        }
        catch(...){
            // 失敗
        }

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }
    bool ToXmlWString( wstring &xmlBuffer ) const
    {
        bool isSuccessful = false;

        // 入力アーカイブの作成
        std::ostringstream oss;

        try{
            boost::archive::xml_oarchive oa(oss);

            // 文字列ストリームへ書き出し
            oa << boost::serialization::make_nvp( RootTagName(), *(T_xml_schema *)this );

            xmlBuffer = oss.str();

            isSuccessful = true;
        }
        catch(...){
            // 失敗
        }

        if( !isSuccessful )
        {
            return false;
        }

        return true;
    }
};


}}