Changeset 803 in dev for branches/egtra/ab5.0


Ignore:
Timestamp:
Feb 11, 2011, 10:05:14 PM (14 years ago)
Author:
イグトランス (egtra)
Message:

Hashmapの実装にunorderedを用いるよう変更

Location:
branches/egtra/ab5.0
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/Debug.cpp

    r798 r803  
    276276UserProc *GetSubFromObp(ULONG_PTR pos)
    277277{
    278     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    279     while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     278    foreach (auto pUserProc, compiler.GetObjectModule().meta.GetUserProcs())
    280279    {
    281         UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    282 
    283280        if(rva_to_real(pUserProc->GetBeginOpAddress()) <= pos  &&
    284281            pos < rva_to_real(pUserProc->GetEndOpAddress()))

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/Diagnose.cpp

    r750 r803  
    3434        int codeSizeOfGlobalProc = 0;
    3535        int codeSizeOfClassMethod = 0;
    36         compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    37         while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     36        foreach (auto pUserProc, compiler.GetObjectModule().meta.GetUserProcs())
    3837        {
    39             UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    4038            if( pUserProc->IsCompiled() ){
    4139                if( pUserProc->HasParentClass() ){
    … …  
    6058        int codeSizeOfEnum = 0;
    6159
    62         // イテレータをリセット
    63         compiler.GetObjectModule().meta.GetClasses().Iterator_Reset();
    64 
    65         while( compiler.GetObjectModule().meta.GetClasses().Iterator_HasNext() ){
     60        foreach (auto pClass, compiler.GetObjectModule().meta.GetClasses())
     61        {
    6662            int codeSizeOfClass = 0;
    6763
    68             CClass &objClass = *compiler.GetObjectModule().meta.GetClasses().Iterator_GetNext();
     64            CClass &objClass = *pClass;
    6965
    7066            if( !objClass.IsEnum() ){
    … …  
    9995        ///////////////////////////////////////////////////////////////////
    10096
    101         // イテレータをリセット
    102         compiler.GetObjectModule().meta.GetClasses().Iterator_Reset();
    103 
    104         while( compiler.GetObjectModule().meta.GetClasses().Iterator_HasNext() ){
     97        foreach (auto pClass, compiler.GetObjectModule().meta.GetClasses())
     98        {
    10599            int codeSizeOfClass = 0;
    106100
    107             CClass &objClass = *compiler.GetObjectModule().meta.GetClasses().Iterator_GetNext();
     101            CClass &objClass = *pClass;
    108102
    109103            // 動的メソッド

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/Subroutine.cpp

    r751 r803  
    319319
    320320bool IsNeedProcCompile(){
    321     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    322     while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
    323     {
    324         UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
     321    foreach (auto pUserProc, compiler.GetObjectModule().meta.GetUserProcs())
     322    {
    325323        if( pUserProc->IsUsing() && pUserProc->IsCompiled() == false ){
    326324            return true;
    … …  
    385383
    386384repeat:
    387     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    388     while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
    389     {
    390         UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
     385    foreach (auto pUserProc, compiler.GetObjectModule().meta.GetUserProcs())
     386    {
    391387        CompileBufferInProcedure( *pUserProc );
    392388    }
    … …  
    410406            //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合
    411407
    412             compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    413             while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     408            foreach(auto pUserProc, compiler.GetObjectModule().meta.GetUserProcs())
    414409            {
    415                 UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    416410                CompileBufferInProcedure( *pUserProc );
    417411            }

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/VarList.cpp

    r763 r803  
    11#include "stdafx.h"
    22
     3#include <boost/range/algorithm.hpp>
    34#include <Compiler.h>
    45
    … …  
    411412    if(pobj_dti->lplpSpBase[i2]==0) return;
    412413
    413     UserProc *pUserProc = NULL;
    414     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    415     while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     414    auto const& t = compiler.GetObjectModule().meta.GetUserProcs();
     415    auto it = boost::find_if<boost::return_found>(t, [&](UserProc *pUserProc) -> bool {
     416        return rva_to_real(pUserProc->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2] &&
     417            pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->GetEndOpAddress());
     418    });
     419    if (it == boost::end(t))
    416420    {
    417         pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    418         if(rva_to_real(pUserProc->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2]  &&
    419             pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->GetEndOpAddress())){
    420             break;
    421         }
    422     }
    423     if(!pUserProc) return;
     421        return;
     422    }
     423    UserProc *pUserProc = *it;
    424424
    425425    foreach( Variable *pVar, pUserProc->GetLocalVars() ){
    … …  
    696696    //プロシージャ コンボボックス
    697697    SendMessage(hProcCombo,CB_RESETCONTENT,0,0);
    698     for(i2=pobj_dti->iProcLevel;i2>=0;i2--){
    699 
     698    for(i2=pobj_dti->iProcLevel;i2>=0;i2--)
     699    {
     700        auto const& t = compiler.GetObjectModule().meta.GetUserProcs();
     701        auto it = boost::find_if<boost::return_found>(t, [&](UserProc* p) {
     702            return rva_to_real(p->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2] &&
     703                pobj_dti->lplpObp[i2] < rva_to_real(p->GetEndOpAddress());
     704        });
    700705        UserProc *pUserProc = NULL;
    701         compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    702         while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     706        if (it != boost::end(t))
    703707        {
    704             pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    705 
    706             if(rva_to_real(pUserProc->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2]  &&
    707                 pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->GetEndOpAddress()))
    708             {
    709                 lstrcpy(temporary,pUserProc->GetName().c_str());
    710                 break;
    711             }
     708            pUserProc = *it;
     709            lstrcpy(temporary, pUserProc->GetName().c_str());
    712710        }
    713711        if(!pUserProc){
    … …  
    811809    i2=pobj_dti->iProcLevel-i2;
    812810
    813     if(pobj_dti->lplpSpBase[i2]){
    814 
    815         UserProc *pUserProc = NULL;
    816         compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    817         while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     811    if(pobj_dti->lplpSpBase[i2])
     812    {
     813        auto const& t = compiler.GetObjectModule().meta.GetUserProcs();
     814        auto it = boost::find_if<boost::return_found>(t, [&](UserProc* p) {
     815            return rva_to_real(p->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2] &&
     816                pobj_dti->lplpObp[i2] < rva_to_real(p->GetEndOpAddress());
     817        });
     818
     819        if (it != boost::end(t))
    818820        {
    819             pUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    820 
    821             if(rva_to_real(pUserProc->GetBeginOpAddress()) <= pobj_dti->lplpObp[i2]  &&
    822                 pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->GetEndOpAddress())){
    823                 break;
    824             }
    825         }
    826 
    827         if(pUserProc){
    828             compiler.StartProcedureCompile( pUserProc );
     821            compiler.StartProcedureCompile(*it);
    829822        }
    830823    }

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/hash.cpp

    r598 r803  
    3333
    3434    // ハッシュ値を取得
    35     DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().GetHashArrayElement( simpleName );
    36     while(pDllProc){
     35    foreach (auto pDllProc, compiler.GetObjectModule().meta.GetDllProcs().GetHashArrayElement(simpleName))
     36    {
    3737        if( pDllProc->IsEqualSymbol( LexicalAnalyzer::FullNameToSymbol( fullName ) ) ){
    3838            return pDllProc;
    3939        }
    40 
    41         pDllProc=pDllProc->GetChainNext();
    4240    }
    4341

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

    r750 r803  
    13481348    delete pobj_LoopRefCheck;
    13491349    pobj_LoopRefCheck=0;
    1350 
    1351     // イテレータの準備
    1352     classes.Iterator_Init();
    13531350}
    13541351
    … …  
    14121409
    14131410    compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
    1414     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
    14151411
    14161412    LexicalAnalyzer::AddMethod(

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Const.cpp

    r637 r803  
    206206        }
    207207    }
    208 
    209     // イテレータを初期化
    210     compiler.GetObjectModule().meta.GetGlobalConsts().Iterator_Init();
    211     compiler.GetObjectModule().meta.GetGlobalConstMacros().Iterator_Init();
    212208}
    213209

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Delegate.cpp

    r750 r803  
    127127    Jenga::Common::SourceTemplate sourceTemplate( ActiveBasic::Common::Environment::GetAbdevSystemDirPath() + "\\templates\\delegate_class.tab" );
    128128
    129     delegates.Iterator_Reset();
    130     while( delegates.Iterator_HasNext() )
    131     {
    132         const Delegate &dg = *delegates.Iterator_GetNext();
     129    foreach (auto pDelegate, delegates)
     130    {
     131        const Delegate &dg = *pDelegate;
    133132
    134133        if( dg.IsExternal() )
    … …  
    263262void LexicalAnalyzer::RefleshDelegatesParameterAndReturnType( Delegates &delegates )
    264263{
    265     delegates.Iterator_Reset();
    266     while( delegates.Iterator_HasNext() )
    267     {
    268         Delegate &dg = *delegates.Iterator_GetNext();
    269         RefleshDelegateParameterAndReturnType( dg );
    270     }
    271 }
     264    foreach (auto *pDelegate, delegates)
     265    {
     266        RefleshDelegateParameterAndReturnType(*pDelegate);
     267    }
     268}

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/Linker.cpp

    r750 r803  
    257257    nativeCode.PutEx( masterObjectModule.globalNativeCode );
    258258
    259     masterObjectModule.meta.GetUserProcs().Iterator_Reset();
    260     while( masterObjectModule.meta.GetUserProcs().Iterator_HasNext() )
    261     {
    262         const UserProc *pUserProc = masterObjectModule.meta.GetUserProcs().Iterator_GetNext();
    263 
     259    foreach (auto pUserProc, masterObjectModule.meta.GetUserProcs())
     260    {
    264261        if( pUserProc->GetNativeCode().GetSize() > 0 )
    265262        {

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/ProcedureGenerator.cpp

    r750 r803  
    1818    int back_cp=cp;
    1919
    20     classes.Iterator_Reset();
    21     while(classes.Iterator_HasNext()){
    22         CClass &objClass = *classes.Iterator_GetNext();
     20    foreach(auto pClass, classes)
     21    {
     22        CClass &objClass = *pClass;
    2323        if( objClass.IsExternal() )
    2424        {
    … …  
    8383    ////////////////////////////////////////////////////////////////////
    8484
    85     // イテレータをリセット
    86     classes.Iterator_Reset();
    87 
    88     while( classes.Iterator_HasNext() ){
    89         const CClass &objClass = *classes.Iterator_GetNext();
     85    foreach (auto pClass, classes)
     86    {
     87        const CClass &objClass = *pClass;
    9088
    9189        if( !objClass.IsUsing() ){
    … …  
    152150    ChangeOpcode( temporary );
    153151
    154     // イテレータをリセット
    155     classes.Iterator_Reset();
    156 
    157     while( classes.Iterator_HasNext() ){
    158         const CClass &objClass = *classes.Iterator_GetNext();
     152    foreach (auto pClass, classes)
     153    {
     154        const CClass &objClass = *pClass;
    159155
    160156        if( !objClass.IsUsing() ){

  • branches/egtra/ab5.0/abdev/BasicCompiler_Common/src/VtblGenerator.cpp

    r750 r803  
    9393void VtblGenerator::GenerateVTablesForAllClasses( Classes &classes )
    9494{
    95     classes.Iterator_Reset();
    96     while( classes.Iterator_HasNext() )
     95    foreach (auto pClass, classes)
    9796    {
    98         CClass *pClass = classes.Iterator_GetNext();
    9997        GenerateFullVTables( *pClass );
    10098
    … …  
    177175void VtblGenerator::ActionVtblScheduleForAllClasses( Classes &classes, LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection )
    178176{
    179     classes.Iterator_Reset();
    180     while( classes.Iterator_HasNext() )
     177    foreach(auto pClass, classes)
    181178    {
    182         CClass *pClass = classes.Iterator_GetNext();
    183179        ActionVtblSchedule( *pClass, ImageBase, MemPos_CodeSection, MemPos_DataSection );
    184180

  • branches/egtra/ab5.0/abdev/ab-common-32.props

    r798 r803  
    1010    </ClCompile>
    1111    <Link>
    12       <AdditionalLibraryDirectories>..\..\jenga\lib\x86;..\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     12      <AdditionalLibraryDirectories>$(SolutionDir)..\jenga\lib\x86;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
    1313    </Link>
    1414  </ItemDefinitionGroup>

  • branches/egtra/ab5.0/abdev/ab-common-64.props

    r798 r803  
    99    </ClCompile>
    1010    <Link>
    11       <AdditionalLibraryDirectories>..\..\jenga\lib\x64;..\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     11      <AdditionalLibraryDirectories>..\..\jenga\lib\x64;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
    1212    </Link>
    1313  </ItemDefinitionGroup>

  • branches/egtra/ab5.0/abdev/ab-common.props

    r798 r803  
    77  </PropertyGroup>
    88  <PropertyGroup>
    9     <IntDir>$(SolutionDir)int\$(ProjectName)\$(Configuration)-$(Platform)\</IntDir>
     9    <IntDir>$(SolutionDir)int\$(Configuration)-$(Platform)\$(ProjectName)\</IntDir>
    1010  </PropertyGroup>
    1111  <ItemDefinitionGroup>
    … …  
    2121      <ExceptionHandling>Async</ExceptionHandling>
    2222      <PreprocessorDefinitions>WIN32;_SECURE_ATL=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     23      <AdditionalOptions>/Zm150 %(AdditionalOptions)</AdditionalOptions>
    2324    </ClCompile>
    2425    <Link>
    2526      <GenerateDebugInformation>true</GenerateDebugInformation>
     27      <AdditionalLibraryDirectories>$(SolutionDir)lib\$(PlatformShortName);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
    2628    </Link>
    2729  </ItemDefinitionGroup>

  • branches/egtra/ab5.0/abdev/ab_common/src/Lexical/Class.cpp

    r750 r803  
    777777
    778778    std::vector<const CClass *> classes;
    779     const CClass *pClass = GetHashArrayElement( symbol.GetName().c_str() );
    780     while( pClass )
    781     {
    782         if( pClass->IsEqualSymbol( symbol.GetNamespaceScopes(), symbol.GetName() ) ){
     779    foreach (auto pClass, GetHashArrayElement(symbol.GetName()))
     780    {
     781        if ( pClass->IsEqualSymbol(symbol.GetNamespaceScopes(), symbol.GetName()))
     782        {
    783783            //名前空間とクラス名が一致した
    784784            classes.push_back( pClass );
    785785        }
    786         pClass = pClass->GetChainNext();
    787786    }
    788787    if( classes.size() > 0 )
    789788    {
    790789        // 複数の名前空間の中に同一のクラス名が存在する場合があるので、アクセス可能で尚且つ階層が一番深いものをチョイスする
    791         pClass = classes.front();
     790        auto pClass = classes.front();
    792791
    793792        foreach( const CClass *pTempClass, classes )

  • branches/egtra/ab5.0/abdev/ab_common/src/Lexical/Const.cpp

    r700 r803  
    2929CConst *Consts::GetObjectPtr( const Symbol &symbol )
    3030{
    31     CConst *pConst = GetHashArrayElement( symbol.GetName().c_str() );
    32     while( pConst )
    33     {
    34         if( pConst->IsEqualSymbol( symbol ) )
    35         {
    36             break;
    37         }
    38         pConst = pConst->GetChainNext();
    39     }
    40 
    41     return pConst;
     31    auto c = GetHashArrayElement(symbol.GetName());
     32    auto it = std::find_if(c.begin(), c.end(),
     33        [&](CConst* t) {return t->IsEqualSymbol(symbol);});
     34    return it != c.end()
     35        ? *it
     36        : nullptr;
    4237}
    4338
    … …  
    131126ConstMacro *ConstMacros::Find( const Symbol &symbol )
    132127{
    133     ConstMacro *pConstMacro = GetHashArrayElement( symbol.GetName().c_str() );
    134     while( pConstMacro )
    135     {
    136         if( pConstMacro->IsEqualSymbol( symbol ) )
    137         {
    138             break;
    139         }
    140         pConstMacro = pConstMacro->GetChainNext();
    141     }
    142 
    143     return pConstMacro;
     128    auto c = GetHashArrayElement(symbol.GetName());
     129    auto it = std::find_if(c.begin(), c.end(),
     130        [&](ConstMacro* t) {return t->IsEqualSymbol(symbol);});
     131    return it != c.end()
     132        ? *it
     133        : nullptr;
    144134}

  • branches/egtra/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp

    r750 r803  
    4646
    4747    // 関数・メソッド
    48     meta.GetUserProcs().Iterator_Reset();
    49     while( meta.GetUserProcs().Iterator_HasNext() )
    50     {
    51         UserProc *pUserProc = meta.GetUserProcs().Iterator_GetNext();
     48    foreach (auto pUserProc, meta.GetUserProcs())
     49    {
    5250        if( pUserProc->IsExternal() )
    5351        {
    … …  
    6563
    6664    // DLL関数
    67     meta.GetDllProcs().Iterator_Reset();
    68     while( meta.GetDllProcs().Iterator_HasNext() )
    69     {
    70         DllProc *pDllProc = meta.GetDllProcs().Iterator_GetNext();
     65    foreach (auto pDllProc, meta.GetDllProcs())
     66    {
    7167        if( pDllProc->IsExternal() )
    7268        {
    … …  
    8177
    8278    // クラス
    83     meta.GetClasses().Iterator_Reset();
    84     while( meta.GetClasses().Iterator_HasNext() )
    85     {
    86         CClass *pClass = meta.GetClasses().Iterator_GetNext();
     79    foreach (auto pClass, meta.GetClasses())
     80    {
    8781        if( pClass->IsExternal() )
    8882        {
    … …  
    132126
    133127    // グローバル定数
    134     meta.GetGlobalConsts().Iterator_Reset();
    135     while( meta.GetGlobalConsts().Iterator_HasNext() )
    136     {
    137         CConst *pConst = meta.GetGlobalConsts().Iterator_GetNext();
     128    foreach (auto pConst, meta.GetGlobalConsts())
     129    {
    138130        if( pConst->IsExternal() )
    139131        {
    … …  
    148140
    149141    // グローバル定数マクロ
    150     meta.GetGlobalConstMacros().Iterator_Reset();
    151     while( meta.GetGlobalConstMacros().Iterator_HasNext() )
    152     {
    153         ConstMacro *pConstMacro = meta.GetGlobalConstMacros().Iterator_GetNext();
     142    foreach (auto pConstMacro, meta.GetGlobalConstMacros())
     143    {
    154144        if( pConstMacro->IsExternal() )
    155145        {
    … …  
    200190
    201191    // デリゲート
    202     meta.GetDelegates().Iterator_Reset();
    203     while( meta.GetDelegates().Iterator_HasNext() )
    204     {
    205         Delegate *pDelegate = meta.GetDelegates().Iterator_GetNext();
     192    foreach (auto pDelegate, meta.GetDelegates())
     193    {
    206194        if( pDelegate->IsExternal() )
    207195        {
    … …  
    218206const ::Delegate &Meta::ToDelegate( const CClass &_class )
    219207{
    220     const ::Delegate *dg = this->GetDelegates().GetHashArrayElement( _class.GetName().c_str() );
    221     while( dg )
    222     {
    223         if( dg->IsEqualSymbol( _class.GetNamespaceScopes(), _class.GetName() ) ){
     208    auto dg = this->GetDelegates().GetHashArrayElement(_class.GetName());
     209    foreach (auto t, dg)
     210    {
     211        if( t->IsEqualSymbol( _class.GetNamespaceScopes(), _class.GetName() ) ){
    224212            //名前空間とクラス名が一致した
    225             return *dg;
    226         }
    227         dg = dg->GetChainNext();
    228     }
    229 
    230     throw;
     213            return *t;
     214        }
     215    }
     216
     217    throw std::runtime_error("Meta::ToDelegate");
    231218}
    232219
    … …  
    256243{
    257244    // 関数・メソッド
    258     this->GetUserProcs().Iterator_Init();
    259     this->GetUserProcs().Iterator_Reset();
    260     while( this->GetUserProcs().Iterator_HasNext() )
    261     {
    262         UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
     245    foreach (auto pUserProc, this->GetUserProcs())
     246    {
    263247        pUserProc->Resolve( resolver, resolveErrors );
    264248    }
    265249
    266250    // DLL関数
    267     this->GetDllProcs().Iterator_Init();
    268     this->GetDllProcs().Iterator_Reset();
    269     while( this->GetDllProcs().Iterator_HasNext() )
    270     {
    271         DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
     251    foreach (auto pDllProc, this->GetDllProcs())
     252    {
    272253        pDllProc->Resolve( resolver, resolveErrors );
    273254    }
    274255
    275256    // クラス
    276     this->GetClasses().Iterator_Init();
    277     this->GetClasses().Iterator_Reset();
    278     while( this->GetClasses().Iterator_HasNext() )
    279     {
    280         CClass *pClass = this->GetClasses().Iterator_GetNext();
     257    foreach (auto pClass, this->GetClasses())
     258    {
    281259        pClass->Resolve( resolver, resolveErrors );
    282260    }
    … …  
    289267
    290268    // グローバル定数
    291     this->GetGlobalConsts().Iterator_Init();
    292     this->GetGlobalConsts().Iterator_Reset();
    293     while( this->GetGlobalConsts().Iterator_HasNext() )
    294     {
    295         CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
     269    foreach (auto pConst, this->GetGlobalConsts())
     270    {
    296271        pConst->Resolve( resolver, resolveErrors );
    297272    }
    298273
    299274    // グローバル定数マクロ
    300     this->GetGlobalConstMacros().Iterator_Init();
    301     this->GetGlobalConstMacros().Iterator_Reset();
    302     while( this->GetGlobalConstMacros().Iterator_HasNext() )
    303     {
    304         ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
     275    foreach (auto pConstMacro, this->GetGlobalConstMacros())
     276    {
    305277        pConstMacro->Resolve( resolver, resolveErrors );
    306278    }
    … …  
    325297
    326298    // デリゲート
    327     this->GetDelegates().Iterator_Init();
    328     this->GetDelegates().Iterator_Reset();
    329     while( this->GetDelegates().Iterator_HasNext() )
    330     {
    331         Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
     299    foreach (auto pDelegate, this->GetDelegates())
     300    {
    332301        pDelegate->Resolve( resolver, resolveErrors );
    333302    }

  • branches/egtra/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

    r750 r803  
    243243
    244244    // ハッシュ値を取得
    245     UserProc *pUserProc = GetHashArrayElement( simpleName );
    246     while(pUserProc){
     245    foreach (auto pUserProc, GetHashArrayElement( simpleName ))
     246    {
    247247        if( pUserProc->IsGlobalProcedure() ){
    248248            if( pUserProc->IsEqualSymbol( localSymbol ) ){
    … …  
    250250            }
    251251        }
    252 
    253         pUserProc=pUserProc->GetChainNext();
    254252    }
    255253}

  • branches/egtra/ab5.0/abdev/abdev/abdev.vcxproj

    r801 r803  
    114114      <DelayLoadDLLs>PSAPI.DLL;DWMAPI.DLL;%(DelayLoadDLLs)</DelayLoadDLLs>
    115115      <SubSystem>Windows</SubSystem>
    116       <TargetMachine>MachineX86</TargetMachine>
    117116      <EntryPointSymbol>Startup_OldWindowsHelper</EntryPointSymbol>
    118117    </Link>
    … …  
    152151      <AdditionalDependencies>comctl32.lib;imm32.lib;htmlhelp.lib;rpcrt4.lib;imagehlp.lib;tinyxmld_STL.lib;%(AdditionalDependencies)</AdditionalDependencies>
    153152      <SubSystem>Windows</SubSystem>
    154       <TargetMachine>MachineX64</TargetMachine>
    155153      <EntryPointSymbol>
    156154      </EntryPointSymbol>
    … …  
    194192      <OptimizeReferences>true</OptimizeReferences>
    195193      <EnableCOMDATFolding>true</EnableCOMDATFolding>
    196       <TargetMachine>MachineX86</TargetMachine>
    197194      <EntryPointSymbol>Startup_OldWindowsHelper</EntryPointSymbol>
    198195    </Link>
    … …  
    235232      <OptimizeReferences>true</OptimizeReferences>
    236233      <EnableCOMDATFolding>true</EnableCOMDATFolding>
    237       <TargetMachine>MachineX64</TargetMachine>
    238234      <EntryPointSymbol>
    239235      </EntryPointSymbol>

  • branches/egtra/ab5.0/abdev/compiler.vcxproj

    r802 r803  
    117117      <SubSystem>Console</SubSystem>
    118118      <StackReserveSize>4194304</StackReserveSize>
    119       <EntryPointSymbol>mainStartup_OldWindowsHelper</EntryPointSymbol>
     119      <EntryPointSymbol>Startup_OldWindowsHelper</EntryPointSymbol>
    120120      <DelayLoadDLLs>PSAPI.DLL</DelayLoadDLLs>
    121121    </Link>

  • branches/egtra/ab5.0/abdev/compiler_x64/MakePeHdr.cpp

    r769 r803  
    166166            compiler.GetObjectModule().meta.GetDelegates()
    167167        );
    168         compiler.GetObjectModule().meta.GetDelegates().Iterator_Init();
    169168
    170169        // デリゲートからクラスコードを生成
    … …  
    219218    );
    220219
    221     // サブルーチン（ユーザー定義、DLL関数）のイテレータの準備
    222     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
    223     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Init();
    224 
    225220
    226221    ///////////////////////////
    … …  
    527522        }
    528523    }
    529     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    530     while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
    531     {
    532         const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    533 
     524    foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs() )
     525    {
    534526        if( !pDllProc->IsUsing() ){
    535527            continue;
    … …  
    601593            //辞書順にサーチ
    602594            temporary[0]=0;
    603             compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    604             while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     595            foreach (auto pTempUserProc, compiler.GetObjectModule().meta.GetUserProcs())
    605596            {
    606                 UserProc *pTempUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    607597                if(pTempUserProc->IsExport()){
    608598                    if(temporary[0]=='\0'){
    … …  
    707697    int ImportDllNum=0;
    708698
    709     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    710     while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
    711     {
    712         const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    713 
     699    foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
     700    {
    714701        if( !pDllProc->IsUsing() ){
    715702            continue;
    … …  
    745732        pImportDescriptor[i].Name=i*0x10;   //※すぐ下で再計算
    746733
    747         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    748         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     734        foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    749735        {
    750             const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    751 
    752736            if( !pDllProc->IsUsing() ){
    753737                continue;
    … …  
    782766    pHintTable=(char *)HeapAlloc(hHeap,0,HintAllocSize);
    783767    for(i=0,i5=0;i<ImportDllNum;i++){
    784         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    785         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     768        foreach (auto pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    786769        {
    787             DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    788 
    789770            if( !pDllProc->IsUsing() ){
    790771                continue;
    … …  
    10711052            LookupSize;         //ルックアップテーブル
    10721053
    1073         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    1074         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     1054        foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    10751055        {
    1076             const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    1077 
    10781056            if( !pDllProc->IsUsing() ){
    10791057                continue;

  • branches/egtra/ab5.0/abdev/compiler_x86/MakePeHdr.cpp

    r750 r803  
    176176            compiler.GetObjectModule().meta.GetDelegates()
    177177        );
    178         compiler.GetObjectModule().meta.GetDelegates().Iterator_Init();
    179178
    180179        // デリゲートからクラスコードを生成
    … …  
    229228    );
    230229
    231     // サブルーチン（ユーザー定義、DLL関数）のイテレータの準備
    232     compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
    233     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Init();
    234 
    235 
    236230
    237231    ///////////////////////////
    … …  
    558552        }
    559553    }
    560     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    561     while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
    562     {
    563         const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    564 
     554    foreach(auto pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
     555    {
    565556        if( !pDllProc->IsUsing() ){
    566557            continue;
    … …  
    631622            //辞書順にサーチ
    632623            temporary[0]=0;
    633             compiler.GetObjectModule().meta.GetUserProcs().Iterator_Reset();
    634             while( compiler.GetObjectModule().meta.GetUserProcs().Iterator_HasNext() )
     624            foreach(auto pTempUserProc, compiler.GetObjectModule().meta.GetUserProcs())
    635625            {
    636                 UserProc *pTempUserProc = compiler.GetObjectModule().meta.GetUserProcs().Iterator_GetNext();
    637626                if(pTempUserProc->IsExport()){
    638627                    if(temporary[0]=='\0'){
    … …  
    723712    int ImportDllNum=0;
    724713
    725     compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    726     while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
    727     {
    728         const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    729 
     714    foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
     715    {
    730716        if( !pDllProc->IsUsing() ){
    731717            continue;
    … …  
    762748        pImportTable[i].Name=i3+i*0x10;
    763749
    764         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    765         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     750        foreach (auto const *pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    766751        {
    767             const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    768 
    769             if( !pDllProc->IsUsing() ){
     752            if (!pDllProc->IsUsing())
     753            {
    770754                continue;
    771755            }
    772 
    773             if( pDllProc->GetDllFileName() == ppDllNames[i] ){
     756            if (pDllProc->GetDllFileName() == ppDllNames[i])
     757            {
    774758                //ルックアップデータのサイズを追加
    775                 LookupSize+=sizeof(DWORD);
     759                LookupSize += sizeof (DWORD);
    776760            }
    777761        }
    … …  
    790774    i3+=ImportDllNum*0x10;
    791775    for(i=0,i5=0;i<ImportDllNum;i++){
    792         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    793         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     776        foreach (auto pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    794777        {
    795             DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    796 
    797778            if( !pDllProc->IsUsing() ){
    798779                continue;
    … …  
    10751056            HintSize;           //ヒント名（関数名）テーブル
    10761057
    1077         compiler.GetObjectModule().meta.GetDllProcs().Iterator_Reset();
    1078         while( compiler.GetObjectModule().meta.GetDllProcs().Iterator_HasNext() )
     1058        foreach (auto const* pDllProc, compiler.GetObjectModule().meta.GetDllProcs())
    10791059        {
    1080             const DllProc *pDllProc = compiler.GetObjectModule().meta.GetDllProcs().Iterator_GetNext();
    1081 
    10821060            if( !pDllProc->IsUsing() ){
    10831061                continue;

  • branches/egtra/ab5.0/jenga/include/common/Hashmap.h

    r639 r803  
    11#pragma once
    2 
     2#include <unordered_set>
     3#include <boost/range/algorithm.hpp>
     4#include <boost/checked_delete.hpp>
     5#include <boost/iterator/transform_iterator.hpp>
     6#include <boost/cast.hpp>
    37
    48namespace Jenga{
    59namespace Common{
    610
     11template<class T>
     12class ObjectInHashmap;
     13template<class T>
     14struct ObjectInHashmapHash;
     15template<class T>
     16struct ObjectInHashmapEqualTo;
    717
    818#define MAX_HASHMAP 65535
    9 template<class T> class Hashmap
    10 {
    11     T* hashArray[MAX_HASHMAP];
     19template<class T> class Hashmap : boost::noncopyable
     20{
     21    typedef std::unordered_set<ObjectInHashmap<T>*, ObjectInHashmapHash<T>, ObjectInHashmapEqualTo<T>> MapType;
     22    MapType map;
     23
     24    struct downcast
     25    {
     26        typedef T* result_type;
     27        T* operator ()(ObjectInHashmap<T>* p) const
     28        {
     29            return boost::polymorphic_cast<T*>(p);
     30        }
     31    };
     32    struct const_downcast
     33    {
     34        typedef T const* result_type;
     35        T const* operator ()(ObjectInHashmap<T> const* p) const
     36        {
     37            return boost::polymorphic_cast<T const*>(p);
     38        }
     39    };
    1240
    1341public:
    14     virtual int GetHash( const char *keyName ) const
    15     {
    16         int key;
    17         for(key=0;*keyName!='\0';keyName++){
    18             key=((key<<8)+ *keyName )%MAX_HASHMAP;
    19         }
    20         return key;
    21     }
    2242
    2343    Hashmap()
    24         : isIteratorReady( false )
    25     {
    26         memset( hashArray, 0, MAX_HASHMAP*sizeof(T*) );
     44    {
    2745    }
    2846    ~Hashmap()
    … …  
    3250    void Clear()
    3351    {
    34         for( int i=0; i<MAX_HASHMAP; i++ )
    35         {
    36             T* temp = hashArray[i];
    37             if( temp )
    38             {
    39                 delete temp;
    40             }
    41         }
    42         memset( hashArray, 0, MAX_HASHMAP*sizeof(T*) );
     52        boost::for_each(*this, boost::checked_deleter<T const>());
     53        map.clear();
    4354    }
    4455
    … …  
    4657    void PullOutAll()
    4758    {
    48         memset( hashArray, 0, MAX_HASHMAP*sizeof(T*) );
    49     }
    50 
    51     bool Put( T* value )
    52     {
    53         int key = GetHash( value->GetKeyName().c_str() );
    54 
    55         if(hashArray[key]){
    56             T *temp = hashArray[key];
    57             while( true ){
    58                 if( temp->IsDuplication( value ) )
    59                 {
    60                     // 重複している
    61                     return false;
    62                 }
    63 
    64                 if( temp->GetChainNext() == NULL )
    65                 {
    66                     break;
    67                 }
    68                 temp = temp->GetChainNext();
    69             }
    70             temp->SetChainNext( value );
    71         }
    72         else{
    73             hashArray[key] = value;
    74         }
    75 
    76         return true;
    77     }
    78 
    79     T* GetHashArrayElement( const char *keyName )
    80     {
    81         return hashArray[GetHash(keyName)];
    82     }
    83     const T* GetHashArrayElement( const char *keyName ) const
    84     {
    85         return hashArray[GetHash(keyName)];
    86     }
    87 
    88     bool IsExistDuplicationKeyName( const std::string &keyName ) const
    89     {
    90         int key = GetHash( keyName.c_str() );
    91 
    92         if(hashArray[key]){
    93             const T *temp = hashArray[key];
    94             while( true ){
    95                 if( temp->IsDuplication( keyName ) )
    96                 {
    97                     // 重複している
    98                     return true;
    99                 }
    100 
    101                 if( temp->GetChainNext() == NULL )
    102                 {
    103                     break;
    104                 }
    105                 temp = temp->GetChainNext();
    106             }
    107         }
    108 
    109         return false;
     59        map.clear();
     60    }
     61
     62    bool Put(T* value)
     63    {
     64        if (value == nullptr)
     65        {
     66            throw std::invalid_argument("Hashmap::Put");
     67        }
     68        return map.insert(value).second;
     69    }
     70
     71    typedef boost::transform_iterator<downcast, typename MapType::local_iterator> local_iterator;
     72    typedef boost::transform_iterator<const_downcast, typename MapType::const_local_iterator> const_local_iterator;
     73
     74    boost::iterator_range<local_iterator> GetHashArrayElement(std::string const& keyName)
     75    {
     76        ObjectInHashmapDummy<T> t(keyName);
     77        return boost::iterator_range<local_iterator>(
     78            local_iterator(map.begin(map.bucket(&t)), downcast()),
     79            local_iterator(map.end(map.bucket(&t)), downcast()));
     80    }
     81
     82    boost::iterator_range<const_local_iterator> GetHashArrayElement(std::string const& keyName) const
     83    {
     84        ObjectInHashmapDummy<T> t(keyName);
     85        return boost::iterator_range<const_local_iterator>(
     86            const_local_iterator(map.begin(map.bucket(&t)), const_downcast()),
     87            const_local_iterator(map.end(map.bucket(&t)), const_downcast()));
     88    }
     89
     90    bool IsExistDuplicationKeyName(const std::string &keyName) const
     91    {
     92        ObjectInHashmapDummy<T> t(keyName);
     93        return map.find(&t) != map.end();
    11094    }
    11195
    11296    bool IsExist( const T* value ) const
    11397    {
    114         int key = GetHash( value->GetKeyName().c_str() );
    115 
    116         if(hashArray[key]){
    117             const T *temp = hashArray[key];
    118             while( true ){
    119                 if( temp->IsDuplication( value ) )
    120                 {
    121                     // 重複している
    122                     return true;
    123                 }
    124 
    125                 if( temp->GetChainNext() == NULL )
    126                 {
    127                     break;
    128                 }
    129                 temp = temp->GetChainNext();
    130             }
    131         }
    132 
    133         return false;
    134     }
    135 
    136     const T *FindLike( const T* value ) const
    137     {
    138         int key = GetHash( value->GetKeyName().c_str() );
    139 
    140         if(hashArray[key]){
    141             const T *temp = hashArray[key];
    142             while( true ){
    143                 if( temp->IsDuplication( value ) )
    144                 {
    145                     // 重複している
    146                     return temp;
    147                 }
    148 
    149                 if( temp->GetChainNext() == NULL )
    150                 {
    151                     break;
    152                 }
    153                 temp = temp->GetChainNext();
    154             }
    155         }
    156 
    157         return NULL;
     98        return map.find(const_cast<T*>(value)) != map.end();
     99    }
     100
     101    const T *FindLike( const ObjectInHashmap<T>* value ) const
     102    {
     103        auto it = map.find(const_cast<ObjectInHashmap<T>*>(value));
     104        return it != map.end()
     105            ? boost::polymorphic_downcast<T const*>(*it)
     106            : nullptr;
    158107    }
    159108
    … …  
    162111    // イテレータ
    163112    /////////////////////////////////////////////////////////////////
    164 private:
    165     mutable std::vector<T*> iterator_Objects;
    166     mutable int iterator_CurrentNext;
    167     mutable bool isIteratorReady;
    168 public:
    169     void Iterator_Init() const
    170     {
    171         iterator_Objects.clear();
    172         iterator_CurrentNext = 0;
    173 
    174         for( int i=0; i<MAX_HASHMAP; i++ ){
    175             if( hashArray[i] ){
    176                 T* temp = hashArray[i];
    177                 while( temp )
    178                 {
    179                     iterator_Objects.push_back( temp );
    180 
    181                     temp = (T*)temp->GetChainNext();
    182                 }
    183             }
    184         }
    185 
    186         isIteratorReady = true;
    187     }
    188     void Iterator_Reset() const
    189     {
    190         if( !isIteratorReady )
    191         {
    192             Jenga::Throw( "イテレータの準備ができていない" );
    193         }
    194         iterator_CurrentNext = 0;
    195     }
    196     bool Iterator_HasNext() const
    197     {
    198         return ( iterator_CurrentNext < (int)iterator_Objects.size() );
    199     }
    200     T *Iterator_GetNext() const
    201     {
    202         return iterator_Objects[iterator_CurrentNext++];
    203     }
    204     int Iterator_GetMaxCount() const
    205     {
    206         return (int)iterator_Objects.size();
    207     }
    208 
     113    //typedef boost::transform_iterator<downcast, typename MapType::iterator> iterator;
     114    typedef boost::transform_iterator<downcast, typename MapType::const_iterator> const_iterator;
     115    typedef const_iterator iterator;
     116    typedef typename MapType::size_type size_type;
     117    typedef typename MapType::difference_type difference_type;
     118    //iterator begin()
     119    //{
     120    //  return iterator(map.begin(), downcast());
     121    //}
     122    //iterator end()
     123    //{
     124    //  return iterator(map.end(), downcast());
     125    //}
     126    const_iterator begin() const
     127    {
     128        return const_iterator(map.begin(), downcast());
     129    }
     130    const_iterator end() const
     131    {
     132        return const_iterator(map.end(), downcast());
     133    }
    209134
    210135    // XMLシリアライズ用
    … …  
    215140    {
    216141        std::vector<T *> objects;
    217         ar & BOOST_SERIALIZATION_NVP( objects );
    218 
    219         // 読み込み後の処理
     142        ar & BOOST_SERIALIZATION_NVP(objects);
    220143        Clear();
    221         BOOST_FOREACH( T *object, objects )
    222         {
    223             Put( object );
    224         }
    225         Iterator_Init();
     144        map = boost::copy_range<MapType>(objects);
    226145    }
    227146    template<class Archive> void save(Archive& ar, const unsigned int version) const
    228147    {
    229         // 保存準備
    230         std::vector<T *> objects;
    231         objects.clear();
    232         Iterator_Reset();
    233         while( Iterator_HasNext() )
    234         {
    235             objects.push_back( Iterator_GetNext() );
    236         }
    237 
    238         ar & BOOST_SERIALIZATION_NVP( objects );
    239     }
    240 };
    241 
    242 template<class T> class ObjectInHashmap
    243 {
    244     T *pNextObject;
     148        std::vector<T *> objects(begin(), end());
     149        ar & BOOST_SERIALIZATION_NVP(objects);
     150    }
     151};
     152
     153template<class T>
     154class ObjectInHashmap
     155{
    245156public:
    246157
    247158    ObjectInHashmap()
    248         : pNextObject( NULL )
    249159    {
    250160    }
    251161    ~ObjectInHashmap()
    252162    {
    253         if( pNextObject )
    254         {
    255             delete pNextObject;
    256         }
    257163    }
    258164
    … …  
    266172        return ( GetKeyName() == keyName );
    267173    }
    268 
    269     T *GetChainNext()
    270     {
    271         return pNextObject;
    272     }
    273     const T *GetChainNext() const
    274     {
    275         return pNextObject;
    276     }
    277     void SetChainNext( T *pNextObject )
    278     {
    279         this->pNextObject = pNextObject;
     174};
     175
     176template<class T>
     177struct ObjectInHashmapHash
     178{
     179    typedef std::size_t result_type;
     180    std::size_t operator ()(ObjectInHashmap<T> const* x) const
     181    {
     182        return std::hash<std::string>()(x->GetKeyName());
     183    }
     184};
     185
     186// GetHashArrayElementなどで文字列から検索するために用いる。
     187template<class T>
     188class ObjectInHashmapDummy : public ObjectInHashmap<T>, boost::noncopyable
     189{
     190public:
     191    explicit ObjectInHashmapDummy(std::string const& s) : str(s) {}
     192
     193    virtual std::string const& GetKeyName() const override
     194    {
     195        return str;
     196    }
     197
     198    virtual bool IsDuplication(T const* value) const override
     199    {
     200        return value != nullptr
     201            && value->ObjectInHashmap<T>::IsDuplication(str);
     202    }
     203
     204private:
     205    std::string const& str;
     206};
     207
     208template<class T>
     209struct ObjectInHashmapEqualTo
     210{
     211    typedef bool result_type;
     212    bool operator ()(ObjectInHashmap<T> const* lhs, ObjectInHashmap<T> const* rhs) const
     213    {
     214        assert(lhs != nullptr);
     215        assert(rhs != nullptr);
     216        if (auto pl = dynamic_cast<T const*>(rhs))
     217        {
     218            return lhs->IsDuplication(pl);
     219        }
     220        else
     221        {
     222            return rhs->IsDuplication(dynamic_cast<T const*>(lhs));
     223        }
    280224    }
    281225};
Note: See TracChangeset for help on using the changeset viewer.