source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/BoostSerializationSupport.cpp@ 828

#include <map>
#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <ios>
#include <streambuf>
#include <sstream>

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <commctrl.h>
#include <time.h>
#include <limits.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <tchar.h>

//boost libraries
#include <boost/foreach.hpp>
#include <boost/cast.hpp>

#pragma warning(push)
#pragma warning(disable: 4244 6326)
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/level.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/version.hpp>
#pragma warning(pop)

#include <jenga/include/jenga.h>

#include <abdev/ab_common/include/libs.h>

using namespace Jenga::Common;

using boost::polymorphic_downcast;

template<class T_xml_schema> void BoostSerializationSupport<T_xml_schema>::echo( const char *msg ) const
{
    MessageBox( NULL, msg, "シリアライズの例外", MB_OK );
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadXml( std::istream& ifs, bool isShowExceptionMessage )
{
    bool isSuccessful = false;

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteXml( std::ostream& ofs, bool isShowExceptionMessage ) const
{
    bool isSuccessful = false;

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

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

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

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

    bool result = WriteXml(ofs,isShowExceptionMessage);

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

    return result;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadXmlString( const std::string &xmlString )
{
    bool isSuccessful = false;

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteXmlString( std::string &xmlString ) const
{
    // 出力アーカイブの作成
    std::ostringstream oss;

    bool isSuccessful = false;
    try{
        boost::archive::xml_oarchive oa(oss);

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

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

    if( !isSuccessful )
    {
        return false;
    }

    xmlString = oss.str();

    return true;
}

template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadBinaryFile( const std::string &filePath, bool isShowExceptionMessage )
{
    // 入力アーカイブの作成
    std::ifstream ifs( filePath.c_str(), std::ios::in | std::ios::binary );

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteBinaryFile( const std::string &filePath, bool isShowExceptionMessage ) const
{
    // 出力アーカイブの作成
    std::ofstream ofs( filePath.c_str(), std::ios::out | std::ios::binary );

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}

template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadBinaryString( const std::string &binaryString )
{
    bool isSuccessful = false;

    // 入力アーカイブの作成
    std::istringstream iss( binaryString, std::ios::in | std::ios::binary );

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

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

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

    return isSuccessful;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteBinaryString( std::string &binaryString ) const
{
    // 出力アーカイブの作成
    std::ostringstream oss( "", std::ios::out | std::ios::binary );

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

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

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

    binaryString = oss.str();

    return isSuccessful;
}

/*
ビルドに時間がかかるので外しておく
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadText( const std::string &filePath, bool isShowExceptionMessage )
{
    // 入力アーカイブの作成
    std::ifstream ifs( filePath.c_str() );

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteText( const std::string &filePath, bool isShowExceptionMessage ) const
{
    // 出力アーカイブの作成
    std::ofstream ofs( filePath.c_str() );

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}

template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadTextString( const std::string &textString )
{
    bool isSuccessful = false;

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::WriteTextString( std::string &textString ) const
{
    // 出力アーカイブの作成
    std::ostringstream oss;

    bool isSuccessful = false;
    try{
        boost::archive::text_oarchive oa(oss);

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

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

    if( !isSuccessful )
    {
        return false;
    }

    textString = oss.str();

    return true;
}

template<class T_xml_schema> bool BoostSerializationSupport<T_xml_schema>::ReadXmlFromString( const std::string &textString )
{
    bool isSuccessful = false;

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

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

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

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

    if( !isSuccessful )
    {
        return false;
    }

    return true;
}
*/


#include <logger.h>
#include <Configuration.h>
#include <abdev/ab_common/include/Lexical/Source.h>

template class Jenga::Common::BoostSerializationSupport<LoggerSetting>;
template class Jenga::Common::BoostSerializationSupport<Configuration>;
template class Jenga::Common::BoostSerializationSupport<BasicSources>;