|
1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // CR99QoSConversion.cpp |
|
15 // Contains methods for converting R97 QoS parameters to R99/R4 parameters |
|
16 // |
|
17 // |
|
18 |
|
19 /** |
|
20 @file |
|
21 @internalComponent |
|
22 */ |
|
23 |
|
24 #include <e32cons.h> |
|
25 #include <e32std.h> |
|
26 #include <bacline.h> |
|
27 #include "ceddumper.h" |
|
28 #include "R99QoSConversion.h" |
|
29 #include "ceddumpglobals.h" |
|
30 #include "dbdef.h" |
|
31 #include <etelpckt.h> |
|
32 #include <etelqos.h> |
|
33 #include <faxdefn.h> |
|
34 #include <networking/panroles.h> |
|
35 |
|
36 /** |
|
37 Creates new class instance |
|
38 */ |
|
39 CR99QoSConversion* CR99QoSConversion::NewL() |
|
40 { |
|
41 CR99QoSConversion *self = new (ELeave) CR99QoSConversion(); |
|
42 CleanupStack::PushL(self); |
|
43 self->ConstructL(); |
|
44 CleanupStack::Pop(self); |
|
45 return self; |
|
46 } |
|
47 |
|
48 /** |
|
49 Constructes, initialises the object |
|
50 */ |
|
51 void CR99QoSConversion::ConstructL() |
|
52 { |
|
53 iNext = NULL; |
|
54 iId = 1; |
|
55 iModificationFlag = EFalse; |
|
56 |
|
57 // Initialize the values. |
|
58 // the remaing, unitialised values are set to '0' by CBase |
|
59 iGPRSReqTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
60 iGPRSMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
61 iGPRSReqDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified; |
|
62 iGPRSMinDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified; |
|
63 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
64 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
65 iGPRSReqBER = RPacketQoS::EBERUnspecified; |
|
66 iGPRSMaxBER = RPacketQoS::EBERUnspecified; |
|
67 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
68 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
69 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
70 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
71 iGPRSSignallingIndication = EFalse; |
|
72 iGPRS_ImCnSignallingIndication = EFalse; |
|
73 |
|
74 //Fixed Value |
|
75 iGPRSReqMaxSDUSize = 1500; |
|
76 iGPRSMinAcceptableMaxSDUSize = 1500; |
|
77 |
|
78 iGPRSReqDeliveryOrder = RPacketQoS::EDeliveryOrderRequired; |
|
79 |
|
80 } |
|
81 |
|
82 /** |
|
83 Deletes object |
|
84 */ |
|
85 CR99QoSConversion::~CR99QoSConversion() |
|
86 { |
|
87 delete iNext; |
|
88 } |
|
89 |
|
90 /** |
|
91 Check if given column is not deprecated within incoming/outgoing GPRS table. |
|
92 Additionally converts the setting to new R99 GPRS QoS values if necessary. |
|
93 Assumes setting is given as R97/98 GPRS QoS parameter. |
|
94 |
|
95 @param aColumn A reference to a descriptor containing the name of a column in the current record. |
|
96 @param aSetting The setting |
|
97 @return CR99QoSConversion::TConvRecordType |
|
98 */ |
|
99 CR99QoSConversion::TConvRecordType CR99QoSConversion::CheckAndConvert(TPtrC& aColumn, TPtrC& aSetting ) |
|
100 { |
|
101 |
|
102 TLex temp(aSetting); |
|
103 TInt number; |
|
104 |
|
105 temp.Val(number); |
|
106 |
|
107 if (aColumn.Compare(TPtrC(GPRS_REQ_PRECEDENCE)) == 0) |
|
108 { |
|
109 switch (number) |
|
110 { |
|
111 case (RPacketQoS::EPriorityHighPrecedence) : |
|
112 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
113 break; |
|
114 case (RPacketQoS::EPriorityMediumPrecedence) : |
|
115 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
116 break; |
|
117 case (RPacketQoS::EPriorityLowPrecedence) : |
|
118 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
119 break; |
|
120 default : break; |
|
121 } |
|
122 iModificationFlag = ETrue; |
|
123 return CR99QoSConversion::EDeprecatedRecord; |
|
124 } |
|
125 else if (aColumn.Compare(TPtrC(GPRS_REQ_DELAY)) == 0) |
|
126 { |
|
127 switch (number) |
|
128 { |
|
129 case (RPacketQoS::EDelayClass1): |
|
130 iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
131 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
132 break; |
|
133 case (RPacketQoS::EDelayClass2): |
|
134 iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
135 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
136 break; |
|
137 case (RPacketQoS::EDelayClass3): |
|
138 iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
139 iGPRSReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
140 break; |
|
141 case (RPacketQoS::EDelayClass4): |
|
142 iGPRSReqTrafficClass = RPacketQoS::ETrafficClassBackground; |
|
143 break; |
|
144 default : |
|
145 break; |
|
146 } |
|
147 iModificationFlag = ETrue; |
|
148 return CR99QoSConversion::EDeprecatedRecord; |
|
149 } |
|
150 else if (aColumn.Compare(TPtrC(GPRS_REQ_RELIABILITY)) == 0) |
|
151 { |
|
152 switch (number) |
|
153 { |
|
154 case (RPacketQoS::EReliabilityClass1) : |
|
155 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
156 iGPRSReqBER = RPacketQoS::EBEROnePerHundredThousand; |
|
157 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
158 break; |
|
159 case (RPacketQoS::EReliabilityClass2) : |
|
160 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
161 iGPRSReqBER = RPacketQoS::EBEROnePerHundredThousand; |
|
162 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
163 break; |
|
164 case (RPacketQoS::EReliabilityClass3) : |
|
165 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; |
|
166 iGPRSReqBER = RPacketQoS::EBEROnePerHundredThousand; |
|
167 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
168 break; |
|
169 case (RPacketQoS::EReliabilityClass4) : |
|
170 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
171 iGPRSReqBER = RPacketQoS::EBEROnePerHundredThousand; |
|
172 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
173 break; |
|
174 case (RPacketQoS::EReliabilityClass5) : |
|
175 iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
176 iGPRSReqBER = RPacketQoS::EBERFourPerThousand; |
|
177 iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; |
|
178 break; |
|
179 default: break; |
|
180 } |
|
181 iModificationFlag = ETrue; |
|
182 return CR99QoSConversion::EDeprecatedRecord; |
|
183 } |
|
184 else if (aColumn.Compare(TPtrC(GPRS_REQ_PEAK_THROUGHPUT)) == 0) |
|
185 { |
|
186 switch (number) |
|
187 { |
|
188 case (RPacketQoS::EPeakThroughput1000) : |
|
189 iGPRSReqMaxUplinkRate = 8; |
|
190 iGPRSReqMaxDownlinkRate = 8; |
|
191 break; |
|
192 case (RPacketQoS::EPeakThroughput2000) : |
|
193 iGPRSReqMaxUplinkRate = 16; |
|
194 iGPRSReqMaxDownlinkRate = 16; |
|
195 break; |
|
196 case (RPacketQoS::EPeakThroughput4000) : |
|
197 iGPRSReqMaxUplinkRate = 32; |
|
198 iGPRSReqMaxDownlinkRate = 32; |
|
199 break; |
|
200 case (RPacketQoS::EPeakThroughput8000) : |
|
201 iGPRSReqMaxUplinkRate = 64; |
|
202 iGPRSReqMaxDownlinkRate = 64; |
|
203 break; |
|
204 case (RPacketQoS::EPeakThroughput16000) : |
|
205 iGPRSReqMaxUplinkRate = 128; |
|
206 iGPRSReqMaxDownlinkRate = 128; |
|
207 break; |
|
208 case (RPacketQoS::EPeakThroughput32000) : |
|
209 iGPRSReqMaxUplinkRate = 256; |
|
210 iGPRSReqMaxDownlinkRate = 256; |
|
211 break; |
|
212 case (RPacketQoS::EPeakThroughput64000) : |
|
213 iGPRSReqMaxUplinkRate = 512; |
|
214 iGPRSReqMaxDownlinkRate = 512; |
|
215 break; |
|
216 case (RPacketQoS::EPeakThroughput128000) : |
|
217 iGPRSReqMaxUplinkRate = 1024; |
|
218 iGPRSReqMaxDownlinkRate = 1024; |
|
219 break; |
|
220 case (RPacketQoS::EPeakThroughput256000) : |
|
221 iGPRSReqMaxUplinkRate = 2048; |
|
222 iGPRSReqMaxDownlinkRate = 2048; |
|
223 break; |
|
224 default : break; |
|
225 } |
|
226 iModificationFlag = ETrue; |
|
227 return CR99QoSConversion::EDeprecatedRecord; |
|
228 } |
|
229 else if (aColumn.Compare(TPtrC(GPRS_REQ_MEAN_THROUGHPUT)) == 0) |
|
230 { |
|
231 iModificationFlag = ETrue; |
|
232 return CR99QoSConversion::EDeprecatedRecord; |
|
233 } |
|
234 else if (aColumn.Compare(TPtrC(GPRS_MIN_PRECEDENCE)) == 0) |
|
235 { |
|
236 switch (number) |
|
237 { |
|
238 case (RPacketQoS::EPriorityHighPrecedence) : |
|
239 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
240 break; |
|
241 case (RPacketQoS::EPriorityMediumPrecedence) : |
|
242 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
243 break; |
|
244 case (RPacketQoS::EPriorityLowPrecedence) : |
|
245 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
246 break; |
|
247 default : break; |
|
248 } |
|
249 iModificationFlag = ETrue; |
|
250 return CR99QoSConversion::EDeprecatedRecord; |
|
251 } |
|
252 else if (aColumn.Compare(TPtrC(GPRS_MIN_DELAY)) == 0) |
|
253 { |
|
254 switch (number) |
|
255 { |
|
256 case (RPacketQoS::EDelayClass1): |
|
257 iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
258 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
259 break; |
|
260 case (RPacketQoS::EDelayClass2): |
|
261 iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
262 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
263 break; |
|
264 case (RPacketQoS::EDelayClass3): |
|
265 iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
266 iGPRSMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
267 break; |
|
268 case (RPacketQoS::EDelayClass4): |
|
269 iGPRSMinTrafficClass = RPacketQoS::ETrafficClassBackground; |
|
270 break; |
|
271 default : |
|
272 break; |
|
273 } |
|
274 iModificationFlag = ETrue; |
|
275 return CR99QoSConversion::EDeprecatedRecord; |
|
276 } |
|
277 else if (aColumn.Compare(TPtrC(GPRS_MIN_RELIABILITY))== 0) |
|
278 { |
|
279 switch (number) |
|
280 { |
|
281 case (RPacketQoS::EReliabilityClass1) : |
|
282 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
283 iGPRSMaxBER = RPacketQoS::EBEROnePerHundredThousand; |
|
284 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
285 break; |
|
286 case (RPacketQoS::EReliabilityClass2) : |
|
287 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
288 iGPRSMaxBER = RPacketQoS::EBEROnePerHundredThousand; |
|
289 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
290 break; |
|
291 case (RPacketQoS::EReliabilityClass3) : |
|
292 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; |
|
293 iGPRSMaxBER = RPacketQoS::EBEROnePerHundredThousand; |
|
294 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
295 break; |
|
296 case (RPacketQoS::EReliabilityClass4) : |
|
297 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
298 iGPRSMaxBER = RPacketQoS::EBEROnePerHundredThousand; |
|
299 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
300 break; |
|
301 case (RPacketQoS::EReliabilityClass5) : |
|
302 iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
303 iGPRSMaxBER = RPacketQoS::EBERFourPerThousand; |
|
304 iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; |
|
305 break; |
|
306 default: break; |
|
307 } |
|
308 iModificationFlag = ETrue; |
|
309 return CR99QoSConversion::EDeprecatedRecord; |
|
310 } |
|
311 else if (aColumn.Compare(TPtrC(GPRS_MIN_PEAK_THROUGHPUT)) == 0) |
|
312 { |
|
313 switch (number) |
|
314 { |
|
315 case (RPacketQoS::EPeakThroughput1000) : |
|
316 iGPRSReqMinUplinkRate = 8; |
|
317 iGPRSReqMinDownlinkRate = 8; |
|
318 break; |
|
319 case (RPacketQoS::EPeakThroughput2000) : |
|
320 iGPRSReqMinUplinkRate = 16; |
|
321 iGPRSReqMinDownlinkRate = 16; |
|
322 break; |
|
323 case (RPacketQoS::EPeakThroughput4000) : |
|
324 iGPRSReqMinUplinkRate = 32; |
|
325 iGPRSReqMinDownlinkRate = 32; |
|
326 break; |
|
327 case (RPacketQoS::EPeakThroughput8000) : |
|
328 iGPRSReqMinUplinkRate = 64; |
|
329 iGPRSReqMinDownlinkRate = 64; |
|
330 break; |
|
331 case (RPacketQoS::EPeakThroughput16000) : |
|
332 iGPRSReqMinUplinkRate = 128; |
|
333 iGPRSReqMinDownlinkRate = 128; |
|
334 break; |
|
335 case (RPacketQoS::EPeakThroughput32000) : |
|
336 iGPRSReqMinUplinkRate = 256; |
|
337 iGPRSReqMinDownlinkRate = 256; |
|
338 break; |
|
339 case (RPacketQoS::EPeakThroughput64000) : |
|
340 iGPRSReqMinUplinkRate = 512; |
|
341 iGPRSReqMinDownlinkRate = 512; |
|
342 break; |
|
343 case (RPacketQoS::EPeakThroughput128000) : |
|
344 iGPRSReqMinUplinkRate = 1024; |
|
345 iGPRSReqMinDownlinkRate = 1024; |
|
346 break; |
|
347 case (RPacketQoS::EPeakThroughput256000) : |
|
348 iGPRSReqMinUplinkRate = 2048; |
|
349 iGPRSReqMinDownlinkRate = 2048; |
|
350 break; |
|
351 default : break; |
|
352 } |
|
353 iModificationFlag = ETrue; |
|
354 return CR99QoSConversion::EDeprecatedRecord; |
|
355 } |
|
356 else if (aColumn.Compare(TPtrC(GPRS_MIN_MEAN_THROUGHPUT)) == 0) |
|
357 { |
|
358 iModificationFlag = ETrue; |
|
359 return CR99QoSConversion::EDeprecatedRecord; |
|
360 } |
|
361 else |
|
362 { |
|
363 return CR99QoSConversion::EValidRecord; |
|
364 } |
|
365 } |
|
366 |
|
367 |
|
368 /** |
|
369 Set iNext to the next CR99QoSConversion object in the list. |
|
370 |
|
371 @param aNext handle to CR99QoSConversion object |
|
372 */ |
|
373 void CR99QoSConversion::SetNext(CR99QoSConversion* aNext) |
|
374 { |
|
375 iNext = aNext; |
|
376 aNext->SetId(iId + 1); |
|
377 } |
|
378 |
|
379 /** |
|
380 Retrieves iNext values |
|
381 |
|
382 @return iNext handle to next CR99QoSConversion object in the list |
|
383 */ |
|
384 CR99QoSConversion* CR99QoSConversion::GetNext() |
|
385 { |
|
386 return iNext; |
|
387 } |
|
388 |
|
389 /** |
|
390 Retrieves identification number |
|
391 |
|
392 @return iId object's identification number |
|
393 */ |
|
394 TInt CR99QoSConversion::GetId() |
|
395 { |
|
396 return iId; |
|
397 } |
|
398 |
|
399 /** |
|
400 Set object identification number |
|
401 |
|
402 @param aId identification number |
|
403 */ |
|
404 void CR99QoSConversion::SetId(TInt aId) |
|
405 { |
|
406 iId = aId; |
|
407 } |
|
408 |
|
409 /** |
|
410 Prints out all R99 values in particular format |
|
411 |
|
412 @param aFileDumper handle to the object responsible for writing to the output file |
|
413 */ |
|
414 void CR99QoSConversion::PrintValues(CFileDump* aFileDumper) |
|
415 { |
|
416 TBuf<MAX_BUFFER_LEN> buf; |
|
417 TPtrC column; |
|
418 TPtrC setting; |
|
419 |
|
420 ASSERT(aFileDumper); |
|
421 |
|
422 aFileDumper->WriteSectionHeader(iId); |
|
423 |
|
424 buf.Copy(TPtrC(QOS_UMTS_R99_AND_ON_TABLE)); |
|
425 buf.AppendNum(iId); |
|
426 column.Set(TPtrC(COMMDB_NAME)); |
|
427 setting.Set(buf); |
|
428 aFileDumper->WriteColumnValue(column, setting); |
|
429 |
|
430 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRAFFIC_CLASS), iGPRSReqTrafficClass); |
|
431 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_TRAFFIC_CLASS), iGPRSMinTrafficClass); |
|
432 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_DELIVERY_ORDER),iGPRSReqDeliveryOrder); |
|
433 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_DELIVERY_ORDER),iGPRSMinDeliveryOrder); |
|
434 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_DELIVER_ERRONEOUS_SDU),iGPRSReqDeliverErroneousSDU); |
|
435 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_DELIVER_ERRONEOUS_SDU),iGPRSMinDeliverErroneousSDU); |
|
436 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_SDUSIZE),iGPRSReqMaxSDUSize); |
|
437 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_ACCEPTABLE_MAX_SDU_SIZE),iGPRSMinAcceptableMaxSDUSize); |
|
438 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_UPLINK_RATE),iGPRSReqMaxUplinkRate); |
|
439 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MIN_UPLINK_RATE),iGPRSReqMinUplinkRate); |
|
440 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_DOWNLINK_RATE),iGPRSReqMaxDownlinkRate); |
|
441 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MIN_DOWNLINK_RATE),iGPRSReqMinDownlinkRate); |
|
442 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_BER),iGPRSReqBER); |
|
443 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_BER),iGPRSMaxBER); |
|
444 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_SDU_ERROR_RATIO),iGPRSReqSDUErrorRatio); |
|
445 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_SDU_ERROR_RATIO),iGPRSMaxSDUErrorRatio); |
|
446 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRAFFIC_HANDLING_PRIORITY),iGPRSReqTrafficHandlingPriority); |
|
447 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_TRAFFIC_HANDLING_PRIORITY),iGPRSMinTrafficHandlingPriority); |
|
448 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRANSFER_DELAY),iGPRSReqTransferDelay); |
|
449 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_TRANSFER_DELAY),iGPRSMaxTransferDelay); |
|
450 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_GUARANTEED_UPLINK_RATE),iGPRSReqGuaranteedUplinkRate); |
|
451 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_GUARANTEED_UPLINK_RATE),iGPRSMinGuaranteedUplinkRate); |
|
452 PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_GUARANTEED_DOWNLINK_RATE),iGPRSReqGuaranteedDownlinkRate); |
|
453 PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_GUARANTEED_DOWNLINK_RATE),iGPRSMinGuaranteedDownlinkRate); |
|
454 PrintLine(aFileDumper, TPtrC(GPRS_QOS_SIGNALLING_INDICATION),(iGPRSSignallingIndication == RPacketQoS::EDeliveryOrderRequired)?TPtrC(_S("TRUE")):TPtrC(_S("FALSE"))); |
|
455 PrintLine(aFileDumper, TPtrC(GPRS_QOS_IM_CN_SIGNALLING_INDICATOR),(iGPRS_ImCnSignallingIndication == RPacketQoS::EDeliveryOrderRequired)?TPtrC(_S("TRUE")):TPtrC(_S("FALSE"))); |
|
456 PrintLine(aFileDumper, TPtrC(GPRS_QOS_SOURCE_STATISTICS_DESCRIPTOR),iGPRSSourceStatisticsDescriptor); |
|
457 |
|
458 aFileDumper->WriteFieldCount(27); |
|
459 aFileDumper->WriteSectionFooter(iId); |
|
460 } |
|
461 |
|
462 /** |
|
463 Prints out the line to the output file |
|
464 |
|
465 @param aFileDumper handle to the object responsible for writing to the output file |
|
466 @param aCol name of the column to print out |
|
467 @param aSetting intiger column's value to print out |
|
468 */ |
|
469 void CR99QoSConversion::PrintLine(CFileDump* aFileDumper, TPtrC aCol, TInt aSetting) |
|
470 { |
|
471 TBuf<MAX_BUFFER_LEN> buf; |
|
472 TPtrC column; |
|
473 TPtrC setting; |
|
474 |
|
475 column.Set(aCol); |
|
476 buf.Num(aSetting); |
|
477 setting.Set(buf); |
|
478 aFileDumper->WriteColumnValue(column, setting); |
|
479 } |
|
480 |
|
481 /** |
|
482 Prints out all R99 values in particular format |
|
483 |
|
484 @param aFileDumper handle to the object responsible for writing to the output file |
|
485 @param aCol name of the column to print out |
|
486 @param aSetting pointer to string to print out as a column's value |
|
487 */ |
|
488 void CR99QoSConversion::PrintLine(CFileDump* aFileDumper, TPtrC aCol, TPtrC aSetting) |
|
489 { |
|
490 TPtrC column; |
|
491 TPtrC setting; |
|
492 column.Set(aCol); |
|
493 setting.Set(aSetting); |
|
494 aFileDumper->WriteColumnValue(column, setting); |
|
495 } |
|
496 |
|
497 /** |
|
498 Retrieves modification flag |
|
499 |
|
500 @return iModificationFlag modification flag |
|
501 */ |
|
502 TBool CR99QoSConversion::GetModificationFlag() |
|
503 { |
|
504 return iModificationFlag; |
|
505 } |