LibLogOut.cpp

[詳解]

//=============================================================================
/// @file
/// ログ出力ライブラリ実装ファイル
///
/// ログ出力ライブラリ実装ファイルです。
///
/// $Id: LibLogOut.cpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma managed( push, off )

//=============================================================================
// インクルードファイル
#include <LibLogOut.h>
#include <CSyncAuto.h>
#include <CProcess.h>
#include <CDebug.h>
#include <CConsole.h>
#include <LibUtility.h>
#include <stdio.h>

//=============================================================================
// インクルード実装ファイル
#include <LibCommon.hpp>

//=============================================================================
// ログ出力ライブラリ名前空間
namespace LibLogOut {
    //=========================================================================
    // ログ出力ライブラリクラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CLibLogOut::CLibLogOut() noexcept
        // 基底クラスコンストラクタ
        : CMapping()
        , CStreamOut()
        // メンバ変数初期化
        , m_psMappingInfo( nullptr )
        , m_cEventRequest()
        , m_cEventNotify()
        , m_cFileLog()
        , m_cThreadSub()
        , m_szExeFile()
    {
        // コンストラクタ実行通知
        NotifyConstructor();

        // 処理ブロック
        bool result = false;
        do {
            // 実行モジュールファイルパスを取得する
            GetExeFileName( m_szExeFile, MAX_PATH );

            // マッピングメモリを作成する
            if ( !Create( sizeof( SMappingInfo ), OBJECT_NAME ) ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }
            // 同期処理ブロック
            else do {
                CSyncAuto cSyncAuto( *this );

                // 共有メモリ情報構造体ポインタを取得する
                m_psMappingInfo = reinterpret_cast< SMappingInfo* >( GetView() );
                if ( nullptr == m_psMappingInfo ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }

                // プロセス情報を巡回する
                DWORD dwProcessId = ::GetCurrentProcessId();
                for ( int nIndex = 0;; ++nIndex ) {
                    // インデックスを調べる
                    if ( PROCESS_MAX <= nIndex ) {
                        // 致命的エラー！
                        NotifyFatalError();
                        break;
                    }
                    // プロセスIDを調べる
                    else if ( 0 == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                        // プロセスIDを設定する
                        m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId = dwProcessId;
                        break;
                    }
                }

                // 要求イベントを作成する
                wchar_t szBuffer[ MAX_PATH ];
                ::swprintf_s( szBuffer, EVENT_REQUEST_FORMAT, dwProcessId );
                if ( !m_cEventRequest.Create( szBuffer ) ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }
                // 通知イベントを作成する
                else if ( !m_cEventNotify.Create( EVENT_NOTIFY_NAME ) ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }
                // 新規作成か調べる
                else if ( IsCreate() ) {
                    // デバイス種別を巡回する
                    for ( int nIndex = 0; DEVICE_MAX > nIndex; ++nIndex ) {
                        // 出力許可フラグを設定する
                        m_psMappingInfo->m_bEnable[ nIndex ] = true;

                        // 出力プロセスIDを設定する
                        m_psMappingInfo->m_dwProcessId[ nIndex ] = dwProcessId;
                    }

                    // 新規ログ出力ファイルパスを取得する
                    wchar_t szPath[ MAX_PATH ];
                    if ( !GetNewLogFilePath( szPath, MAX_PATH ) ) {
                        // 致命的エラー！
                        NotifyFatalError();
                        break;
                    }

                    // パスをコピーする
                    ::wcscpy_s( m_psMappingInfo->m_szPath, szPath );

                    // ログ出力ファイルを作成する
                    if ( !m_cFileLog.Create( m_psMappingInfo->m_szPath ) ) {
                        // 致命的エラー！
                        NotifyFatalError();
                        break;
                    }
                }
                // ログ出力ファイルを追記モードでオープンする
                else if ( !m_cFileLog.OpenAppend( m_psMappingInfo->m_szPath ) ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }

                // 参照プロセスカウントをインクリメントする
                ++m_psMappingInfo->m_nReffer;

                // サブスレッドを起動する
                if ( !m_cThreadSub.Create( SubThreadProc, this ) ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }

                // 成功！
                result = true;
            } while ( false );
        } while ( false );

        // 実行結果を調べる
        if ( !result ) {
            // サブスレッドをクローズする
            m_cThreadSub.Close();

            // ファイルをクローズする
            m_cFileLog.Close();

            // 通知イベントをクローズする
            m_cEventNotify.Close();

            // 要求イベントをクローズする
            m_cEventRequest.Close();

            // マッピングをクローズする
            Close();
        }
    }

    //-------------------------------------------------------------------------
    // デストラクタ
    CLibLogOut::~CLibLogOut() noexcept {
        // デストラクタ実行通知
        NotifyDestructor();

        // 同期処理ブロック
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を更新する
            UpdateProcessInfo( true );

            // 参照プロセスカウントを調べる
            if ( 0 == m_psMappingInfo->m_nReffer ) {
                // バッファカウントを調べる
                if ( 0 < m_psMappingInfo->m_nCount ) {
                    // フラッシュする
                    Flush();
                    ConsoleNewLine();
                }

                // コンソールウィンドウハンドルを調べる
                if ( nullptr != ConsoleWindowHandle() ) {
                    // 終了演出をするかどうかしらべる
                    if ( true ) {
                        // コンソール入力バッファをクリアする
                        ConsoleClearInput();

                        // 巡回する
                        wchar_t const* pszMessage = L"ダイセンジガケ ダラナヨサ";
                        for ( ;; ++pszMessage ) {
                            // キー入力を調べる
                            if ( ConsoleKbHitDirect() ) {
                                // 終了！
                                break;
                            }
                            // 文字コードを調べる
                            else if ( L'\0' == *pszMessage ) {
                                // 巡回する
                                for ( int nIndex = 0; 100 > nIndex; ++nIndex ) {
                                    // キー入力を調べる
                                    if ( ConsoleKbHitDirect() ) {
                                        // 終了！
                                        break;
                                    }

                                    // 少し待つ
                                    ::Sleep( 10 );
                                }
                                ConsoleNewLine();
                                break;
                            }
                            // 文字コードを調べる
                            else if ( L' ' == *pszMessage ) {
                                // 巡回する
                                for ( int nIndex = 0; 50 > nIndex; ++nIndex ) {
                                    // キー入力を調べる
                                    if ( ConsoleKbHitDirect() ) {
                                        // 終了！
                                        break;
                                    }

                                    // 少し待つ
                                    ::Sleep( 10 );
                                }
                            }
                            else {
                                // 巡回する
                                for ( int nIndex = 0; 25 > nIndex; ++nIndex ) {
                                    // キー入力を調べる
                                    if ( ConsoleKbHitDirect() ) {
                                        // 終了！
                                        break;
                                    }

                                    // 少し待つ
                                    ::Sleep( 10 );
                                }

                                // １文字出力する
                                ConsoleChar( *pszMessage );
                            }
                        }
                    }
                }
            }
        } while ( false );
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // 文字列出力関数
    bool CLibLogOut::OutputString( wchar_t const* pszString ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列ポインタを調べる
            if ( nullptr == pszString ) {
                // 失敗！
                break;
            }
            // 同期処理ブロック
            else do {
                CSyncAuto cSyncAuto( *this );

                // 巡回する
                for ( ;; ++pszString ) {
                    // 文字コードを調べる
                    if ( L'\0' == *pszString ) {
                        // 成功！
                        result = true;
                        break;
                    }
                    // バッファカウントを調べる
                    else if ( BUFFER_SIZE <= m_psMappingInfo->m_nCount ) {
                        // フラッシュする
                        if ( !Flush() ) {
                            // 致命的エラー！
                            NotifyFatalError();
                            break;
                        }
                        // バッファカウントを調べる
                        else if ( BUFFER_SIZE <= m_psMappingInfo->m_nCount ) {
                            // 致命的エラー！
                            NotifyFatalError();
                            break;
                        }
                    }

                    // 文字列バッファに１文字追加する
                    m_psMappingInfo->m_szBuffer[ m_psMappingInfo->m_nCount++ ] = *pszString;
                }
            } while ( false );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 行番号更新関数
    bool CLibLogOut::UpdateLineNumber() noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // 行番号をインクリメントする
            ++m_psMappingInfo->m_nLine;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 行番号取得関数
    int CLibLogOut::GetLineNumber() noexcept {
        // 同期処理ブロック
        int result = 0;
        do {
            CSyncAuto cSyncAuto( *this );

            // 行番号を取得する
            result = m_psMappingInfo->m_nLine;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // インデントカウント取得関数
    int CLibLogOut::GetIndentCount() noexcept {
        // 同期処理ブロック
        int result = 0;
        do {
            CSyncAuto cSyncAuto( *this );

            // インデントカウントを取得する
            result = m_psMappingInfo->m_nIndent;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // インデント関数
    bool CLibLogOut::Indent() noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を更新する
            UpdateProcessInfo();

            // インデントカウントをインクリメントする
            ++m_psMappingInfo->m_nIndent;

            // 巡回する
            DWORD dwProcessId = ::GetCurrentProcessId();
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( PROCESS_MAX <= nIndex ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }
                // プロセスIDを調べる
                else if ( dwProcessId == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                    // インデントカウントをインクリメントする
                    ++m_psMappingInfo->m_sProcess[ nIndex ].m_nIndent;

                    // 成功！
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // アンインデント関数
    bool CLibLogOut::Unindent() noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を更新する
            UpdateProcessInfo();

            // インデントカウントをデクリメントする
            --m_psMappingInfo->m_nIndent;

            // 巡回する
            DWORD dwProcessId = ::GetCurrentProcessId();
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( PROCESS_MAX <= nIndex ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }
                // プロセスIDを調べる
                else if ( dwProcessId == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                    // インデントカウントをデクリメントする
                    --m_psMappingInfo->m_sProcess[ nIndex ].m_nIndent;

                    // 成功！
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 参照プロセスカウント取得関数
    int CLibLogOut::GetRefferCount() noexcept {
        // 同期処理ブロック
        int result = 0;
        do {
            CSyncAuto cSyncAuto( *this );

            // 参照プロセスカウントを取得する
            result = m_psMappingInfo->m_nReffer;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // バッファカウント取得関数
    int CLibLogOut::GetCount() noexcept {
        // 同期処理ブロック
        int result = 0;
        do {
            CSyncAuto cSyncAuto( *this );

            // バッファカウントを取得する
            result = m_psMappingInfo->m_nCount;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // フラッシュ関数
    bool CLibLogOut::Flush() noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を更新する
            UpdateProcessInfo();

            // 出力バッファを巡回する
            DWORD dwProcessId = ::GetCurrentProcessId();
            for ( int nIndex = 0, nCount = m_psMappingInfo->m_nCount;; ) {
                // 残り文字数を調べる
                if ( nCount <= nIndex ) {
                    // バッファカウントをクリアする
                    m_psMappingInfo->m_nCount = 0;

                    // 成功！
                    result = true;
                    break;
                }

                // 出力文字コードを巡回する
                m_psMappingInfo->m_nRequestPos  = nIndex;
                m_psMappingInfo->m_nRequestSize = 0;
                for ( ; nCount > nIndex; ++nIndex ) {
                    // 出力要求サイズをインクリメントする
                    ++m_psMappingInfo->m_nRequestSize;

                    // 文字コードを調べる
                    if ( L'\n' == m_psMappingInfo->m_szBuffer[ nIndex ] ) {
                        // インデックスをインクリメントする
                        ++nIndex;

                        // 終了！
                        break;
                    }
                }

                // 出力デバイスを巡回する
                for ( int nDevice = 0; DEVICE_MAX > nDevice; ++nDevice ) {
                    // 出力許可フラグを調べる
                    if ( m_psMappingInfo->m_bEnable[ nDevice ] ) {
                        // 出力デバイス種別を設定する
                        m_psMappingInfo->m_eDevice = static_cast< EOutputDevice >( nDevice );

                        // 出力プロセスIDを調べる
                        bool bResult = false;
                        if ( 0 != m_psMappingInfo->m_dwProcessId[ nDevice ] ) {
                            // 出力プロセスIDを調べる
                            if ( dwProcessId != m_psMappingInfo->m_dwProcessId[ nDevice ] ) {
                                // 要求イベントをオープンする
                                wchar_t szBuffer[ MAX_PATH ];
                                ::swprintf_s( szBuffer, EVENT_REQUEST_FORMAT, m_psMappingInfo->m_dwProcessId[ nDevice ] );
                                CEvent cRequest;
                                if ( cRequest.Open( szBuffer ) ) {
                                    // 要求イベントをセットする
                                    if ( cRequest.Set() ) {
                                        // 通知イベントを待機する
                                        if ( m_cEventNotify.Wait( NOTIFY_WAIT ) ) {
                                            // 成功！
                                            bResult = true;
                                        }
                                    }
                                }
                            }
                        }

                        // 実行結果を調べる
                        if ( !bResult ) {
                            // カレントプロセスでデバイス出力する
                            OutputDevice();
                        }
                    }
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 出力デバイスプロセス設定関数
    bool CLibLogOut::SetDeviceProcess( EOutputDevice eDevice, DWORD dwProcessId ) noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を更新する
            UpdateProcessInfo();

            // プロセス情報を巡回する
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( PROCESS_MAX <= nIndex ) {
                    // 失敗！
                    break;
                }
                // プロセスIDを調べる
                else if ( dwProcessId == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                    // 出力プロセスIDを設定する
                    m_psMappingInfo->m_dwProcessId[ static_cast< int >( eDevice ) ] = dwProcessId;

                    // 成功！
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 限定公開関数
    //-------------------------------------------------------------------------
    // プロセス情報更新関数
    bool CLibLogOut::UpdateProcessInfo( bool bCurrent ) noexcept {
        // 同期処理ブロック
        bool result = false;
        do {
            CSyncAuto cSyncAuto( *this );

            // プロセス情報を巡回する
            DWORD dwProcessId = ::GetCurrentProcessId();
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( PROCESS_MAX <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }
                // プロセスIDを調べる
                else if ( 0 == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                    // 継続！
                    continue;
                }
                // プロセスIDを調べる
                else if ( dwProcessId == m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) {
                    // カレントプロセス削除フラグを調べる
                    if ( !bCurrent ) {
                        // 継続！
                        continue;
                    }
                }
                else {
                    // プロセスをオープンする
                    CProcess cProcess;
                    if ( cProcess.Open( m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId ) ) {
                        // プロセス実行状態を調べる
                        if ( !cProcess.Wait( 0 ) ) {
                            // プロセスをクローズする
                            cProcess.Close();

                            // 継続！
                            continue;
                        }

                        // プロセスをクローズする
                        cProcess.Close();
                    }
                }

                // インデックスカウントを減算する
                m_psMappingInfo->m_nIndent -= m_psMappingInfo->m_sProcess[ nIndex ].m_nIndent;

                // 参照プロセスカウントを調べる
                if ( 0 == m_psMappingInfo->m_nReffer ) {
                    // 致命的エラー！
                    NotifyFatalError();
                    break;
                }

                // 参照プロセスカウントをデクリメントする
                wchar_t const* pszMessage = L"";
                if ( 0 == --m_psMappingInfo->m_nReffer ) {
                    // 生成消滅演算子情報更新ログを出力する
                    pszMessage = L", All Processes Termination";
                }

                // プロセス終了ログを出力する
                ExOutputLineFormat( true, false, L"Indent#%ld, By Terminated Process[%04X], Count = %ld%s."
                    , m_psMappingInfo->m_nIndent
                    , m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId
                    , m_psMappingInfo->m_sProcess[ nIndex ].m_nIndent
                    , pszMessage );

                // デバイス種別を巡回する
                for ( int nDevice = 0; DEVICE_MAX > nDevice; ++nDevice ) {
                    // プロセスIDを調べる
                    if ( m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId == m_psMappingInfo->m_dwProcessId[ nDevice ] ) {
                        // デバイス種別を巡回する
                        for ( int nDevice2 = 0;; ++nDevice2 ) {
                            // インデックスを調べる
                            if ( DEVICE_MAX <= nDevice2 ) {
                                // プロセスIDを設定する
                                m_psMappingInfo->m_dwProcessId[ nDevice ] = dwProcessId;
                                break;
                            }
                            // プロセスIDを調べる
                            else if ( ( 0 != m_psMappingInfo->m_dwProcessId[ nDevice2 ] ) && ( m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId != m_psMappingInfo->m_dwProcessId[ nDevice2 ] ) ) {
                                // プロセスIDを設定する
                                m_psMappingInfo->m_dwProcessId[ nDevice ] = m_psMappingInfo->m_dwProcessId[ nDevice2 ];
                                break;
                            }
                        }
                    }
                }

                // プロセス情報をクリアする
                m_psMappingInfo->m_sProcess[ nIndex ].m_dwProcessId = 0;
                m_psMappingInfo->m_sProcess[ nIndex ].m_nIndent    = 0;
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // デバイス出力関数
    bool CLibLogOut::OutputDevice() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列ポインタを取得する
            wchar_t* pszString = &m_psMappingInfo->m_szBuffer[ m_psMappingInfo->m_nRequestPos ];

            // 終端文字を保存する
            wchar_t ch = pszString[ m_psMappingInfo->m_nRequestSize ];

            // 終端文字を設定する
            pszString[ m_psMappingInfo->m_nRequestSize ] = L'\0';

            // 出力要求デバイス種別を調べる
            switch ( m_psMappingInfo->m_eDevice ) {
            case EOutputDevice::Debug: // デバッグ出力
                // デバッグ出力する
                DebugString( pszString );

                // 成功！
                result = true;
                break;

            case EOutputDevice::Console: // コンソール出力
                // コンソール出力する
                ConsoleString( pszString );

                // 成功！
                result = true;
                break;

            case EOutputDevice::File: // ファイル出力
                // ファイル出力する
                m_cFileLog.OutputString( pszString );

                // 成功！
                result = true;
                break;
            }

            // 終端文字を復元する
            pszString[ m_psMappingInfo->m_nRequestSize ] = ch;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // プロジェクト種別取得関数
    wchar_t const* CLibLogOut::GetProjectType() noexcept {
        // プロジェクト種別文字列を返す
        return _PROJECT_TYPE;
    }

    //-------------------------------------------------------------------------
    // インスタンスハンドル取得関数
    HINSTANCE CLibLogOut::GetInstanceHandle() noexcept {
#if defined( _WINDLL ) && !defined( _MANAGED )

        // インスタンスハンドルを返す
        return s_hInstance;

#       else

        // 実行モジュールのインスタンスハンドルを返す
        return ::GetModuleHandleW( nullptr );

#       endif
    }

    //=========================================================================
    // 静的限定公開関数
    //-------------------------------------------------------------------------
    // サブスレッド関数
    DWORD CLibLogOut::SubThreadProc( LPVOID lpParam ) noexcept {
        // 処理ブロック
        DWORD result = 0;
        do {
            // インスタンスポインタを取得する
            CLibLogOut*& rpcInstance = reinterpret_cast< CLibLogOut*& >( lpParam );
            if ( nullptr == rpcInstance ) {
                // 致命的エラー！
                NotifyFatalError();
                break;
            }
            // 巡回する
            else for ( ;; ) {
                // 要求イベントを待つ
                if ( rpcInstance->m_cEventRequest.Wait() ) {
                    // デバイスに出力する
                    rpcInstance->OutputDevice();

                    // 通知イベントをセットする
                    rpcInstance->m_cEventNotify.Set();
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 新規ログ出力ファイルパス取得関数
    bool CLibLogOut::GetNewLogFilePath( wchar_t* pszPath, int nSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 実行ファイルパスを取得する
            GetExeFilePath( pszPath, nSize );

            // ファイルパスを分解する
            wchar_t szDrive[ _MAX_DRIVE ];
            wchar_t szDir  [ _MAX_DIR ];
            wchar_t szFName[ _MAX_FNAME ];
            wchar_t szExt  [ _MAX_EXT ];
            if ( 0 != ::_wsplitpath_s( pszPath, szDrive, szDir, szFName, szExt ) ) {
                // 失敗！
                break;
            }
            // ファイル検索文字列を作成する
            else if ( 0 >= ::swprintf_s( pszPath, nSize, L"%s%s%s#??.log", szDrive, szDir, szFName ) ) {
                // 失敗！
                break;
            }

            // ファイルを検索する
            WORD             wNumber = 0;
            WIN32_FIND_DATAW sFindData;
            HANDLE           hFind = ::FindFirstFileW( pszPath, &sFindData );
            if ( INVALID_HANDLE_VALUE != hFind ) {
                // 巡回する
                long long unsigned llMax = 0;
                for ( ;; ) {
                    // ファイルパスを作成する
                    if ( 0 < ::swprintf_s( pszPath, nSize, L"%s%s%s", szDrive, szDir, sFindData.cFileName ) ) {
                        // ファイルをオープンする
                        HANDLE handle = ::CreateFileW( pszPath, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, nullptr );
                        if ( INVALID_HANDLE_VALUE != handle ) {
                            // 更新日時を取得する
                            FILETIME time;
                            if ( 0 != ::GetFileTime( handle, nullptr, nullptr, &time ) ) {
                                // 更新日時を比較する
                                long long unsigned tmp = ( static_cast< long long unsigned >( time.dwHighDateTime ) << 32 ) | static_cast< long long unsigned >( time.dwLowDateTime );
                                if ( llMax <= tmp ) {
                                    // 最大値を更新する
                                    llMax = tmp;

                                    // ログ出力ファイル番号を取得する
                                    wNumber = static_cast< WORD >( ( ::wcstol( &sFindData.cFileName[ ::wcslen( szFName ) + 1 ], nullptr, 10 ) + 1 ) % 100 );
                                }
                            }

                            // ファイルハンドルをクローズする
                            ::CloseHandle( handle );
                        }
                    }

                    // 次のファイルを検索する
                    if ( 0 == ::FindNextFileW( hFind, &sFindData ) ) {
                        // 終了！
                        break;
                    }
                }

                // ファイル検索ハンドルをクローズする
                ::FindClose( hFind );
            }

            // 新規ログ出力ファイルパスを作成する
            ::swprintf_s( pszPath, nSize, L"%s%s%s#%02u.log", szDrive, szDir, szFName, wNumber );

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的限定公開文字列定数
    wchar_t const* const CLibLogOut::OBJECT_NAME          = L"LibLogOut::CLibLogOut";
    wchar_t const* const CLibLogOut::EVENT_REQUEST_FORMAT = L"LibLogOut::CLibLogOut.EventRequest#%04X";
    wchar_t const* const CLibLogOut::EVENT_NOTIFY_NAME    = L"LibLogOut::CLibLogOut.EventNotify";

    //=========================================================================
    // 静的限定公開変数
    CLibLogOut CLibLogOut::s_cInstance;
}

#pragma managed( pop )