|
1 // Copyright (c) 2007-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 // |
|
15 |
|
16 #include "parameters.h" |
|
17 #include "umts_qos_variables.h" |
|
18 #include "guqos_log.h" |
|
19 #include "guqos.h" |
|
20 |
|
21 |
|
22 TQoSRequested::TQoSRequested() : iHeaderCompression(0) |
|
23 { |
|
24 Reset(); |
|
25 } |
|
26 |
|
27 void TQoSRequested::Reset() |
|
28 { |
|
29 iReqTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
30 iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
31 iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
32 iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
33 iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
34 iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
35 iReqMaxSDUSize = 0; // subscribe value |
|
36 iMinAcceptableMaxSDUSize = 0; // subscribe value |
|
37 iReqMaxRate.iUplinkRate = 0; |
|
38 iReqMaxRate.iDownlinkRate = 0; |
|
39 iMinAcceptableMaxRate.iUplinkRate = 0; |
|
40 iMinAcceptableMaxRate.iDownlinkRate = 0; |
|
41 iReqBER = RPacketQoS::EBERUnspecified; |
|
42 iMaxBER = RPacketQoS::EBERUnspecified; |
|
43 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
44 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
45 iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
46 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
47 iReqTransferDelay = 0; |
|
48 iMaxTransferDelay = 0; |
|
49 iReqGuaranteedRate.iUplinkRate = 0; |
|
50 iReqGuaranteedRate.iDownlinkRate = 0; |
|
51 iMinGuaranteedRate.iUplinkRate = 0; |
|
52 iMinGuaranteedRate.iDownlinkRate = 0; |
|
53 } |
|
54 |
|
55 void TQoSRequested::ClearMinimumParameters() |
|
56 { |
|
57 iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
58 iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
59 iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
60 iMinAcceptableMaxSDUSize = 0; |
|
61 iMinAcceptableMaxRate.iUplinkRate = 0; |
|
62 iMinAcceptableMaxRate.iDownlinkRate = 0; |
|
63 iMaxBER = RPacketQoS::EBERUnspecified; |
|
64 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
65 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
66 iMaxTransferDelay = 0; |
|
67 iMinGuaranteedRate.iUplinkRate = 0; |
|
68 iMinGuaranteedRate.iDownlinkRate = 0; |
|
69 } |
|
70 |
|
71 void TQoSRequested::ParsePolicyData(CExtensionPolicy* extensionPolicy) |
|
72 { |
|
73 LOG(Log::Printf(_L("<-------------------------------------------------"))); |
|
74 LOG(Log::Printf(_L("TQoSRequested::ParsePolicyData - Start Parsing Extensions"))); |
|
75 |
|
76 TExtensionQueueIter i(extensionPolicy->Extensions()); |
|
77 CExtension* extension; |
|
78 |
|
79 while ((extension = i++) != NULL) |
|
80 { |
|
81 if( (extension->Type() != STATIC_CAST(TUint,KPfqosR5ExtensionUmts)) |
|
82 && (extension->Type() != STATIC_CAST(TUint,KPfqosExtensionUmts)) |
|
83 ) |
|
84 { |
|
85 LOG(Log::Printf(_L("\tKPfqosExtensionUmts - Extension NOT found"))); |
|
86 continue; |
|
87 } |
|
88 |
|
89 LOG(Log::Printf(_L("\tKPfqosExtensionUmts - Extension found"))); |
|
90 |
|
91 |
|
92 TVariableQueueIter iter(extension->Queue()); |
|
93 TVariableBase *var; |
|
94 |
|
95 while ((var = iter++) != NULL) |
|
96 { |
|
97 switch (var->Type()) |
|
98 { |
|
99 |
|
100 case KPfqosTypeInteger: |
|
101 { |
|
102 TIntVariable* tmp = (TIntVariable*) var; |
|
103 LOG(Log::Printf(_L("\tKPfqosExtensionUmts '%S': %d"), &tmp->Name(), tmp->Value())); |
|
104 |
|
105 //lint -e{961} would want terminating 'else' (but we don't) |
|
106 if (tmp->Name().Compare(KDescDeliveryOfErroneusSduRequested)==0) |
|
107 { |
|
108 TInt value = tmp->Value(); |
|
109 switch(value) |
|
110 { |
|
111 case RPacketQoS::EErroneousSDUDeliveryUnspecified: |
|
112 iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
113 break; |
|
114 case RPacketQoS::EErroneousSDUDeliveryRequired: |
|
115 iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; |
|
116 break; |
|
117 case RPacketQoS::EErroneousSDUDeliveryNotRequired: |
|
118 iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
119 break; |
|
120 default: |
|
121 break; |
|
122 } |
|
123 } |
|
124 else if (tmp->Name().Compare(KDescDeliveryOrderRequested)==0) |
|
125 { |
|
126 TInt value = tmp->Value(); |
|
127 switch(value) |
|
128 { |
|
129 case RPacketQoS::EDeliveryOrderUnspecified: |
|
130 iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
131 break; |
|
132 case RPacketQoS::EDeliveryOrderRequired: |
|
133 iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderRequired; |
|
134 break; |
|
135 case RPacketQoS::EDeliveryOrderNotRequired: |
|
136 iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; |
|
137 break; |
|
138 default: |
|
139 break; |
|
140 } |
|
141 } |
|
142 else if (tmp->Name().Compare(KDescErrorRatioRequested)==0) |
|
143 { |
|
144 TInt value = tmp->Value(); |
|
145 switch(value) |
|
146 { |
|
147 case RPacketQoS::ESDUErrorRatioUnspecified: |
|
148 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
149 break; |
|
150 case RPacketQoS::ESDUErrorRatioOnePerTen: |
|
151 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTen; |
|
152 break; |
|
153 case RPacketQoS::ESDUErrorRatioOnePerHundred: |
|
154 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundred; |
|
155 break; |
|
156 case RPacketQoS::ESDUErrorRatioSevenPerThousand: |
|
157 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioSevenPerThousand; |
|
158 break; |
|
159 case RPacketQoS::ESDUErrorRatioOnePerThousand: |
|
160 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
161 break; |
|
162 case RPacketQoS::ESDUErrorRatioOnePerTenThousand: |
|
163 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; |
|
164 break; |
|
165 case RPacketQoS::ESDUErrorRatioOnePerHundredThousand: |
|
166 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundredThousand; |
|
167 break; |
|
168 case RPacketQoS::ESDUErrorRatioOnePerMillion: |
|
169 iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
170 break; |
|
171 default: |
|
172 break; |
|
173 } |
|
174 } |
|
175 else if (tmp->Name().Compare(KDescGuaBitrateDownlinkRequested)==0) |
|
176 { |
|
177 iReqGuaranteedRate.iDownlinkRate = tmp->Value(); |
|
178 } |
|
179 else if (tmp->Name().Compare(KDescGuaBitrateUplinkRequested)==0) |
|
180 { |
|
181 iReqGuaranteedRate.iUplinkRate = tmp->Value(); |
|
182 } |
|
183 else if (tmp->Name().Compare(KDescMaxBitrateDownlinkRequested)==0) |
|
184 { |
|
185 iReqMaxRate.iDownlinkRate = tmp->Value(); |
|
186 } |
|
187 else if (tmp->Name().Compare(KDescMaxBitrateUplinkRequested)==0) |
|
188 { |
|
189 iReqMaxRate.iUplinkRate = tmp->Value(); |
|
190 } |
|
191 else if (tmp->Name().Compare(KDescMaxSduSizeRequested)==0) |
|
192 { |
|
193 iReqMaxSDUSize = tmp->Value(); |
|
194 } |
|
195 else if (tmp->Name().Compare(KDescPriorityRequested)==0) |
|
196 { |
|
197 TInt value = tmp->Value(); |
|
198 switch(value) |
|
199 { |
|
200 case RPacketQoS::ETrafficPriorityUnspecified: |
|
201 iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
202 break; |
|
203 case RPacketQoS::ETrafficPriority1: |
|
204 iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
205 break; |
|
206 case RPacketQoS::ETrafficPriority2: |
|
207 iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
208 break; |
|
209 case RPacketQoS::ETrafficPriority3: |
|
210 iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
211 break; |
|
212 default: |
|
213 break; |
|
214 } |
|
215 } |
|
216 else if (tmp->Name().Compare(KDescResidualBerRequested)==0) |
|
217 { |
|
218 TInt value = tmp->Value(); |
|
219 switch(value) |
|
220 { |
|
221 case RPacketQoS::EBERUnspecified: |
|
222 iReqBER = RPacketQoS::EBERUnspecified; |
|
223 break; |
|
224 case RPacketQoS::EBERFivePerHundred: |
|
225 iReqBER = RPacketQoS::EBERFivePerHundred; |
|
226 break; |
|
227 case RPacketQoS::EBEROnePerHundred: |
|
228 iReqBER = RPacketQoS::EBEROnePerHundred; |
|
229 break; |
|
230 case RPacketQoS::EBERFivePerThousand: |
|
231 iReqBER = RPacketQoS::EBERFivePerThousand; |
|
232 break; |
|
233 case RPacketQoS::EBERFourPerThousand: |
|
234 iReqBER = RPacketQoS::EBERFourPerThousand; |
|
235 break; |
|
236 case RPacketQoS::EBEROnePerThousand: |
|
237 iReqBER = RPacketQoS::EBEROnePerThousand; |
|
238 break; |
|
239 case RPacketQoS::EBEROnePerTenThousand: |
|
240 iReqBER = RPacketQoS::EBEROnePerTenThousand; |
|
241 break; |
|
242 case RPacketQoS::EBEROnePerHundredThousand: |
|
243 iReqBER = RPacketQoS::EBEROnePerHundredThousand; |
|
244 break; |
|
245 case RPacketQoS::EBEROnePerMillion: |
|
246 iReqBER = RPacketQoS::EBEROnePerMillion; |
|
247 break; |
|
248 case RPacketQoS::EBERSixPerHundredMillion: |
|
249 iReqBER = RPacketQoS::EBERSixPerHundredMillion; |
|
250 break; |
|
251 default: |
|
252 break; |
|
253 } |
|
254 } |
|
255 else if (tmp->Name().Compare(KDescTrafficClassRequested)==0) |
|
256 { |
|
257 TInt value = tmp->Value(); |
|
258 switch(value) |
|
259 { |
|
260 case RPacketQoS::ETrafficClassUnspecified: |
|
261 iReqTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
262 break; |
|
263 case RPacketQoS::ETrafficClassConversational: |
|
264 iReqTrafficClass = RPacketQoS::ETrafficClassConversational; |
|
265 break; |
|
266 case RPacketQoS::ETrafficClassStreaming: |
|
267 iReqTrafficClass = RPacketQoS::ETrafficClassStreaming; |
|
268 break; |
|
269 case RPacketQoS::ETrafficClassInteractive: |
|
270 iReqTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
271 break; |
|
272 case RPacketQoS::ETrafficClassBackground: |
|
273 iReqTrafficClass = RPacketQoS::ETrafficClassBackground; |
|
274 break; |
|
275 default: |
|
276 break; |
|
277 } |
|
278 } |
|
279 else if (tmp->Name().Compare(KDescTransferDelayRequested)==0) |
|
280 { |
|
281 iReqTransferDelay = tmp->Value(); |
|
282 } |
|
283 // Minimum |
|
284 else if (tmp->Name().Compare(KDescDeliveryOfErroneusSduMinimum)==0) |
|
285 { |
|
286 TInt value = tmp->Value(); |
|
287 switch(value) |
|
288 { |
|
289 case RPacketQoS::EErroneousSDUDeliveryUnspecified: |
|
290 iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; |
|
291 break; |
|
292 case RPacketQoS::EErroneousSDUDeliveryRequired: |
|
293 iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; |
|
294 break; |
|
295 case RPacketQoS::EErroneousSDUDeliveryNotRequired: |
|
296 iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
297 break; |
|
298 default: |
|
299 break; |
|
300 } |
|
301 } |
|
302 else if (tmp->Name().Compare(KDescDeliveryOrderMinimum)==0) |
|
303 { |
|
304 TInt value = tmp->Value(); |
|
305 switch(value) |
|
306 { |
|
307 case RPacketQoS::EDeliveryOrderUnspecified: |
|
308 iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
309 break; |
|
310 case RPacketQoS::EDeliveryOrderRequired: |
|
311 iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderRequired; |
|
312 break; |
|
313 case RPacketQoS::EDeliveryOrderNotRequired: |
|
314 iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; |
|
315 break; |
|
316 default: |
|
317 break; |
|
318 } |
|
319 } |
|
320 else if (tmp->Name().Compare(KDescErrorRatioMinimum)==0) |
|
321 { |
|
322 TInt value = tmp->Value(); |
|
323 switch(value) |
|
324 { |
|
325 case RPacketQoS::ESDUErrorRatioUnspecified: |
|
326 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
327 break; |
|
328 case RPacketQoS::ESDUErrorRatioOnePerTen: |
|
329 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTen; |
|
330 break; |
|
331 case RPacketQoS::ESDUErrorRatioOnePerHundred: |
|
332 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundred; |
|
333 break; |
|
334 case RPacketQoS::ESDUErrorRatioSevenPerThousand: |
|
335 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioSevenPerThousand; |
|
336 break; |
|
337 case RPacketQoS::ESDUErrorRatioOnePerThousand: |
|
338 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; |
|
339 break; |
|
340 case RPacketQoS::ESDUErrorRatioOnePerTenThousand: |
|
341 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; |
|
342 break; |
|
343 case RPacketQoS::ESDUErrorRatioOnePerHundredThousand: |
|
344 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundredThousand; |
|
345 break; |
|
346 case RPacketQoS::ESDUErrorRatioOnePerMillion: |
|
347 iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; |
|
348 break; |
|
349 default: |
|
350 break; |
|
351 } |
|
352 } |
|
353 else if (tmp->Name().Compare(KDescGuaBitrateDownlinkMinimum)==0) |
|
354 { |
|
355 iMinGuaranteedRate.iDownlinkRate = tmp->Value(); |
|
356 } |
|
357 else if (tmp->Name().Compare(KDescGuaBitrateUplinkMinimum)==0) |
|
358 { |
|
359 iMinGuaranteedRate.iUplinkRate = tmp->Value(); |
|
360 } |
|
361 else if (tmp->Name().Compare(KDescMaxBitrateDownlinkMinimum)==0) |
|
362 { |
|
363 iMinAcceptableMaxRate.iDownlinkRate = tmp->Value(); |
|
364 } |
|
365 else if (tmp->Name().Compare(KDescMaxBitrateUplinkMinimum)==0) |
|
366 { |
|
367 iMinAcceptableMaxRate.iUplinkRate = tmp->Value(); |
|
368 } |
|
369 else if (tmp->Name().Compare(KDescMaxSduSizeMinimum)==0) |
|
370 { |
|
371 iMinAcceptableMaxSDUSize = tmp->Value(); |
|
372 } |
|
373 else if (tmp->Name().Compare(KDescPriorityMinimum)==0) |
|
374 { |
|
375 TInt value = tmp->Value(); |
|
376 switch(value) |
|
377 { |
|
378 case RPacketQoS::ETrafficPriorityUnspecified: |
|
379 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
380 break; |
|
381 case RPacketQoS::ETrafficPriority1: |
|
382 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
383 break; |
|
384 case RPacketQoS::ETrafficPriority2: |
|
385 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
386 break; |
|
387 case RPacketQoS::ETrafficPriority3: |
|
388 iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
389 break; |
|
390 default: |
|
391 break; |
|
392 } |
|
393 } |
|
394 else if (tmp->Name().Compare(KDescResidualBerMinimum)==0) |
|
395 { |
|
396 TInt value = tmp->Value(); |
|
397 switch(value) |
|
398 { |
|
399 case RPacketQoS::EBERUnspecified: |
|
400 iMaxBER = RPacketQoS::EBERUnspecified; |
|
401 break; |
|
402 case RPacketQoS::EBERFivePerHundred: |
|
403 iMaxBER = RPacketQoS::EBERFivePerHundred; |
|
404 break; |
|
405 case RPacketQoS::EBEROnePerHundred: |
|
406 iMaxBER = RPacketQoS::EBEROnePerHundred; |
|
407 break; |
|
408 case RPacketQoS::EBERFivePerThousand: |
|
409 iMaxBER = RPacketQoS::EBERFivePerThousand; |
|
410 break; |
|
411 case RPacketQoS::EBERFourPerThousand: |
|
412 iMaxBER = RPacketQoS::EBERFourPerThousand; |
|
413 break; |
|
414 case RPacketQoS::EBEROnePerThousand: |
|
415 iMaxBER = RPacketQoS::EBEROnePerThousand; |
|
416 break; |
|
417 case RPacketQoS::EBEROnePerTenThousand: |
|
418 iMaxBER = RPacketQoS::EBEROnePerTenThousand; |
|
419 break; |
|
420 case RPacketQoS::EBEROnePerHundredThousand: |
|
421 iMaxBER = RPacketQoS::EBEROnePerHundredThousand; |
|
422 break; |
|
423 case RPacketQoS::EBEROnePerMillion: |
|
424 iMaxBER = RPacketQoS::EBEROnePerMillion; |
|
425 break; |
|
426 case RPacketQoS::EBERSixPerHundredMillion: |
|
427 iMaxBER = RPacketQoS::EBERSixPerHundredMillion; |
|
428 break; |
|
429 default: |
|
430 break; |
|
431 } |
|
432 } |
|
433 else if (tmp->Name().Compare(KDescTrafficClassMinimum)==0) |
|
434 { |
|
435 TInt value = tmp->Value(); |
|
436 switch(value) |
|
437 { |
|
438 case RPacketQoS::ETrafficClassUnspecified: |
|
439 iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; |
|
440 break; |
|
441 case RPacketQoS::ETrafficClassConversational: |
|
442 iMinTrafficClass = RPacketQoS::ETrafficClassConversational; |
|
443 break; |
|
444 case RPacketQoS::ETrafficClassStreaming: |
|
445 iMinTrafficClass = RPacketQoS::ETrafficClassStreaming; |
|
446 break; |
|
447 case RPacketQoS::ETrafficClassInteractive: |
|
448 iMinTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
449 break; |
|
450 case RPacketQoS::ETrafficClassBackground: |
|
451 iMinTrafficClass = RPacketQoS::ETrafficClassBackground; |
|
452 break; |
|
453 default: |
|
454 break; |
|
455 } |
|
456 } |
|
457 else if (tmp->Name().Compare(KDescTransferDelayMinimum)==0) |
|
458 { |
|
459 iMaxTransferDelay = tmp->Value(); |
|
460 } |
|
461 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
462 else if (tmp->Name().Compare(KDescSignallingIndicatorRequested)==0) |
|
463 { |
|
464 iSignallingIndication = tmp->Value(); |
|
465 } |
|
466 else if (tmp->Name().Compare(KDescSrcStatDescRequested)==0) |
|
467 { |
|
468 TInt value = tmp->Value(); |
|
469 switch(value) |
|
470 { |
|
471 case RPacketQoS::ESourceStatisticsDescriptorUnknown: |
|
472 iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorUnknown; |
|
473 break; |
|
474 case RPacketQoS::ESourceStatisticsDescriptorSpeech: |
|
475 iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorSpeech; |
|
476 break; |
|
477 default: |
|
478 break; |
|
479 } |
|
480 } |
|
481 #endif // SYMBIAN_NETWORKING_UMTSR5 |
|
482 else if (tmp->Name().Compare(KDescHeaderCompression)==0) |
|
483 { |
|
484 iHeaderCompression = tmp->Value(); |
|
485 } |
|
486 } |
|
487 break; |
|
488 |
|
489 default: |
|
490 LOG(Log::Printf(_L("\tKPfqosExtensionUmts type=%d '%S': ignored"), (TInt)var->Type(), &var->Name())); |
|
491 break; |
|
492 } |
|
493 } |
|
494 } |
|
495 |
|
496 LOG(Log::Printf(_L("TQoSRequested::ParsePolicyData - End Parsing Extensions"))); |
|
497 LOG(Log::Printf(_L("PARSED VALUES:"))); |
|
498 LOG(Log::Printf(_L("\tiReqTrafficClass = %d"), iReqTrafficClass)); |
|
499 LOG(Log::Printf(_L("\tiReqDeliveryOrderReqd = %d"), iReqDeliveryOrderReqd)); |
|
500 LOG(Log::Printf(_L("\tiReqDeliverErroneousSDU = %d"), iReqDeliverErroneousSDU)); |
|
501 LOG(Log::Printf(_L("\tiReqMaxSDUSize = %d"), iReqMaxSDUSize)); |
|
502 LOG(Log::Printf(_L("\tiReqMaxRate.iUplinkRate = %d"), iReqMaxRate.iUplinkRate)); |
|
503 LOG(Log::Printf(_L("\tiReqMaxRate.iDownlinkRate = %d"), iReqMaxRate.iDownlinkRate)); |
|
504 LOG(Log::Printf(_L("\tiReqBER = %d"), iReqBER)); |
|
505 LOG(Log::Printf(_L("\tiReqSDUErrorRatio = %d"), iReqSDUErrorRatio)); |
|
506 LOG(Log::Printf(_L("\tiReqTrafficHandlingPriority = %d"),iReqTrafficHandlingPriority)); |
|
507 LOG(Log::Printf(_L("\tiReqTransferDelay = %d"), iReqTransferDelay)); |
|
508 LOG(Log::Printf(_L("\tiReqGuaranteedRate.iUplinkRate = %d"),iReqGuaranteedRate.iUplinkRate)); |
|
509 LOG(Log::Printf(_L("\tiReqGuaranteedRate.iDownlinkRate = %d"),iReqGuaranteedRate.iDownlinkRate)); |
|
510 LOG(Log::Printf(_L(""))); |
|
511 LOG(Log::Printf(_L("\tiMinTrafficClass = %d"), iMinTrafficClass)); |
|
512 LOG(Log::Printf(_L("\tiMinDeliveryOrderReqd = %d"), iMinDeliveryOrderReqd)); |
|
513 LOG(Log::Printf(_L("\tiMinDeliverErroneousSDU = %d") ,iMinDeliverErroneousSDU)); |
|
514 LOG(Log::Printf(_L("\tiMinAcceptableMaxSDUSize = %d") ,iMinAcceptableMaxSDUSize)); |
|
515 LOG(Log::Printf(_L("\tiMinAcceptableMaxRate.iUplinkRate = %d"),iMinAcceptableMaxRate.iUplinkRate)); |
|
516 LOG(Log::Printf(_L("\tiMinAcceptableMaxRate.iDownlinkRate= %d"),iMinAcceptableMaxRate.iDownlinkRate)); |
|
517 LOG(Log::Printf(_L("\tiMaxBER = %d"), iMaxBER)); |
|
518 LOG(Log::Printf(_L("\tiMaxSDUErrorRatio = %d"), iMaxSDUErrorRatio)); |
|
519 LOG(Log::Printf(_L("\tiMinTrafficHandlingPriority = %d"),iMinTrafficHandlingPriority)); |
|
520 LOG(Log::Printf(_L("\tiMaxTransferDelay = %d"), iMaxTransferDelay)); |
|
521 LOG(Log::Printf(_L("\tiMinGuaranteedRate.iUplinkRate = %d"),iMinGuaranteedRate.iUplinkRate)); |
|
522 LOG(Log::Printf(_L("\tiMinGuaranteedRate.iDownlinkRate = %d"),iMinGuaranteedRate.iDownlinkRate)); |
|
523 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
524 LOG(Log::Printf(_L("\tiSignallingIndication = %d"),iSignallingIndication)); |
|
525 LOG(Log::Printf(_L("\tiSourceStatisticsDescriptor = %d"),iSourceStatisticsDescriptor)); |
|
526 #endif // SYMBIAN_NETWORKING_UMTSR5 |
|
527 |
|
528 } |
|
529 |
|
530 void ParameterMapper::MapGenericToRel99(const TQoSParameters& aSpec, RPacketQoS::TQoSR99_R4Requested& aGprs) |
|
531 { |
|
532 // |
|
533 // Traffic class |
|
534 // |
|
535 if ((aSpec.GetUpLinkDelay() < 250 && aSpec.GetUpLinkDelay() > 0) || |
|
536 (aSpec.GetDownLinkDelay() < 250 && aSpec.GetDownLinkDelay() > 0)) |
|
537 aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassConversational; |
|
538 else if (aSpec.GetUpLinkDelay() >= 250 || aSpec.GetDownLinkDelay() >= 250) |
|
539 aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassStreaming; |
|
540 else if ((aSpec.GetUpLinkPriority() >= 0 && aSpec.GetUpLinkPriority() <= 2) || |
|
541 (aSpec.GetDownLinkPriority() >= 0 && aSpec.GetDownLinkPriority() <= 2)) |
|
542 aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassInteractive; |
|
543 else |
|
544 aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassBackground; |
|
545 |
|
546 aGprs.iMinTrafficClass = aGprs.iReqTrafficClass; |
|
547 |
|
548 // |
|
549 // Delivery order |
|
550 // |
|
551 aGprs.iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; |
|
552 aGprs.iMinDeliveryOrderReqd = aGprs.iReqDeliveryOrderReqd; |
|
553 |
|
554 // |
|
555 // Delivery of erroneous SDUs |
|
556 // |
|
557 aGprs.iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; |
|
558 aGprs.iMinDeliverErroneousSDU = aGprs.iReqDeliverErroneousSDU; |
|
559 |
|
560 // |
|
561 // Residual BER |
|
562 // |
|
563 aGprs.iReqBER = RPacketQoS::EBERUnspecified; |
|
564 aGprs.iMaxBER = aGprs.iReqBER; |
|
565 |
|
566 // |
|
567 // SDU error ratio |
|
568 // |
|
569 aGprs.iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; |
|
570 aGprs.iMaxSDUErrorRatio = aGprs.iReqSDUErrorRatio; |
|
571 |
|
572 // |
|
573 // Traffic handling priority |
|
574 // |
|
575 if (aGprs.iReqTrafficClass == RPacketQoS::ETrafficClassInteractive) |
|
576 { |
|
577 if (aSpec.GetUpLinkPriority() == 0 || aSpec.GetDownLinkPriority() == 0) |
|
578 aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
579 else if (aSpec.GetUpLinkPriority() == 1 || aSpec.GetDownLinkPriority() == 1) |
|
580 aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; |
|
581 else |
|
582 aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; |
|
583 } |
|
584 else |
|
585 { |
|
586 aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; |
|
587 } |
|
588 |
|
589 aGprs.iMinTrafficHandlingPriority = aGprs.iReqTrafficHandlingPriority; |
|
590 |
|
591 // |
|
592 // Transfer delay |
|
593 // |
|
594 aGprs.iReqTransferDelay = ParameterMapper::Min(aSpec.GetUpLinkDelay(), aSpec.GetDownLinkDelay()); |
|
595 aGprs.iMaxTransferDelay = aGprs.iReqTransferDelay; |
|
596 |
|
597 // |
|
598 // Maximum SDU size |
|
599 // |
|
600 aGprs.iReqMaxSDUSize = aSpec.GetUpLinkMaximumPacketSize(); |
|
601 aGprs.iMinAcceptableMaxSDUSize = aGprs.iReqMaxSDUSize; |
|
602 |
|
603 // |
|
604 // Maximum bitrate |
|
605 // |
|
606 aGprs.iReqMaxRate.iUplinkRate = aSpec.GetUplinkBandwidth(); |
|
607 aGprs.iReqMaxRate.iDownlinkRate = aSpec.GetDownlinkBandwidth(); |
|
608 |
|
609 // |
|
610 // Guaranteed bitrate |
|
611 // |
|
612 aGprs.iReqGuaranteedRate.iUplinkRate = aSpec.GetUplinkBandwidth(); |
|
613 aGprs.iReqGuaranteedRate.iDownlinkRate = aSpec.GetDownlinkBandwidth(); |
|
614 } |
|
615 |
|
616 |
|
617 TInt ParameterMapper::CombineParameters(const RPacketQoS::TQoSR99_R4Requested& aGprs, TQoSParameters& aFlowSpec) |
|
618 { |
|
619 if (aGprs.iReqGuaranteedRate.iUplinkRate > 0) |
|
620 aFlowSpec.SetUplinkBandwidth(aGprs.iReqGuaranteedRate.iUplinkRate); |
|
621 if (aGprs.iReqGuaranteedRate.iDownlinkRate > 0) |
|
622 aFlowSpec.SetDownlinkBandwidth(aGprs.iReqGuaranteedRate.iDownlinkRate); |
|
623 |
|
624 return KErrNone; |
|
625 } |
|
626 |
|
627 |
|
628 void ParameterMapper::CombineDefault(const TQoSRequested& aDefault, TQoSRequested& aPolicy) |
|
629 { |
|
630 if (aPolicy.iReqTrafficClass == RPacketQoS::ETrafficClassUnspecified) |
|
631 aPolicy.iReqTrafficClass = aDefault.iReqTrafficClass; |
|
632 if (aPolicy.iMinTrafficClass == RPacketQoS::ETrafficClassUnspecified) |
|
633 aPolicy.iMinTrafficClass = aDefault.iMinTrafficClass; |
|
634 if (aPolicy.iReqDeliveryOrderReqd == RPacketQoS::EDeliveryOrderUnspecified) |
|
635 aPolicy.iReqDeliveryOrderReqd = aDefault.iReqDeliveryOrderReqd; |
|
636 if (aPolicy.iMinDeliveryOrderReqd == RPacketQoS::EDeliveryOrderUnspecified) |
|
637 aPolicy.iMinDeliveryOrderReqd = aDefault.iMinDeliveryOrderReqd; |
|
638 if (aPolicy.iReqDeliverErroneousSDU == RPacketQoS::EErroneousSDUDeliveryUnspecified) |
|
639 aPolicy.iReqDeliverErroneousSDU = aDefault.iReqDeliverErroneousSDU; |
|
640 if (aPolicy.iMinDeliverErroneousSDU == RPacketQoS::EErroneousSDUDeliveryUnspecified) |
|
641 aPolicy.iMinDeliverErroneousSDU = aDefault.iMinDeliverErroneousSDU; |
|
642 if (aPolicy.iReqMaxSDUSize == 0) |
|
643 aPolicy.iReqMaxSDUSize = aDefault.iReqMaxSDUSize; |
|
644 if (aPolicy.iMinAcceptableMaxSDUSize == 0) |
|
645 aPolicy.iMinAcceptableMaxSDUSize = aDefault.iMinAcceptableMaxSDUSize; |
|
646 if (aPolicy.iReqMaxRate.iUplinkRate == 0) |
|
647 aPolicy.iReqMaxRate.iUplinkRate = aDefault.iReqMaxRate.iUplinkRate; |
|
648 if (aPolicy.iReqMaxRate.iDownlinkRate == 0) |
|
649 aPolicy.iReqMaxRate.iDownlinkRate = aDefault.iReqMaxRate.iDownlinkRate; |
|
650 if (aPolicy.iMinAcceptableMaxRate.iUplinkRate == 0) |
|
651 aPolicy.iMinAcceptableMaxRate.iUplinkRate = aDefault.iMinAcceptableMaxRate.iUplinkRate; |
|
652 if (aPolicy.iMinAcceptableMaxRate.iDownlinkRate == 0) |
|
653 aPolicy.iMinAcceptableMaxRate.iDownlinkRate = aDefault.iMinAcceptableMaxRate.iDownlinkRate; |
|
654 if (aPolicy.iReqBER == RPacketQoS::EBERUnspecified) |
|
655 aPolicy.iReqBER = aDefault.iReqBER; |
|
656 if (aPolicy.iMaxBER == RPacketQoS::EBERUnspecified) |
|
657 aPolicy.iMaxBER = aDefault.iMaxBER; |
|
658 if (aPolicy.iReqSDUErrorRatio == RPacketQoS::ESDUErrorRatioUnspecified) |
|
659 aPolicy.iReqSDUErrorRatio = aDefault.iReqSDUErrorRatio; |
|
660 if (aPolicy.iMaxSDUErrorRatio == RPacketQoS::ESDUErrorRatioUnspecified) |
|
661 aPolicy.iMaxSDUErrorRatio = aDefault.iMaxSDUErrorRatio; |
|
662 if (aPolicy.iReqTrafficHandlingPriority == RPacketQoS::ETrafficPriorityUnspecified) |
|
663 aPolicy.iReqTrafficHandlingPriority = aDefault.iReqTrafficHandlingPriority; |
|
664 if (aPolicy.iMinTrafficHandlingPriority == RPacketQoS::ETrafficPriorityUnspecified) |
|
665 aPolicy.iMinTrafficHandlingPriority = aDefault.iMinTrafficHandlingPriority; |
|
666 if (aPolicy.iReqTransferDelay == 0) |
|
667 aPolicy.iReqTransferDelay = aDefault.iReqTransferDelay; |
|
668 if (aPolicy.iMaxTransferDelay == 0) |
|
669 aPolicy.iMaxTransferDelay = aDefault.iMaxTransferDelay; |
|
670 if (aPolicy.iReqGuaranteedRate.iUplinkRate == 0) |
|
671 aPolicy.iReqGuaranteedRate.iUplinkRate = aDefault.iReqGuaranteedRate.iUplinkRate; |
|
672 if (aPolicy.iReqGuaranteedRate.iDownlinkRate == 0) |
|
673 aPolicy.iReqGuaranteedRate.iDownlinkRate = aDefault.iReqGuaranteedRate.iDownlinkRate; |
|
674 if (aPolicy.iMinGuaranteedRate.iUplinkRate == 0) |
|
675 aPolicy.iMinGuaranteedRate.iUplinkRate = aDefault.iMinGuaranteedRate.iUplinkRate; |
|
676 if (aPolicy.iMinGuaranteedRate.iDownlinkRate == 0) |
|
677 aPolicy.iMinGuaranteedRate.iDownlinkRate = aDefault.iMinGuaranteedRate.iDownlinkRate; |
|
678 } |
|
679 |
|
680 |
|
681 void ParameterMapper::CombineOverride(const TQoSRequested& aOverride, TQoSRequested& aPolicy) |
|
682 { |
|
683 if (aOverride.iReqTrafficClass != RPacketQoS::ETrafficClassUnspecified) |
|
684 aPolicy.iReqTrafficClass = aOverride.iReqTrafficClass; |
|
685 if (aOverride.iMinTrafficClass != RPacketQoS::ETrafficClassUnspecified) |
|
686 aPolicy.iMinTrafficClass = aOverride.iMinTrafficClass; |
|
687 if (aOverride.iReqDeliveryOrderReqd != RPacketQoS::EDeliveryOrderUnspecified) |
|
688 aPolicy.iReqDeliveryOrderReqd = aOverride.iReqDeliveryOrderReqd; |
|
689 if (aOverride.iMinDeliveryOrderReqd != RPacketQoS::EDeliveryOrderUnspecified) |
|
690 aPolicy.iMinDeliveryOrderReqd = aOverride.iMinDeliveryOrderReqd; |
|
691 if (aOverride.iReqDeliverErroneousSDU != RPacketQoS::EErroneousSDUDeliveryUnspecified) |
|
692 aPolicy.iReqDeliverErroneousSDU = aOverride.iReqDeliverErroneousSDU; |
|
693 if (aOverride.iMinDeliverErroneousSDU != RPacketQoS::EErroneousSDUDeliveryUnspecified) |
|
694 aPolicy.iMinDeliverErroneousSDU = aOverride.iMinDeliverErroneousSDU; |
|
695 if (aOverride.iReqMaxSDUSize > 0) |
|
696 aPolicy.iReqMaxSDUSize = aOverride.iReqMaxSDUSize; |
|
697 if (aOverride.iMinAcceptableMaxSDUSize > 0) |
|
698 aPolicy.iMinAcceptableMaxSDUSize = aOverride.iMinAcceptableMaxSDUSize; |
|
699 if (aOverride.iReqMaxRate.iUplinkRate > 0) |
|
700 aPolicy.iReqMaxRate.iUplinkRate = aOverride.iReqMaxRate.iUplinkRate; |
|
701 if (aOverride.iReqMaxRate.iDownlinkRate > 0) |
|
702 aPolicy.iReqMaxRate.iDownlinkRate = aOverride.iReqMaxRate.iDownlinkRate; |
|
703 if (aOverride.iMinAcceptableMaxRate.iUplinkRate > 0) |
|
704 aPolicy.iMinAcceptableMaxRate.iUplinkRate = aOverride.iMinAcceptableMaxRate.iUplinkRate; |
|
705 if (aOverride.iMinAcceptableMaxRate.iDownlinkRate > 0) |
|
706 aPolicy.iMinAcceptableMaxRate.iDownlinkRate = aOverride.iMinAcceptableMaxRate.iDownlinkRate; |
|
707 if (aOverride.iReqBER != RPacketQoS::EBERUnspecified) |
|
708 aPolicy.iReqBER = aOverride.iReqBER; |
|
709 if (aOverride.iMaxBER != RPacketQoS::EBERUnspecified) |
|
710 aPolicy.iMaxBER = aOverride.iMaxBER; |
|
711 if (aOverride.iReqSDUErrorRatio != RPacketQoS::ESDUErrorRatioUnspecified) |
|
712 aPolicy.iReqSDUErrorRatio = aOverride.iReqSDUErrorRatio; |
|
713 if (aOverride.iMaxSDUErrorRatio != RPacketQoS::ESDUErrorRatioUnspecified) |
|
714 aPolicy.iMaxSDUErrorRatio = aOverride.iMaxSDUErrorRatio; |
|
715 if (aOverride.iReqTrafficHandlingPriority != RPacketQoS::ETrafficPriorityUnspecified) |
|
716 aPolicy.iReqTrafficHandlingPriority = aOverride.iReqTrafficHandlingPriority; |
|
717 if (aOverride.iMinTrafficHandlingPriority != RPacketQoS::ETrafficPriorityUnspecified) |
|
718 aPolicy.iMinTrafficHandlingPriority = aOverride.iMinTrafficHandlingPriority; |
|
719 if (aOverride.iReqTransferDelay > 0) |
|
720 aPolicy.iReqTransferDelay = aOverride.iReqTransferDelay; |
|
721 if (aOverride.iMaxTransferDelay > 0) |
|
722 aPolicy.iMaxTransferDelay = aOverride.iMaxTransferDelay; |
|
723 if (aOverride.iReqGuaranteedRate.iUplinkRate > 0) |
|
724 aPolicy.iReqGuaranteedRate.iUplinkRate = aOverride.iReqGuaranteedRate.iUplinkRate; |
|
725 if (aOverride.iReqGuaranteedRate.iDownlinkRate > 0) |
|
726 aPolicy.iReqGuaranteedRate.iDownlinkRate = aOverride.iReqGuaranteedRate.iDownlinkRate; |
|
727 if (aOverride.iMinGuaranteedRate.iUplinkRate > 0) |
|
728 aPolicy.iMinGuaranteedRate.iUplinkRate = aOverride.iMinGuaranteedRate.iUplinkRate; |
|
729 if (aOverride.iMinGuaranteedRate.iDownlinkRate > 0) |
|
730 aPolicy.iMinGuaranteedRate.iDownlinkRate = aOverride.iMinGuaranteedRate.iDownlinkRate; |
|
731 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
732 if (aOverride.iSignallingIndication == 0 && aOverride.iReqTrafficClass == RPacketQoS::ETrafficClassInteractive ) |
|
733 aPolicy.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; |
|
734 #endif // SYMBIAN_NETWORKING_UMTSR5 |
|
735 aPolicy.iHeaderCompression = aOverride.iHeaderCompression; |
|
736 #ifdef SYMBIAN_NETWORKING_UMTSR5 |
|
737 aPolicy.iSignallingIndication = aOverride.iSignallingIndication; |
|
738 aPolicy.iSourceStatisticsDescriptor =aOverride.iSourceStatisticsDescriptor; |
|
739 #endif // SYMBIAN_NETWORKING_UMTSR5 |
|
740 } |
|
741 |
|
742 // if SBLP presents, this method will return ETrue |
|
743 TBool RFlowExtensionParams::ParsePolicyDataForSblp( CExtensionPolicy * aExtensionPolicy ) |
|
744 { |
|
745 TBool retValue = EFalse; |
|
746 |
|
747 TExtensionQueueIter i(aExtensionPolicy->Extensions()); |
|
748 CExtension* extension; |
|
749 while ((extension = i++) != NULL) |
|
750 { |
|
751 if (extension->Type() != STATIC_CAST(TUint, KPfqosExtensionSBLP)) |
|
752 continue; |
|
753 |
|
754 LOG(Log::Printf(_L(""))); |
|
755 LOG(Log::Printf(_L("PARSED SBLP VALUES"))); |
|
756 |
|
757 // KPfqosExtensionSBLP presents! so return ETrue |
|
758 retValue = ETrue; |
|
759 |
|
760 TVariableQueueIter iter(extension->Queue()); |
|
761 TVariableBase *var; |
|
762 |
|
763 TUint16 mediaComponentNumberCount = 0; |
|
764 TUint16 ipFlowNumberCount = 0; |
|
765 RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier flowIdTemp; |
|
766 |
|
767 while ((var = iter++) != NULL) |
|
768 { |
|
769 switch (var->Type()) |
|
770 { |
|
771 case KPfqosTypeInteger: |
|
772 { |
|
773 TIntVariable* tmp = (TIntVariable*) var; |
|
774 //lint -e{961} would want terminating 'else' (but we don't?) |
|
775 if (tmp->Name().Compare(KDescSblpMediaComponentNumber)==0) |
|
776 { |
|
777 TInt value = tmp->Value(); |
|
778 flowIdTemp.iMediaComponentNumber = static_cast<TUint16>(value); |
|
779 LOG(Log::Printf(_L("\tMedia component number = %d"),flowIdTemp.iMediaComponentNumber)); |
|
780 mediaComponentNumberCount++; |
|
781 } |
|
782 else if (tmp->Name().Compare(KDescSblpIPFlowNumber)==0) |
|
783 { |
|
784 TInt value = tmp->Value(); |
|
785 flowIdTemp.iIPFlowNumber = static_cast<TUint16>(value); |
|
786 LOG(Log::Printf(_L("\tIP flow number = %d"),flowIdTemp.iIPFlowNumber)); |
|
787 ipFlowNumberCount++; |
|
788 |
|
789 if(mediaComponentNumberCount == ipFlowNumberCount) |
|
790 { |
|
791 iFlowIds.Append(flowIdTemp); |
|
792 } |
|
793 } |
|
794 } |
|
795 break; |
|
796 |
|
797 case KPfqosTypeString: |
|
798 { |
|
799 TStringVariable* stringVar = (TStringVariable*) var; |
|
800 if (stringVar->Name().Compare(KDescSblpMediaAuthorizationToken)==0) |
|
801 { |
|
802 //TBuf<KMatSize> strValue = stringVar->Value(); |
|
803 iAuthorizationToken.Copy(stringVar->Value()); |
|
804 LOG(Log::Printf(_L("\tMAT string = '%S'"), &stringVar->Value())); |
|
805 } |
|
806 } |
|
807 break; |
|
808 |
|
809 default: |
|
810 break; |
|
811 } |
|
812 } |
|
813 } |
|
814 return retValue; |
|
815 } |
|
816 |
|
817 //lint -e{1927} would like to use initializer list |
|
818 RFlowExtensionParams::RFlowExtensionParams() |
|
819 { |
|
820 } |
|
821 |
|
822 RFlowExtensionParams& RFlowExtensionParams::operator=(const RFlowExtensionParams& aFlowExtParam) |
|
823 { |
|
824 // NOP, if assigned to self |
|
825 if (this != &aFlowExtParam) |
|
826 { |
|
827 iAuthorizationToken.Copy(aFlowExtParam.iAuthorizationToken); |
|
828 iFlowIds.Reset(); |
|
829 for(TInt i=0; i<aFlowExtParam.iFlowIds.Count();i++) |
|
830 { |
|
831 iFlowIds.Append(aFlowExtParam.iFlowIds[i]); |
|
832 } |
|
833 } |
|
834 return *this; |
|
835 } |
|
836 |
|
837 RFlowExtensionParams::~RFlowExtensionParams() |
|
838 { |
|
839 iFlowIds.Close(); |
|
840 } |