Return to list.cpp CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview

Annotation of mstools/samples/sdktools/capview/list.cpp, revision 1.1

1.1     ! root        1: #include <afxwin.h>
        !             2: #include <afxcoll.h>
        !             3: 
        !             4: #include "types.h"
        !             5: #include "list.h"
        !             6: 
        !             7: extern "C" char * UnDName(char *);
        !             8: 
        !             9: ListItem::ListItem(char * szModule, char * szName, int cCalls, TIMETYPE time2, TIMETYPE timeFunc) :
        !            10:        strMod(szModule), strFunc(szName)
        !            11: {
        !            12:     totalTime = timeFunc;
        !            13:     timeAll = time2;
        !            14:     calls = cCalls;
        !            15: 
        !            16:     return;
        !            17: }
        !            18: 
        !            19: int ListArray::Search(char * szModule, char * szName)
        !            20: {
        !            21:     int         i = 0;
        !            22:     int         j = GetUpperBound();
        !            23:     int         k;
        !            24:     ListItem *  pli;
        !            25: 
        !            26:     if (j == -1) {
        !            27:         return 0;
        !            28:     }
        !            29: 
        !            30:     while ( i < j ) {
        !            31:         k = (i + j) / 2;
        !            32:         pli = (ListItem *) GetAt(k);
        !            33: 
        !            34:         if (pli->strModule() < szModule) {
        !            35:             i = k + 1;
        !            36:         } else if (pli->strModule() > szModule) {
        !            37:             j = k - 1;
        !            38:         } else if (pli->strFunction() < szName) {
        !            39:             i = k + 1;
        !            40:         } else if (pli->strFunction() > szName) {
        !            41:             j = k - 1;
        !            42:         } else {
        !            43:             return k;
        !            44:         }
        !            45:     }
        !            46: 
        !            47:     pli = (ListItem *) GetAt(i);
        !            48:     if (pli->strModule() < szModule) {
        !            49:         i += 1;
        !            50:     } else if ((pli->strModule() == szModule) &&
        !            51:                (pli->strFunction() < szName)) {
        !            52:         i += 1;
        !            53:     }
        !            54: 
        !            55:     return i;
        !            56: }                               /* ListArray::Search() */
        !            57: 
        !            58: void ListHead::AddTiming(char * szModule, char * szName, int cCalls,
        !            59:                          TIMETYPE timeAll, TIMETYPE timeFunc)
        !            60: {
        !            61:     int         i;
        !            62:     ListItem *  pli1;
        !            63: 
        !            64:     /*
        !            65:      *  Keep track of the total tree time from the root
        !            66:      */
        !            67: 
        !            68:     timeTotal += timeFunc;
        !            69: 
        !            70:     /*
        !            71:      *  Find if the item is in the array already
        !            72:      */
        !            73: 
        !            74:     i = rgAlpha.Search(szModule, szName);
        !            75:     if (i <= rgAlpha.GetUpperBound()) {
        !            76:         pli1 = (ListItem *) rgAlpha[i];
        !            77: 
        !            78:         if ((pli1->strModule() == szModule) &&
        !            79:             (pli1->strFunction() == szName)) {
        !            80: 
        !            81:             pli1->AddTime(cCalls, timeAll, timeFunc);
        !            82:             return;
        !            83:         }
        !            84:     }
        !            85: 
        !            86:     pli1 = new ListItem(szModule, szName, cCalls, timeAll, timeFunc);
        !            87:     rgAlpha.InsertAt(i, pli1);
        !            88: 
        !            89:     return;
        !            90: }                               /* ListHead::AddTiming() */
        !            91: 
        !            92: 
        !            93: int _CRTAPI1 a(const void * pv1, const void * pv2)
        !            94: {
        !            95:     ListItem * p1 = *(ListItem **) pv1;
        !            96:     ListItem *  p2 = *(ListItem **) pv2;
        !            97: 
        !            98:     if (p1->Time() > p2->Time()) {
        !            99:         return -1;
        !           100:     } else if (p2->Time() > p1->Time()) {
        !           101:        return  1;
        !           102:     }
        !           103:     return 0;
        !           104: }
        !           105: 
        !           106: void ListHead::SortByTotalTime()
        !           107: {
        !           108:     rgRoutineTime.SetSize(rgAlpha.GetSize());
        !           109: 
        !           110:     for (int i=0; i < rgAlpha.GetSize(); i++) {
        !           111:         rgRoutineTime[i] = rgAlpha[i];
        !           112:     }
        !           113: 
        !           114:     rgRoutineTime.Sort(a);
        !           115:     return;
        !           116: }                               /* ListHead::SortByTotalTime() */
        !           117: 
        !           118: 
        !           119: int _CRTAPI1 b(const void * pv1, const void * pv2)
        !           120: {
        !           121:     ListItem * p1 = *(ListItem **) pv1;
        !           122:     ListItem *  p2 = *(ListItem **) pv2;
        !           123: 
        !           124:     if (p1->TimePerCall() > p2->TimePerCall()) {
        !           125:         return -1;
        !           126:     } else if (p2->TimePerCall() > p1->TimePerCall()) {
        !           127:        return  1;
        !           128:     }
        !           129:     return 0;
        !           130: }
        !           131: 
        !           132: void ListHead::SortByPerTime()
        !           133: {
        !           134:     rgRoutineTimePer.SetSize(rgAlpha.GetSize());
        !           135: 
        !           136:     for (int i=0; i < rgAlpha.GetSize(); i++) {
        !           137:         rgRoutineTimePer[i] = rgAlpha[i];
        !           138:     }
        !           139:     rgRoutineTimePer.Sort(b);
        !           140:     return;
        !           141: }                               /* ListHead::SortByPerTime() */
        !           142: 
        !           143: 
        !           144: int _CRTAPI1 c(const void * pv1, const void * pv2)
        !           145: {
        !           146:     ListItem * p1 = *(ListItem **) pv1;
        !           147:     ListItem *  p2 = *(ListItem **) pv2;
        !           148: 
        !           149:     if (p1->Calls() > p2->Calls()) {
        !           150:         return -1;
        !           151:     } else if (p2->Calls() > p1->Calls()) {
        !           152:        return  1;
        !           153:     }
        !           154:     return 0;
        !           155: }
        !           156: 
        !           157: void ListHead::SortByCallCount()
        !           158: {
        !           159:     rgCalls.SetSize(rgAlpha.GetSize());
        !           160: 
        !           161:     for (int i=0; i < rgAlpha.GetSize(); i++) {
        !           162:         rgCalls[i] = rgAlpha[i];
        !           163:     }
        !           164:     rgCalls.Sort(c);
        !           165:     return;
        !           166: }                               /* ListHead::SortByCallCount() */
        !           167: 
        !           168: int _CRTAPI1 d(const void * pv1, const void * pv2)
        !           169: {
        !           170:     ListItem * p1 = *(ListItem **) pv1;
        !           171:     ListItem *  p2 = *(ListItem **) pv2;
        !           172: 
        !           173:     if (p1->TimeAll() > p2->TimeAll()) {
        !           174:         return -1;
        !           175:     } else if (p2->TimeAll() > p1->TimeAll()) {
        !           176:        return  1;
        !           177:     }
        !           178:     return 0;
        !           179: }
        !           180: 
        !           181: void ListHead::SortByTimeAll()
        !           182: {
        !           183:     rgTreeTime.SetSize(rgAlpha.GetSize());
        !           184: 
        !           185:     for (int i=0; i < rgAlpha.GetSize(); i++) {
        !           186:         rgTreeTime[i] = rgAlpha[i];
        !           187:     }
        !           188:     rgTreeTime.Sort(d);
        !           189:     return;
        !           190: }                               /* ListHead::SortByTimeAll() */
        !           191: 
        !           192: 
        !           193: int _CRTAPI1 e(const void * pv1, const void * pv2)
        !           194: {
        !           195:     ListItem * p1 = *(ListItem **) pv1;
        !           196:     ListItem *  p2 = *(ListItem **) pv2;
        !           197: 
        !           198:     if (p1->TimeAllPerCall() > p2->TimeAllPerCall()) {
        !           199:         return -1;
        !           200:     } else if (p2->TimeAllPerCall() > p1->TimeAllPerCall()) {
        !           201:        return  1;
        !           202:     }
        !           203:     return 0;
        !           204: }
        !           205: 
        !           206: void ListHead::SortByTPerTime()
        !           207: {
        !           208:     rgTreeTimePer.SetSize(rgAlpha.GetSize());
        !           209: 
        !           210:     for (int i=0; i < rgAlpha.GetSize(); i++) {
        !           211:         rgTreeTimePer[i] = rgAlpha[i];
        !           212:     }
        !           213:     rgTreeTimePer.Sort(e);
        !           214:     return;
        !           215: }                               /* ListHead::SortByTPerTime() */
        !           216: 
        !           217: 
        !           218: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.