![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to list.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview|
Return to list.cpp CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / capview |
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.