It's just like pok

#define SEALED(className) \
    className ## Sealer \
        { \
            private: className ## Sealer(){}; \
            friend class className; \
        }; \
        class className : virtual private className ## Sealer \

class SEALED(MyClass) {};

i = 0
size = files_to_check.length
while i < size
    break unless uptodate?(target, files_to_check[i])
    i += 1
end

# do not need build
return if i == size

# need to compile
updated_objects = 0
srcs.each do | fullPath |
    #puts fullPath
    gcc_mm = "gcc -MM #{include_flags} #{fullPath}"
    result = `#{gcc_mm}`.split
    object_file = result[0].chomp(':')
    object_file.gsub!(/\.o$/, '_g.o') if @with_debug_symbol
    need_compile = uptodate?(object_file, fullPath) ? false : true
    unless need_compile
        2.upto(result.length-1) do | result_index |
            dependent_header = result[result_index]
            #puts dependent_file
            if ( dependent_header != "\\" ) \
                and ( dependent_header.include?("wxWidgets-2.8.9") == false ) \
                and ( dependent_header.include?("/usr/") == false ) \
                and ( uptodate?(object_file, dependent_header) == false )
                puts "#{object_file} will be recompiled because #{dependent_header} was changed"
                need_compile = true
            end
            break if need_compile
        end
    end
    #compile
    if need_compile
        compiler = ( fullPath.match(/.*\.cpp$/) != nil )? 'g++' : 'gcc'
        compiler << " -g -o #{object_file}" if @with_debug_symbol
        sh "#{compiler}#{include_flags} -O3 -c #{fullPath}"
    end

    lib_flags_head << ' ' + object_file
    updated_objects += 1 unless uptodate?(target, object_file)
end

static void log( const char* _pSzContents )
{
    onPreSetMessage_();
    pLogger_->strCurrentMessage_ = _pSzContents;
    onPostSetMessage_();
}

template< typename T0, typename T1 >
static void log( const char* _pSzContents, T0 _t0, T1 _t1 )
{
    onPreSetMessage_();
    EStringUtils::formatStr(pLogger_->strCurrentMessage_, _pSzContents, _t0, _t1);
    onPostSetMessage_();
}

template< typename T0, typename T1, typename T2 >
static void log( const char* _pSzContents, T0 _t0, T1 _t1, T2 _t2 )
{
    onPreSetMessage_();
    EStringUtils::formatStr(pLogger_->strCurrentMessage_, _pSzContents, _t0, _t1, _t2);
    onPostSetMessage_();
}
...

template< typename T0 >
static void formatStr(std::string& _rString, const char* _pSzContents, T0 _t0 )
{
    formatStr(_rString, _pSzContents, _t0, FORMAT_INDEX_ERROR);
}

template< typename T0, typename T1 >
static void formatStr(std::string& _rString, const char* _pSzContents, T0 _t0, T1 _t1 )
{
    formatStr(_rString, _pSzContents, _t0, _t1, FORMAT_INDEX_ERROR);
}

...

static void formatStr(std::string& _rString, const char* _pSzContents, T0 _t0, T1 _t1, T2 _t2, T3 _t3, T4 _t4, T5 _t5, T6 _t6, T7 _t7 )
{
    assert(_rString.empty());
    std::vector< std::string > vBuffers;
    splitFormat_(_pSzContents, vBuffers);

    std::ostringstream oss;
    ...
   
}

std::vector< std::string > vecSplittedPath;

const char* pSzContents = ";;/usr;;/opt/lib;/sbin;;/etc";
const char* pSzError = 0;
const char* pSzPattern = "[^;]+";
TRex* pRex = trex_compile(pSzPattern, &pSzError);
if(pRex)
{
    const char *pSzBegin,*pSzEnd;
    while(trex_search(pRex, pSzContents, &pSzBegin, &pSzEnd) )
    {
        TRexMatch match;
        trex_getsubexp(pRex,0,&match);
        vecSplittedPath.push_back( std::string(match.begin, match.len) );

        pSzContents = pSzEnd;
    }
}
trex_free(pRex);

//////////////////////////////////////////////////////////////////////
//
// Input Processor Interface
//
//////////////////////////////////////////////////////////////////////

class InputProcessor
{
public:

    //  break type
    enum BREAK_CONDITION
    {
        BREAK_EOF = 0,
        BREAK_ENTER,
        BREAK_ZERO,

        BREAK_TOTAL
    };

    // 생성자 / 소멸자
    InputProcessor(BREAK_CONDITION _eBreak) { eBreakCondition_ = _eBreak; }
    virtual ~InputProcessor(){}

    // 인터페이스
    virtual void  process()              = 0;
    virtual int   getDataIndexCount()    = 0;
    virtual const std::vector<int>* getDigits(int _nIndex)   = 0;
    virtual const std::vector<std::string>* getChars(int _nIndex)   = 0;

    // Test를 위한 함수
    virtual void addTestInput(const char* pSzTestData) = 0;

protected:

    // break condition
    BREAK_CONDITION  eBreakCondition_;

    // data manipulator
    // 로컬 템플릿 클래스는 명시적 특화가 허용되지 않고 부분특화만 허용됨. 그에 대한 꽁수
    // cf. 비주얼스튜디오 확장으로 로컬클래스의 명시적 특화가 허용된다.
    template< typename T, typename PartialSpecialization = bool >
    struct SDataManipulator{};
    template< typename PartialSpecialization >
    struct SDataManipulator< int, PartialSpecialization >
    {
        static int convertData(char* _pSzData){ return atoi( _pSzData ); }
        static const int getZero(){return 0;}
        static const std::vector<int>* getDigits(
                std::vector< std::vector<int>* >& _refVecData,
                int _nIndex)
        {
            return _refVecData[ _nIndex ];
        }
        static const std::vector<std::string>*  getChars(
                std::vector< std::vector<int>* >& _refVecData,
                int _nIndex)
        {
            return 0;
        }
    };
    template< typename PartialSpecialization >
    struct SDataManipulator< std::string, PartialSpecialization >
    {
        static char* convertData(char* _pSzData){ return _pSzData; }
        static const char* getZero(){ return "0";}
        static const std::vector<int>* getDigits(
                std::vector< std::vector<std::string>* >& _refVecData,
                int _nIndex)
        {
            return 0;
        }
        static const std::vector<std::string>*  getChars(
                std::vector< std::vector<std::string>* >& _refVecData,
                int _nIndex)
        {
            return _refVecData[ _nIndex ];
        }
    };

    // multiline data
    template< typename T >
    struct SInputData
    {
        // data container
        std::vector< std::vector<T>* > aVecVecData;

        // get data
        void processData(BREAK_CONDITION _eBreak, const char* _pSzManualData )
        {
            char buf[512];
            bool bLoop = true;
            while( bLoop )
            {
                if( _pSzManualData == 0 )
                {
                    // 라인으로 입력받기
                    if( gets( buf ) == 0 )
                        return;
                }
                else
                {
                    strcpy(buf, _pSzManualData);
                    bLoop = false;
                }

                std::vector<T>*  pVector = new std::vector<T>;
                char* pSzEach = strtok(buf, " ");
                while (pSzEach!= 0)
                {
                    pVector->push_back(
                                SDataManipulator<T>::convertData( pSzEach )
                    );
                    pSzEach = strtok(0, " ");
                }

                // Zero Break
                if( _eBreak == BREAK_ZERO && pVector->size() == 2 )
                {
                    if( (*pVector)[0] == SDataManipulator<T>::getZero() &&
                        (*pVector)[1] == SDataManipulator<T>::getZero() )
                    {
                        delete pVector;
                        return;
                    }
                }

                aVecVecData.push_back( pVector );

                // Enter Break
                if( _eBreak == BREAK_ENTER )
                    return;
            }
        }

        // clear data
        void clearData()
        {
            int nSize = (int)aVecVecData.size();
            for( int i = 0; i < nSize; ++i)
            {
                delete aVecVecData[i];
            }
            aVecVecData.clear();
        }
    };

};


//////////////////////////////////////////////////////////////////////
//
// Input Processor Implimentation
//
//////////////////////////////////////////////////////////////////////

template< typename T >
class InputProcessorImpl : public InputProcessor
{
public:
    InputProcessorImpl(BREAK_CONDITION _eBreak) : InputProcessor(_eBreak) {}
    virtual ~InputProcessorImpl(){ aData_.clearData(); }

    virtual void process()
    {
        if( aData_.aVecVecData.empty() == false )
                aData_.clearData();
        aData_.processData( eBreakCondition_, 0);
    }

    virtual const std::vector<int>* getDigits(int _nIndex)
    {
        if( _nIndex < 0 ||
            aData_.aVecVecData.empty() ||
            _nIndex >= getDataIndexCount() )
            return 0;

        return InputProcessor::SDataManipulator<T>::getDigits(aData_.aVecVecData, _nIndex);
    }

    virtual const std::vector<std::string>* getChars(int _nIndex)
    {
        if( _nIndex < 0 ||
             aData_.aVecVecData.empty() ||
              _nIndex >= getDataIndexCount() )
            return 0;

        return InputProcessor::SDataManipulator<T>::getChars(aData_.aVecVecData, _nIndex);
    }

    virtual int getDataIndexCount()
    {
        return (int)aData_.aVecVecData.size();
    }

    virtual void addTestInput(const char* pSzTestData)
    {
        aData_.processData(InputProcessor::BREAK_EOF, pSzTestData );
    }

private:
    InputProcessor::SInputData< T > aData_;
};

// 아래의 코드는 컴파일 되지 않는다.
for(int i = 0; i < TL::Length<T_TypeList>::value; ++i)
{
    m_Modules[ i ] = new TL::TypeAt< T_TypeList, i>
}

void InitContext()
{
    // ...

    m_pMockModuleGen = new T_MockModuleGen;

    MakeUsingModule<
        T_TypeList, TL::Length<T_TypeList>::value> makeIt(m_pMockModuleGen);

    // ...
}

template<typename T_TypeList, int i>
struct MakeUsingModule : public MakeUsingModule<T_TypeList, i-1>
{
    MakeUsingModule( MockModuleGenerator* pModuleGen)
        : MakeUsingModule<T_TypeList, i-1>(pModuleGen)
    {
        pModuleGen->CreateUsingModule< TL::TypeAt<T_TypeList, i-1>::Result >();
    }
};

template<typename T_TypeList>
struct MakeUsingModule<T_TypeList, 0>
{
    MakeUsingModule(MockModuleGenerator* pModuleGen)
    {
    }
};

CHelloPok aTestPok("Test pok on hello world 'key'...");
aTestPok.callFunc("key");
aTestPok.callFunc("id");

class CrtpInterface
{
public:
    virtual ~CrtpInterface(){}
    virtual void callFunc(const char* _pSzFuncId) = 0;
};

template <typename T>
class CrtpImpl : public CrtpInterface
{
public:
    virtual void callFunc(const char* _pSzFuncKey)
    {
        FuncMap::iterator itr = funcMap_.find(_pSzFuncKey);
        if( itr == funcMap_.end() )
        {
            printf("Not Found '%s!'\n", _pSzFuncKey);
            return;
        }

        // call func
        (static_cast<T*>(this)->*(itr->second))();
    }

protected:
    typedef void (T::*Func)(void);
    void registerFunc(const char* _pSzFuncKey, Func _pFunc)
    {
        funcMap_[ _pSzFuncKey ] = _pFunc;
    }

private:
    typedef std::map< std::string, Func > FuncMap;
    FuncMap funcMap_;
};

class CHelloWorld : public CrtpImpl< CHelloWorld >
{
public:
    CHelloWorld()
    {
        // key 라는 문자열에 CHelloWorld::helloWorld 멤버함수 연결
        registerFunc("key", &CHelloWorld::helloWorld );
    }

    void helloWorld()
    {
        printf("Hello World!\n");
    }
};

class CHelloPok : public CrtpImpl< CHelloPok >
{
public:
    CHelloPok(const char* _pSzContents) : strToSay_( _pSzContents )
    {
        // key 라는 문자열에 CHelloPok::helloPok 멤버함수 연결
        registerFunc("key", &CHelloPok::helloPok );

        // id 라는 문자열에 CHelloPok::whoAmI 멤버함수 연결
        registerFunc("id", &CHelloPok::whoAmI );
    }

    void helloPok()
    {
        printf("%s\n", strToSay_.c_str() );
    }

    void whoAmI()
    {
        printf("Hey, it's me. pok.\n\n");
    }

private:
    std::string strToSay_;
};

int _tmain(int argc, _TCHAR* argv[])
{
    // 함수호출 테스트
    CHelloPok aTestPok("Test pok on hello world 'key'...");
    aTestPok.callFunc("key");
    aTestPok.callFunc("id");

    // 다형성 테스트
    CHelloWorld aHelloWorld;
    CHelloPok aHelloPok("Hello pok!");

    std::vector< CrtpInterface* > vecFunc;
    vecFunc.push_back(&aHelloWorld);
    vecFunc.push_back(&aHelloPok);

    for(std::vector< CrtpInterface* >::iterator itr = vecFunc.begin();
        itr != vecFunc.end(); ++itr )
    {
        (*itr)->callFunc("key");
    }
    return 0;
}

enum PROP
{
    PROP_1 = 1 << 1,
    PROP_2 = 1 << 2
};

int g_prop = 0;

void AddProperty(PROP _eProp)
{
    g_prop |= _eProp;
}

void RemoveProperty(PROP _eProp)
{
    g_prop &= ~_eProp;
}

bool QueryProperty(PROP _eProp)
{
    if( (g_prop & _eProp) == _eProp )
        return true;
    return false;
    // 혹은
    // return (g_prop & _eProp) ? true : false;
}

def dfsWithStack( _rStartCell )
    aCurrentCell = @aCellContainer[_rStartCell.cell_id]
    return if aCurrentCell == nil

    aMarkedCells = Hash.new
    aDepthStack = Pok::Stack.new

    #start dfs
    aDepthStack.push_back( aCurrentCell )
    print "DFS init With Cell id : " + aCurrentCell.cell_id.to_s + "\n"

    #stack loop
    while aDepthStack.empty? == false
        aCurrentCell = aDepthStack.pop_back
        next if aMarkedCells[ aCurrentCell.cell_id ] == true

        # marking
        aMarkedCells[aCurrentCell.cell_id] = true
        print "Cell id : " + aCurrentCell.cell_id.to_s + " is now visited\n"

        #Test 확인을 쉽게 하기 위해 거꾸로 push 하도록 해서 pop할때는 작은수부터 나오게
        aConnectedCells = aCurrentCell.edge_container.sort
        aConnectedCells.reverse!
        aConnectedCells.each do | id_value_array |
            #연결된 셀을 선택
            aCandidateCell = @aCellContainer[ id_value_array[0] ]
            if aMarkedCells[aCandidateCell.cell_id] == nil
                #셀이 예전에 탐색되지 않은 셀이라면, 스택에 넣어준다.
                aDepthStack.push_back(aCandidateCell)
            end
        end
    end
end

def dfsRecursive( _rStartCell )
    aCurrentCell = @aCellContainer[_rStartCell.cell_id]
    return if aCurrentCell == nil

    aMarkedCellsContainer = Hash.new
    print "DFS(Recursive version) init With Cell id : " + aCurrentCell.cell_id.to_s + "\n"
    dfsRecursiveCore( aCurrentCell, aMarkedCellsContainer )
end

def dfsRecursiveCore( _rCell , _rMarkedCells)
    _rMarkedCells[ _rCell.cell_id ] = true
    print "Cell id : " + _rCell.cell_id.to_s + " is just now visited\n"

    #테스트 확인을 쉽게 하기 위해 셀 번호순서대로 소팅하기
    aConnectedCellsContainer = _rCell.edge_container.sort
    aConnectedCellsContainer.each do | vertex_id_weight |
        nCell_id = vertex_id_weight[0]
        if _rMarkedCells[ nCell_id ] == nil
            dfsRecursiveCore( @aCellContainer[nCell_id], _rMarkedCells )
        end
    end
end