CArray.hpp

[詳解]

//=============================================================================
/// @file
/// 配列クラス実装ヘッダファイル
///
/// 配列クラス実装ヘッダファイルです。
///
/// $Id: CArray.hpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma once
#pragma managed( push, off )

//=============================================================================
// インクルードファイル
#include <CArray.h>
#include <algorithm>

//=============================================================================
// 共通ライブラリ名前空間
namespace LibCommon {
    //=========================================================================
    // 配列クラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    template< typename Type >
    CArray< Type >::CArray() noexcept
        // メンバ変数初期化
        : m_pBuffer( nullptr )
        , m_nSize( 0 )
        , m_nCount( 0 )
    {}

    //-------------------------------------------------------------------------
    // コンストラクタ
    template< typename Type >
    CArray< Type >::CArray( Type const& rElement ) noexcept
        // 移譲コンストラクタ
        : CArray()
    {
        // コピーする
        Copy( rElement );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    template< typename Type >
    CArray< Type >::CArray( Type const* pBuffer, int nCount ) noexcept
        // 移譲コンストラクタ
        : CArray()
    {
        // コピーする
        Copy( pBuffer, nCount );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    template< typename Type >
    CArray< Type >::CArray( std::initializer_list< Type const > const& rcInitializer ) noexcept
        // 移譲コンストラクタ
        : CArray()
    {
        // コピーする
        Copy( rcInitializer );
    }

    //-------------------------------------------------------------------------
    // コピーコンストラクタ
    template< typename Type >
    CArray< Type >::CArray( CArray const& rcInstance ) noexcept
        // 移譲コンストラクタ
        : CArray()
    {
        // コピーする
        Copy( rcInstance );
    }

    //-------------------------------------------------------------------------
    // ムーブコンストラクタ
    template< typename Type >
    CArray< Type >::CArray( CArray< Type >&& rcInstance ) noexcept
        // 移譲コンストラクタ
        : CArray()
    {
        // ムーブする
        Move( std::move( rcInstance ) );
    }

    //-------------------------------------------------------------------------
    // デストラクタ
    template< typename Type >
    CArray< Type >::~CArray() noexcept {
        // クリアする
        Clear();
    }

    //=========================================================================
    // 公開演算子オーバーロード関数
    //-------------------------------------------------------------------------
    // コピー代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator=( CArray const& rcInstance ) noexcept {
        // コピーする
        Copy( rcInstance );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // ムーブ代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator=( CArray&& rcInstance ) noexcept {
        // ムーブする
        Move( std::move( rcInstance ) );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator=( Type const& rElement ) noexcept {
        // コピーする
        Copy( rElement );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator=( std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // コピーする
        Copy( rcInitializer );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator+=( CArray const& rcInstance ) noexcept {
        // 追加する
        Append( rcInstance );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator+=( Type const& rElement ) noexcept {
        // 追加する
        Append( rElement );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    template< typename Type >
    CArray< Type >& CArray< Type >::operator+=( std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // 追加する
        Append( rcInitializer );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 配列添字演算子オーバーロード関数
    template< typename Type >
    Type& CArray< Type >::operator[]( int nIndex ) noexcept {
        // 静的配列要素
        static Type element;

        // 処理ブロック
        Type* result = &element;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = &m_pBuffer[ nIndex ];
        } while ( false );

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

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // クリア関数
    template< typename Type >
    void CArray< Type >::Clear() noexcept {
        // バッファを削除する
        delete[] m_pBuffer;

        // メンバ変数を初期化する
        m_pBuffer = nullptr;
        m_nSize   = 0;
        m_nCount  = 0;
    }

    //-------------------------------------------------------------------------
    // バッファ作成関数
    template< typename Type >
    bool CArray< Type >::CreateBuffer( int nSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファサイズを調べる
            if ( m_nCount > nSize ) {
                // 失敗！
                break;
            }
            // バッファサイズを調べる
            else if ( m_nSize != nSize ) {
                // 新規バッファを作成する
                Type* pNewBuffer = new Type[ nSize ];
                if ( nullptr == pNewBuffer ) {
                    // 失敗！
                    break;
                }
                // 巡回する
                else for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                    // 配列要素をコピーする
                    pNewBuffer[ nIndex ] = m_pBuffer[ nIndex ];
                }

                // 巡回する
                for ( int nIndex = m_nCount; nSize > nIndex; ++nIndex ) {
                    // 配列要素をクリアする
                    ::memset( &pNewBuffer[ nIndex ], 0, sizeof( Type ) );
                }

                // 既存バッファを削除する
                delete[] m_pBuffer;

                // バッファポインタとバッファサイズを設定する
                m_pBuffer = pNewBuffer;
                m_nSize   = nSize;
            }

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

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

    //-------------------------------------------------------------------------
    // バッファサイズ更新関数
    template< typename Type >
    bool CArray< Type >::UpdateBuffer( int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 配列要素数とバッファサイズを比較する
            if ( m_nSize < nCount ) {
                // 終端配列要素分を追加したセグメント単位のバッファサイズを取得する
                int nSize = ( ( nCount + GetSegmentSize() ) / GetSegmentSize() * GetSegmentSize() );

                // バッファを作成する
                if ( !CreateBuffer( nSize ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // バッファサイズコンパクト化関数
    template< typename Type >
    bool CArray< Type >::CompactBuffer() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファサイズとバッファカウントを比較する
            if ( m_nSize > m_nCount ) {
                // バッファを作成する
                if ( !CreateBuffer( m_nCount ) ) {
                    // 失敗！
                    break;
                }
            }

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

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

    //-------------------------------------------------------------------------
    // コピー関数
    template< typename Type >
    bool CArray< Type >::Copy( CArray const& rcInstance ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rcInstance );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    template< typename Type >
    bool CArray< Type >::Copy( Type const& rElement ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rElement );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    template< typename Type >
    bool CArray< Type >::Copy( Type const* pBuffer, int nCount ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, pBuffer, nCount );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    template< typename Type >
    bool CArray< Type >::Copy( std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rcInitializer );
    }

    //-------------------------------------------------------------------------
    // ムーブ関数
    template< typename Type >
    bool CArray< Type >::Move( CArray< Type >&& rcInstance ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クリアする
            Clear();

            // メンバ変数をコピーする
            m_pBuffer      = rcInstance.m_pBuffer;
            m_nSize   = rcInstance.m_nSize;
            m_nCount = rcInstance.m_nCount;

            // ムーブ元インスタンスのメンバ変数を初期化する
            rcInstance.m_pBuffer = nullptr;
            rcInstance.m_nSize   = 0;
            rcInstance.m_nCount  = 0;

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

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

    //-------------------------------------------------------------------------
    // 追加関数
    template< typename Type >
    bool CArray< Type >::Append( CArray const& rcInstance ) noexcept {
        // 挿入する
        return Insert( m_nCount, rcInstance );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    template< typename Type >
    bool CArray< Type >::Append( Type const& rElement ) noexcept {
        // 挿入する
        return Insert( m_nCount, rElement );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    template< typename Type >
    bool CArray< Type >::Append( Type const* pBuffer, int nCount ) noexcept {
        // 挿入する
        return Insert( m_nCount, pBuffer, nCount );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    template< typename Type >
    bool CArray< Type >::Append( std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // 挿入する
        return Insert( m_nCount, rcInitializer );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    template< typename Type >
    bool CArray< Type >::Insert( int nIndex, CArray const& rcInstance ) noexcept {
        // 挿入する
        return Insert( nIndex, rcInstance.m_pBuffer, rcInstance.m_nCount );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    template< typename Type >
    bool CArray< Type >::Insert( int nIndex, Type const& rElement ) noexcept {
        // 挿入する
        return Insert( nIndex, &rElement, 1 );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    template< typename Type >
    bool CArray< Type >::Insert( int nIndex, Type const* pBuffer, int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファポインタを調べる
            if ( nullptr == pBuffer ) {
                // 失敗！
                break;
            }
            // インデックスを調べる
            else if ( ( 0 > nIndex ) || ( m_nCount < nIndex ) ) {
                // 失敗！
                break;
            }
            // 配列要素数を調べる
            else if ( 0 > nCount ) {
                // 失敗！
                break;
            }
            // バッファサイズを更新する
            else if ( !UpdateBuffer( m_nCount + nCount ) ) {
                // 失敗！
                break;
            }

            // 移動配列要素数を取得する
            int nMove = ( m_nCount - nIndex );
            if ( 0 < nMove ) {
                // 巡回する
                Type*       pDst = &m_pBuffer[ m_nCount + nCount - 1 ];
                Type const* pSrc = &m_pBuffer[ m_nCount - 1 ];
                for ( ; 0 < nMove; --nMove ) {
                    // 配列要素をコピーする
                    *pDst-- = *pSrc--;
                }
            }

            // 配列要素数を更新する
            m_nCount += nCount;

            // 巡回する
            Type const* pSrc = pBuffer;
            Type*       pDst = &m_pBuffer[ nIndex ];
            for ( ; 0 < nCount; --nCount ) {
                // 配列要素をコピーする
                *pDst++ = *pSrc++;
            }

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

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

    //-------------------------------------------------------------------------
    // 挿入関数
    template< typename Type >
    bool CArray< Type >::Insert( int nIndex, std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( auto pcIter = rcInitializer.begin();; ++pcIter ) {
                // イテレータを調べる
                if ( rcInitializer.end() == pcIter ) {
                    // 成功！
                    result = true;
                    break;
                }

                // 挿入する
                if ( !Insert( nIndex++, *pcIter ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 削除関数
    template< typename Type >
    bool CArray< Type >::Remove() noexcept {
        // 削除する
        return Remove( m_nCount - 1 );
    }

    //-------------------------------------------------------------------------
    // 削除関数
    template< typename Type >
    bool CArray< Type >::Remove( int nIndex ) noexcept {
        // 削除する
        return Remove( nIndex, 1 );
    }

    //-------------------------------------------------------------------------
    // 削除関数
    template< typename Type >
    bool CArray< Type >::Remove( int nIndex, int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }
            // 配列要素数を調べる
            else if ( ( m_nCount - nIndex ) < nCount ) {
                // 失敗！
                break;
            }

            // 移動配列要素数を取得する
            int nMove = ( m_nCount - nIndex - nCount );
            if ( 0 < nMove ) {
                // 巡回する
                for ( ; 0 < nMove; --nMove, ++nIndex ) {
                    // 配列要素をコピーする
                    m_pBuffer[ nIndex ] = m_pBuffer[ nIndex + nCount ];
                }
            }

            // 巡回する
            for ( ; m_nCount > nIndex; ++nIndex ) {
                // 配列要素をクリアする
                ::memset( &m_pBuffer[ nIndex ], 0, sizeof( Type ) );
            }

            // 配列要素数を更新する
            m_nCount -= nCount;

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

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

    //-------------------------------------------------------------------------
    // 取得関数
    template< typename Type >
    bool CArray< Type >::Get( int nIndex, Type& rElement ) const noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 配列要素を取得する
            rElement = m_pBuffer[ nIndex ];

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

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

    //-------------------------------------------------------------------------
    // 設定関数
    template< typename Type >
    bool CArray< Type >::Set( int nIndex, Type const& rElement ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 配列要素を設定する
            m_pBuffer[ nIndex ] = rElement;

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

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

    //-------------------------------------------------------------------------
    // 検索関数
    template< typename Type >
    int CArray< Type >::Find( Type const& rElement ) const noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // 配列要素を調べる
                if ( Compare( rElement, m_pBuffer[ nIndex ] ) ) {
                    // 成功！
                    result = nIndex;
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // 比較関数
    template< typename Type >
    bool CArray< Type >::Compare( Type const& rElement1, Type const& rElement2 ) const noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( int nIndex = 0;; ++nIndex ) {
                // インデックスを調べる
                if ( sizeof( Type ) <= nIndex ) {
                    // 成功！
                    result = true;
                    break;
                }
                // バイトデータを調べる
                else if ( reinterpret_cast< char const* >( &rElement1 )[ nIndex ] != reinterpret_cast< char const* >( &rElement2 )[ nIndex ] ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

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

    //-------------------------------------------------------------------------
    // プッシュ関数
    template< typename Type >
    bool CArray< Type >::Push( Type const& rElement ) noexcept {
        // 追加する
        return Append( rElement );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    template< typename Type >
    bool CArray< Type >::Push( Type const* pBuffer, int nCount ) noexcept {
        // 追加する
        return Append( pBuffer, nCount );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    template< typename Type >
    bool CArray< Type >::Push( std::initializer_list< Type const > const& rcInitializer ) noexcept {
        // 追加する
        return Append( rcInitializer );
    }

    //-------------------------------------------------------------------------
    // ポップ関数
    template< typename Type >
    bool CArray< Type >::Pop( Type& rElement ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 配列要素数を取得する
            if ( !Get( ( m_nCount - 1 ), rElement ) ) {
                // 失敗！
                break;
            }
            // 削除する
            else if ( !Remove() ) {
                // 失敗！
                break;
            }

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

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

    //-------------------------------------------------------------------------
    // ポップフロント関数
    template< typename Type >
    bool CArray< Type >::PopFront( Type& rElement ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 配列要素数を取得する
            if ( !Get( 0, rElement ) ) {
                // 失敗！
                break;
            }
            // 削除する
            else if ( !Remove( 0 ) ) {
                // 失敗！
                break;
            }

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

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

#pragma managed( pop )