|
1 /* |
|
2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: DM tree etc. |
|
15 * |
|
16 */ |
|
17 |
|
18 #include "nsmldmcommandbuffer.h" |
|
19 #include "nsmldmtreeconstants.h" |
|
20 #include "nsmldmddf.h" |
|
21 #include "nsmldmuri.h" |
|
22 |
|
23 |
|
24 // =========================================================================== |
|
25 // CNSmlDmCommandBuffer |
|
26 // =========================================================================== |
|
27 |
|
28 // --------------------------------------------------------------------------- |
|
29 // CNSmlDmCommandBuffer::~CNSmlDmCommandBuffer() |
|
30 // --------------------------------------------------------------------------- |
|
31 CNSmlDmCommandBuffer::~CNSmlDmCommandBuffer() |
|
32 { |
|
33 if(iCommandBuffer !=0 ) |
|
34 { |
|
35 CNSmlDmCommands* tmp=iCommandBuffer; |
|
36 while(tmp!=0) |
|
37 { |
|
38 tmp=iCommandBuffer->iNext; |
|
39 delete iCommandBuffer; |
|
40 iCommandBuffer = tmp; |
|
41 } |
|
42 } |
|
43 } |
|
44 |
|
45 // --------------------------------------------------------------------------- |
|
46 // CNSmlDmCommandBuffer::CNSmlDmCommandBuffer() |
|
47 // --------------------------------------------------------------------------- |
|
48 CNSmlDmCommandBuffer::CNSmlDmCommandBuffer(CNSmlDmModule& aDmModule) |
|
49 :iDmModule(aDmModule) |
|
50 { |
|
51 } |
|
52 |
|
53 // --------------------------------------------------------------------------- |
|
54 // CNSmlDmCommandBuffer* CNSmlDmCommandBuffer::NewL() |
|
55 // --------------------------------------------------------------------------- |
|
56 CNSmlDmCommandBuffer* CNSmlDmCommandBuffer::NewL(CNSmlDmModule& aDmModule) |
|
57 { |
|
58 CNSmlDmCommandBuffer* self = new (ELeave) CNSmlDmCommandBuffer(aDmModule); |
|
59 return self; |
|
60 } |
|
61 |
|
62 |
|
63 // --------------------------------------------------------------------------- |
|
64 // CNSmlDmCommandBuffer::AddObjectL() |
|
65 // Adds an Add command to the command buffer. The command is executed |
|
66 // in Commit |
|
67 // --------------------------------------------------------------------------- |
|
68 void CNSmlDmCommandBuffer::AddObjectL(const TDesC8& aURI, |
|
69 const TDesC8& aObject, |
|
70 const TDesC8& aType, |
|
71 TInt aStatusRef ) |
|
72 { |
|
73 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
74 CleanupStack::PushL(cmd); |
|
75 |
|
76 cmd->iURI = aURI.AllocL(); |
|
77 cmd->iObject = aObject.AllocL(); |
|
78 cmd->iType = aType.AllocL(); |
|
79 cmd->iStatusRef = aStatusRef; |
|
80 cmd->iCmdType = EAclAdd; |
|
81 |
|
82 if(iCommandBuffer==0) |
|
83 { |
|
84 iCommandBuffer = cmd; |
|
85 } |
|
86 else |
|
87 { |
|
88 CNSmlDmCommands* tmp=iCommandBuffer; |
|
89 while(tmp->iNext!=0) |
|
90 { |
|
91 tmp=tmp->iNext; |
|
92 } |
|
93 tmp->iNext = cmd; |
|
94 } |
|
95 CleanupStack::Pop(); //cmd |
|
96 } |
|
97 |
|
98 // --------------------------------------------------------------------------- |
|
99 // CNSmlDmCommandBuffer::UpdateObjectL() |
|
100 // Adds an Update command to the command buffer. The command is executed |
|
101 // in Commit |
|
102 // --------------------------------------------------------------------------- |
|
103 void CNSmlDmCommandBuffer::UpdateObjectL( const TDesC8& aURI, |
|
104 const TDesC8& aObject, |
|
105 const TDesC8& aType, |
|
106 TInt aStatusRef) |
|
107 { |
|
108 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
109 CleanupStack::PushL(cmd); |
|
110 |
|
111 cmd->iURI = aURI.AllocL(); |
|
112 cmd->iObject = aObject.AllocL(); |
|
113 cmd->iType = aType.AllocL(); |
|
114 cmd->iStatusRef = aStatusRef; |
|
115 cmd->iCmdType = EAclReplace; |
|
116 |
|
117 if(iCommandBuffer==0) |
|
118 { |
|
119 iCommandBuffer = cmd; |
|
120 } |
|
121 else |
|
122 { |
|
123 CNSmlDmCommands* tmp=iCommandBuffer; |
|
124 while(tmp->iNext!=0) |
|
125 { |
|
126 tmp=tmp->iNext; |
|
127 } |
|
128 tmp->iNext = cmd; |
|
129 } |
|
130 CleanupStack::Pop(); |
|
131 } |
|
132 |
|
133 |
|
134 // --------------------------------------------------------------------------- |
|
135 // CNSmlDmCommandBuffer::FetchObjectL() |
|
136 // Adds an Fetch command to the command buffer. The command is executed in Commit |
|
137 // --------------------------------------------------------------------------- |
|
138 void CNSmlDmCommandBuffer::FetchObjectL(const TDesC8& aURI, |
|
139 const TDesC8& aType, |
|
140 TInt aResultsRef, |
|
141 TInt aStatusRef ) |
|
142 { |
|
143 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
144 CleanupStack::PushL(cmd); |
|
145 |
|
146 cmd->iURI = aURI.AllocL(); |
|
147 cmd->iType = aType.AllocL(); |
|
148 cmd->iStatusRef = aStatusRef; |
|
149 cmd->iCmdType = EAclGet; |
|
150 cmd->iResultsRef = aResultsRef; |
|
151 |
|
152 if(iCommandBuffer==0) |
|
153 { |
|
154 iCommandBuffer = cmd; |
|
155 } |
|
156 else |
|
157 { |
|
158 CNSmlDmCommands* tmp=iCommandBuffer; |
|
159 while(tmp->iNext!=0) |
|
160 { |
|
161 tmp=tmp->iNext; |
|
162 } |
|
163 tmp->iNext = cmd; |
|
164 } |
|
165 CleanupStack::Pop(); //cmd |
|
166 } |
|
167 |
|
168 // --------------------------------------------------------------------------- |
|
169 // CNSmlDmCommandBuffer::DeleteObjectL() |
|
170 // Adds an Delete command to the command buffer. The command is executed |
|
171 // in Commit |
|
172 // --------------------------------------------------------------------------- |
|
173 void CNSmlDmCommandBuffer::DeleteObjectL( const TDesC8& aURI, TInt aStatusRef) |
|
174 { |
|
175 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
176 CleanupStack::PushL(cmd); |
|
177 |
|
178 cmd->iURI = aURI.AllocL(); |
|
179 cmd->iStatusRef = aStatusRef; |
|
180 cmd->iCmdType = EAclDelete; |
|
181 |
|
182 if(iCommandBuffer==0) |
|
183 { |
|
184 iCommandBuffer = cmd; |
|
185 } |
|
186 else |
|
187 { |
|
188 CNSmlDmCommands* tmp=iCommandBuffer; |
|
189 while(tmp->iNext!=0) |
|
190 { |
|
191 tmp=tmp->iNext; |
|
192 } |
|
193 tmp->iNext = cmd; |
|
194 } |
|
195 CleanupStack::Pop(); //cmd |
|
196 } |
|
197 |
|
198 |
|
199 // --------------------------------------------------------------------------- |
|
200 // CNSmlDmCommandBuffer::ExecuteObjectL() |
|
201 // Adds an Execute command to the command buffer. The command is executed |
|
202 // in Commit |
|
203 // --------------------------------------------------------------------------- |
|
204 void CNSmlDmCommandBuffer::ExecuteObjectL( const TDesC8& aURI, |
|
205 const TDesC8& aObject, |
|
206 const TDesC8& aType, |
|
207 TInt aStatusRef) |
|
208 { |
|
209 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
210 CleanupStack::PushL(cmd); |
|
211 |
|
212 cmd->iURI = aURI.AllocL(); |
|
213 cmd->iObject = aObject.AllocL(); |
|
214 cmd->iType = aType.AllocL(); |
|
215 cmd->iStatusRef = aStatusRef; |
|
216 cmd->iCmdType = EAclExecute; |
|
217 |
|
218 if(iCommandBuffer==0) |
|
219 { |
|
220 iCommandBuffer = cmd; |
|
221 } |
|
222 else |
|
223 { |
|
224 CNSmlDmCommands* tmp=iCommandBuffer; |
|
225 while(tmp->iNext!=0) |
|
226 { |
|
227 tmp=tmp->iNext; |
|
228 } |
|
229 tmp->iNext = cmd; |
|
230 } |
|
231 CleanupStack::Pop(); //cmd |
|
232 } |
|
233 |
|
234 // --------------------------------------------------------------------------- |
|
235 // CNSmlDmCommandBuffer::CopyObjectL() |
|
236 // Adds an Copy command to the command buffer. The command is executed |
|
237 // in Commit |
|
238 // --------------------------------------------------------------------------- |
|
239 void CNSmlDmCommandBuffer::CopyObjectL( const TDesC8& aTargetURI, |
|
240 const TDesC8& aSourceURI, |
|
241 const TDesC8& aType, |
|
242 TInt aStatusRef) |
|
243 { |
|
244 CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands; |
|
245 CleanupStack::PushL(cmd); |
|
246 |
|
247 cmd->iURI = aSourceURI.AllocL(); |
|
248 cmd->iTargetURI = aTargetURI.AllocL(); |
|
249 cmd->iType = aType.AllocL(); |
|
250 cmd->iStatusRef = aStatusRef; |
|
251 cmd->iCmdType = EAclCopy; |
|
252 |
|
253 if(iCommandBuffer==0) |
|
254 { |
|
255 iCommandBuffer = cmd; |
|
256 } |
|
257 else |
|
258 { |
|
259 CNSmlDmCommands* tmp=iCommandBuffer; |
|
260 while(tmp->iNext!=0) |
|
261 { |
|
262 tmp=tmp->iNext; |
|
263 } |
|
264 tmp->iNext = cmd; |
|
265 } |
|
266 CleanupStack::Pop(); //cmd |
|
267 } |
|
268 |
|
269 |
|
270 // --------------------------------------------------------------------------- |
|
271 // CNSmlDmCommandBuffer::IsGetWithAtomic() |
|
272 // Checks whether nested Get command is there inside atomic command |
|
273 // --------------------------------------------------------------------------- |
|
274 TBool CNSmlDmCommandBuffer::IsGetWithAtomic() |
|
275 { TBool isget(EFalse); |
|
276 TInt isnested = -1; |
|
277 CNSmlDmCommands* cmd=iCommandBuffer; |
|
278 |
|
279 while(cmd !=0) |
|
280 { |
|
281 if(cmd->iCmdType == EAclGet) |
|
282 { |
|
283 |
|
284 isget =ETrue; |
|
285 } |
|
286 isnested++; |
|
287 |
|
288 cmd=cmd->iNext; |
|
289 } |
|
290 if(isnested > 0 && isget) |
|
291 { |
|
292 return ETrue; |
|
293 } |
|
294 |
|
295 |
|
296 return EFalse; |
|
297 |
|
298 } |
|
299 // --------------------------------------------------------------------------- |
|
300 // CNSmlDmCommandBuffer::CommitL() |
|
301 // Executes the commands in commandbuffer. If some of commands fails, |
|
302 // the rest of commands are deleted without execution |
|
303 // (NotExecuted status is returned) |
|
304 // --------------------------------------------------------------------------- |
|
305 void CNSmlDmCommandBuffer::CommitL( CNSmlDmDDF& aDDF ) |
|
306 { |
|
307 aDDF.StartAtomicL(); |
|
308 CNSmlDmCommands* cmd=iCommandBuffer; |
|
309 while(cmd!=0) |
|
310 { |
|
311 if(!cmd->iGotStatus) |
|
312 { |
|
313 //check the access from the ddf (not acl) |
|
314 CNSmlDmDDF::TAccess access = aDDF.CheckURIL( |
|
315 NSmlDmURI::RemoveProp(cmd->iURI->Des()),cmd->iCmdType); |
|
316 |
|
317 if(access == CNSmlDmDDF::EOk ) //access ok |
|
318 { |
|
319 TInt offset = cmd->iURI->Find(KNSmlDmProperty); |
|
320 if(offset==KErrNotFound) //not property asked |
|
321 { |
|
322 switch(cmd->iCmdType) |
|
323 { |
|
324 case EAclAdd: |
|
325 aDDF.AddObjectL(*cmd->iURI,*cmd->iObject, |
|
326 *cmd->iType,cmd->iStatusRef); |
|
327 break; |
|
328 |
|
329 case EAclReplace: |
|
330 aDDF.UpdateObjectL(*cmd->iURI,*cmd->iObject, |
|
331 *cmd->iType,cmd->iStatusRef); |
|
332 break; |
|
333 |
|
334 case EAclGet: |
|
335 if(IsGetWithAtomic()) |
|
336 { |
|
337 cmd->iStatusCode = KNSmlDmStatusCommandFailed; |
|
338 cmd->iGotStatus = ETrue; |
|
339 } |
|
340 else |
|
341 aDDF.FetchObjectL(*cmd->iURI,*cmd->iType, |
|
342 cmd->iResultsRef,cmd->iStatusRef); |
|
343 break; |
|
344 |
|
345 case EAclDelete: |
|
346 aDDF.DeleteObjectL(*cmd->iURI,cmd->iStatusRef); |
|
347 break; |
|
348 |
|
349 case EAclExecute: |
|
350 // FOTA |
|
351 aDDF.ExecuteObjectL(*cmd->iURI,*cmd->iObject, |
|
352 *cmd->iType,cmd->iStatusRef, KNullDesC8); |
|
353 // FOTA end |
|
354 break; |
|
355 |
|
356 case EAclCopy: |
|
357 aDDF.CopyObjectL(*cmd->iTargetURI,*cmd->iURI, |
|
358 *cmd->iType,cmd->iStatusRef); |
|
359 break; |
|
360 default: |
|
361 User::Panic ( KNSmlTxtPanicDmModule, KErrArgument ); |
|
362 break; |
|
363 } |
|
364 } |
|
365 else //property |
|
366 { |
|
367 switch(cmd->iCmdType) |
|
368 { |
|
369 case EAclReplace: |
|
370 iDmModule.UpdatePropertyL(*cmd->iURI,*cmd->iObject, |
|
371 *cmd->iType,offset+KNSmlDmProperty().Length(), |
|
372 cmd->iStatusRef); |
|
373 break; |
|
374 |
|
375 case EAclGet: |
|
376 iDmModule.GetPropertyL(*cmd->iURI,*cmd->iType, |
|
377 KNSmlDmProperty().Length()+offset, |
|
378 cmd->iResultsRef,cmd->iStatusRef); |
|
379 break; |
|
380 |
|
381 default: |
|
382 cmd->iStatusCode = KNSmlDmStatusCommandNotAllowed; |
|
383 cmd->iGotStatus = ETrue; |
|
384 break; |
|
385 |
|
386 } |
|
387 |
|
388 } //end else |
|
389 } //end if(CheckURIL()) |
|
390 else if(access == CNSmlDmDDF::ENotAccess ) |
|
391 { |
|
392 cmd->iStatusCode = KNSmlDmStatusCommandNotAllowed; |
|
393 cmd->iGotStatus = ETrue; |
|
394 } |
|
395 else |
|
396 { |
|
397 SetStatus(cmd->iStatusRef,KNSmlDmStatusNotFound); |
|
398 } |
|
399 } |
|
400 cmd=cmd->iNext; |
|
401 } //end while |
|
402 aDDF.EndMessageL(); |
|
403 if(AtomicFailed()) |
|
404 { |
|
405 aDDF.RollbackAtomicL(); |
|
406 RollBackL(aDDF); |
|
407 } |
|
408 else |
|
409 { |
|
410 aDDF.CommitAtomicL(); |
|
411 } |
|
412 ChangeAtomicStatuses(); |
|
413 SendStatusAndResultCodesL(); |
|
414 } |
|
415 |
|
416 |
|
417 // --------------------------------------------------------------------------- |
|
418 // CNSmlDmCommandBuffer::RollBackL() |
|
419 // Returns status NotExecuted to the commands in commandbuffer |
|
420 // --------------------------------------------------------------------------- |
|
421 void CNSmlDmCommandBuffer::RollBackL(CNSmlDmDDF& aDDF) |
|
422 { |
|
423 CNSmlDmCommands* cmd=iCommandBuffer; |
|
424 TBool loopAgain = EFalse; |
|
425 while(cmd!=0) |
|
426 { |
|
427 if(cmd->iGotStatus && |
|
428 cmd->iStatusCode==KNSmlDmStatusOK && |
|
429 cmd->iURI->Find(KNSmlDmProperty)==KErrNotFound) |
|
430 { |
|
431 if(cmd->iCmdType==EAclAdd) |
|
432 { |
|
433 loopAgain=ETrue; |
|
434 delete cmd->iCallback; |
|
435 cmd->iCallback=0; |
|
436 cmd->iCallback = CNSmlDmLinkCallback::NewL(); |
|
437 iDmModule.DeleteInTransactionL(*cmd->iURI,cmd->iCallback); |
|
438 } |
|
439 if(cmd->iCmdType!=EAclGet) |
|
440 { |
|
441 cmd->iStatusCode = KNSmlDmStatusAtomicRollBackFailed; |
|
442 } |
|
443 } |
|
444 else if(cmd->iStatusCode != KNSmlDmStatusOK) |
|
445 { |
|
446 cmd->iStatusCode = KNSmlDmStatusCommandFailed; |
|
447 } |
|
448 cmd=cmd->iNext; |
|
449 } |
|
450 |
|
451 if(loopAgain) |
|
452 { |
|
453 cmd=iCommandBuffer; |
|
454 while(cmd!=0) |
|
455 { |
|
456 if(cmd->iCmdType==EAclAdd&&cmd->iCallback) |
|
457 { |
|
458 TInt status = cmd->iCallback->GetStatusL(); |
|
459 if(status==KNSmlDmStatusOK || ParentNodeDeletedL(*cmd->iURI) || |
|
460 (status==KNSmlDmStatusNotFound&& |
|
461 aDDF.CheckURIL(*cmd->iURI,EAclAdd)==CNSmlDmDDF::EOk) ) |
|
462 { |
|
463 cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK; |
|
464 } |
|
465 } |
|
466 else if(cmd->iCmdType==EAclReplace) |
|
467 { |
|
468 if(ParentNodeDeletedL(*cmd->iURI)) |
|
469 { |
|
470 cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK; |
|
471 } |
|
472 } |
|
473 cmd=cmd->iNext; |
|
474 } |
|
475 } |
|
476 } |
|
477 |
|
478 // --------------------------------------------------------------------------- |
|
479 // CNSmlDmCommandBuffer::ChangeAtomicStatuses() |
|
480 // Changes all statuses so that they matches to atomic statuses |
|
481 // --------------------------------------------------------------------------- |
|
482 void CNSmlDmCommandBuffer::ChangeAtomicStatuses() |
|
483 { |
|
484 CNSmlDmCommands* cmd=iCommandBuffer; |
|
485 |
|
486 if(iAtomicFailed) |
|
487 { |
|
488 while(cmd!=0) |
|
489 { |
|
490 if(cmd->iCmdType==EAclReplace && |
|
491 cmd->iURI->Find(KNSmlDmProperty) && |
|
492 cmd->iStatusCode == KNSmlDmStatusOK) |
|
493 { |
|
494 cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK; |
|
495 } |
|
496 if( cmd->iStatusCode<KNSmlDmStatusLargestOK) |
|
497 { |
|
498 cmd->iStatusCode = KNSmlDmStatusAtomicRollBackFailed; |
|
499 } |
|
500 |
|
501 cmd=cmd->iNext; |
|
502 } |
|
503 } |
|
504 } |
|
505 |
|
506 |
|
507 // --------------------------------------------------------------------------- |
|
508 // CNSmlDmCommandBuffer::CheckResultsRef() |
|
509 // Check if this fetch has came inside atomc |
|
510 // --------------------------------------------------------------------------- |
|
511 TBool CNSmlDmCommandBuffer::CheckResultsRef(TInt aResultsRef) |
|
512 { |
|
513 CNSmlDmCommands* cmd=iCommandBuffer; |
|
514 while(cmd!=0) |
|
515 { |
|
516 if(aResultsRef==cmd->iResultsRef) |
|
517 { |
|
518 return ETrue; |
|
519 } |
|
520 cmd=cmd->iNext; |
|
521 } |
|
522 return EFalse; |
|
523 } |
|
524 |
|
525 |
|
526 // --------------------------------------------------------------------------- |
|
527 // CNSmlDmCommandBuffer::CheckStatusRef() |
|
528 // Check if this command has came inside atomc |
|
529 // --------------------------------------------------------------------------- |
|
530 TBool CNSmlDmCommandBuffer::CheckStatusRef(TInt aStatusRef) |
|
531 { |
|
532 CNSmlDmCommands* cmd=iCommandBuffer; |
|
533 while(cmd!=0) |
|
534 { |
|
535 if(aStatusRef==cmd->iStatusRef) |
|
536 { |
|
537 return ETrue; |
|
538 } |
|
539 cmd=cmd->iNext; |
|
540 } |
|
541 return EFalse; |
|
542 } |
|
543 |
|
544 |
|
545 // --------------------------------------------------------------------------- |
|
546 // CNSmlDmCommandBuffer::SetResultsL( TInt aResultsRef, |
|
547 // const CBufBase& aObject, |
|
548 // const TDesC8& aType, |
|
549 // const TDesC8& aFormat ) |
|
550 // Set Results to buffer for later returning |
|
551 // --------------------------------------------------------------------------- |
|
552 void CNSmlDmCommandBuffer::SetResultsL( TInt aResultsRef, |
|
553 const CBufBase& aObject, |
|
554 const TDesC8& /*aType*/, |
|
555 const TDesC8& aFormat ) |
|
556 { |
|
557 CNSmlDmCommands* cmd=iCommandBuffer; |
|
558 while(cmd!=0) |
|
559 { |
|
560 if(aResultsRef==cmd->iResultsRef) |
|
561 { |
|
562 cmd->iFormat = aFormat.AllocL(); |
|
563 if(cmd->iResult) |
|
564 { |
|
565 cmd->iResult->Reset(); |
|
566 } |
|
567 else |
|
568 { |
|
569 cmd->iResult = CBufFlat::NewL(32); |
|
570 } |
|
571 cmd->iResult->InsertL(0,CONST_CAST(CBufBase&, aObject).Ptr(0), |
|
572 aObject.Size()); |
|
573 return; |
|
574 } |
|
575 cmd=cmd->iNext; |
|
576 } |
|
577 } |
|
578 |
|
579 // --------------------------------------------------------------------------- |
|
580 // CNSmlDmCommandBuffer::SetStatusL(TInt aStatusRef, TInt aStatusCode) |
|
581 // Set Status to buffer for later returning |
|
582 // --------------------------------------------------------------------------- |
|
583 void CNSmlDmCommandBuffer::SetStatus(TInt aStatusRef, TInt aStatusCode) |
|
584 { |
|
585 CNSmlDmCommands* cmd=iCommandBuffer; |
|
586 if(aStatusCode>KNSmlDmStatusLargestOK) |
|
587 { |
|
588 iAtomicFailed = ETrue; |
|
589 } |
|
590 while(cmd!=0) |
|
591 { |
|
592 if(iAtomicFailed&&!cmd->iGotStatus) |
|
593 { |
|
594 cmd->iGotStatus = ETrue; |
|
595 cmd->iStatusCode = KNSmlDmStatusNotExecuted; |
|
596 } |
|
597 if(aStatusRef==cmd->iStatusRef) |
|
598 { |
|
599 cmd->iGotStatus = ETrue; |
|
600 cmd->iStatusCode = aStatusCode; |
|
601 } |
|
602 cmd=cmd->iNext; |
|
603 } |
|
604 } |
|
605 |
|
606 // --------------------------------------------------------------------------- |
|
607 // CNSmlDmCommandBuffer::SendStatusAndResultCodesL() |
|
608 // Send the results and status codes from the buffer |
|
609 // --------------------------------------------------------------------------- |
|
610 void CNSmlDmCommandBuffer::SendStatusAndResultCodesL() |
|
611 { |
|
612 CNSmlDmCommands* cmd=iCommandBuffer; |
|
613 |
|
614 while(cmd!=0) |
|
615 { |
|
616 if(cmd->iCmdType==EAclGet && cmd->iStatusCode>0 && |
|
617 cmd->iStatusCode<KNSmlDmStatusLargestOK) |
|
618 { |
|
619 iDmModule.DoSetResultsL(cmd->iResultsRef,*cmd->iResult, |
|
620 *cmd->iType,*cmd->iFormat,cmd->iResult->Size(),ETrue); |
|
621 } |
|
622 iDmModule.DoSetStatusL(cmd->iStatusRef,cmd->iStatusCode,ETrue); |
|
623 cmd=cmd->iNext; |
|
624 } |
|
625 } |
|
626 |
|
627 // --------------------------------------------------------------------------- |
|
628 // CNSmlDmCommandBuffer::ParentNodeDeletedL() |
|
629 // Checks if parent node has been deleted |
|
630 // --------------------------------------------------------------------------- |
|
631 TBool CNSmlDmCommandBuffer::ParentNodeDeletedL(const TDesC8& aURI) |
|
632 { |
|
633 |
|
634 HBufC8* uri = NSmlDmURI::RemoveProp(aURI).AllocLC(); |
|
635 TPtr8 uriPtr = uri->Des(); |
|
636 |
|
637 while(uriPtr.Length()!=0) |
|
638 { |
|
639 |
|
640 CNSmlDmCommands* cmd=iCommandBuffer; |
|
641 |
|
642 while(cmd!=0) |
|
643 { |
|
644 if(cmd->iCallback&&cmd->iCallback->GetStatusL()==KNSmlDmStatusOK) |
|
645 { |
|
646 if(cmd->iURI->Compare(uriPtr)==0) |
|
647 { |
|
648 CleanupStack::PopAndDestroy(); //uri |
|
649 return ETrue; |
|
650 } |
|
651 } |
|
652 cmd=cmd->iNext; |
|
653 } |
|
654 uriPtr = NSmlDmURI::RemoveLastSeg(uriPtr); |
|
655 } |
|
656 CleanupStack::PopAndDestroy(); //uri |
|
657 return EFalse; |
|
658 } |
|
659 |
|
660 |
|
661 // --------------------------------------------------------------------------- |
|
662 // CNSmlDmCommandBuffer::AtomicFailed() |
|
663 // Checks if some command has failed or status missing inside the atomic |
|
664 // --------------------------------------------------------------------------- |
|
665 TBool CNSmlDmCommandBuffer::AtomicFailed() |
|
666 { |
|
667 |
|
668 TBool isnestedget = IsGetWithAtomic(); |
|
669 if(isnestedget) |
|
670 return ETrue; |
|
671 if(iAtomicFailed) |
|
672 { |
|
673 return ETrue; |
|
674 } |
|
675 else |
|
676 { |
|
677 CNSmlDmCommands* cmd=iCommandBuffer; |
|
678 while(cmd!=0) |
|
679 { |
|
680 if(!cmd->iGotStatus) |
|
681 { |
|
682 return ETrue; |
|
683 } |
|
684 cmd=cmd->iNext; |
|
685 } |
|
686 } |
|
687 return EFalse; |
|
688 } |
|
689 |
|
690 |
|
691 // --------------------------------------------------------------------------- |
|
692 // CNSmlDmCommands::CNSmlDmCommands |
|
693 // Constructor |
|
694 // --------------------------------------------------------------------------- |
|
695 CNSmlDmCommands::CNSmlDmCommands() |
|
696 { |
|
697 iStatusCode=KNSmlDmStatusNotExecuted; |
|
698 } |
|
699 |
|
700 // --------------------------------------------------------------------------- |
|
701 // CNSmlDmCommands::~CNSmlDmCommands |
|
702 // Destructor |
|
703 // --------------------------------------------------------------------------- |
|
704 CNSmlDmCommands::~CNSmlDmCommands() |
|
705 { |
|
706 delete iURI; |
|
707 delete iTargetURI; |
|
708 delete iResult; |
|
709 delete iObject; |
|
710 delete iType; |
|
711 delete iFormat; |
|
712 delete iCallback; |
|
713 } |
|
714 |