245 if ( iBufferOverFlow == EFalse ) |
240 if ( iBufferOverFlow == EFalse ) |
246 { |
241 { |
247 // ------------------------------------------------------------- |
242 // ------------------------------------------------------------- |
248 |
243 |
249 // Read search query from the message |
244 // Read search query from the message |
250 HBufC8* searchQuery = HBufC8::NewLC(KBufferMaxLen); |
245 CPsQuery* psQuery = ReadQueryLC( 0, aMessage ); |
251 |
|
252 TPtr8 searchQueryPtr(searchQuery->Des()); |
|
253 aMessage.ReadL(0, searchQueryPtr); |
|
254 |
|
255 // Stream over the buffer |
|
256 RDesReadStream searchQueryStream(searchQueryPtr); |
|
257 searchQueryStream.PushL(); |
|
258 |
|
259 // Query object |
|
260 CPsQuery* psQuery = CPsQuery::NewL(); |
|
261 |
|
262 psQuery->InternalizeL(searchQueryStream); |
|
263 |
|
264 // searchQueryStream, searchQuery |
|
265 CleanupStack::PopAndDestroy(2, searchQuery); |
|
266 |
246 |
267 // ------------------------------------------------------------- |
247 // ------------------------------------------------------------- |
|
248 |
|
249 RPointerArray<CPsClientData> searchResults; |
|
250 RPointerArray<CPsPattern> searchSeqs; |
|
251 |
|
252 iServer->PluginInterface()->PerformSearchL(*iSettings, |
|
253 *psQuery, |
|
254 searchResults, |
|
255 searchSeqs); |
|
256 CleanupStack::PopAndDestroy( psQuery ); |
268 |
257 |
269 // Dynamic data buffer |
258 // Dynamic data buffer |
270 CBufFlat* buf = CBufFlat::NewL(KBufferMaxLen); |
259 CBufFlat* buf = CBufFlat::NewL(KBufferMaxLen); |
271 CleanupStack::PushL(buf); |
260 CleanupStack::PushL(buf); |
272 |
261 |
273 // Stream over the buffer |
262 // Stream over the buffer |
274 RBufWriteStream stream(*buf); |
263 RBufWriteStream stream(*buf); |
275 stream.PushL(); |
264 stream.PushL(); |
276 |
265 |
277 RPointerArray<CPsClientData> searchResults; |
|
278 RPointerArray<CPsPattern> searchSeqs; |
|
279 |
|
280 |
|
281 iServer->PluginInterface()->PerformSearchL(*iSettings, |
|
282 *psQuery, |
|
283 searchResults, |
|
284 searchSeqs); |
|
285 |
|
286 // Write the number of contacts |
266 // Write the number of contacts |
287 stream.WriteInt32L(searchResults.Count()); |
267 stream.WriteInt32L(searchResults.Count()); |
288 |
268 |
289 // Write the contacts |
269 // Write the contacts |
290 for ( int i = 0; i < searchResults.Count(); i++ ) |
270 for ( TInt i = 0; i < searchResults.Count(); i++ ) |
291 { |
271 { |
292 searchResults[i]->ExternalizeL(stream); |
272 searchResults[i]->ExternalizeL(stream); |
293 } |
273 } |
294 |
274 |
295 // Write the number of char seqs |
275 // Write the number of char seqs |
296 stream.WriteInt32L(searchSeqs.Count()); |
276 stream.WriteInt32L(searchSeqs.Count()); |
297 |
277 |
298 // Write the seqs |
278 // Write the seqs |
299 for ( int j = 0; j < searchSeqs.Count(); j++ ) |
279 for ( TInt j = 0; j < searchSeqs.Count(); j++ ) |
300 { |
280 { |
301 searchSeqs[j]->ExternalizeL(stream); |
281 searchSeqs[j]->ExternalizeL(stream); |
302 } |
282 } |
303 |
283 |
304 // Cleanup |
284 // Cleanup |
305 searchResults.ResetAndDestroy(); |
285 searchResults.ResetAndDestroy(); |
306 searchSeqs.ResetAndDestroy(); |
286 searchSeqs.ResetAndDestroy(); |
307 delete psQuery; |
|
308 |
287 |
309 // Results are already packed in the stream |
288 // Results are already packed in the stream |
310 stream.CommitL(); |
289 stream.CommitL(); |
311 |
290 |
312 // Create a heap descriptor from the buffer |
291 // Create a heap descriptor from the buffer |
313 iDes = HBufC8::NewL(buf->Size()); |
292 delete iDes; |
314 TPtr8 ptr(iDes->Des()); |
293 iDes = NULL; |
315 buf->Read(0, ptr, buf->Size()); |
294 iDes = buf->Ptr(0).AllocL(); |
316 |
295 |
317 CleanupStack::PopAndDestroy(2, buf); // buf, stream |
296 CleanupStack::PopAndDestroy(2, buf); // buf, stream |
318 } |
297 } |
319 |
298 |
320 TInt rcevdBufferSize = aMessage.GetDesMaxLength(1); |
299 TInt rcevdBufferSize = aMessage.GetDesMaxLength(1); |
321 User::LeaveIfNull( iDes ); |
300 User::LeaveIfNull( iDes ); |
368 __LATENCY_MARK ( _L("CPcsSession::SearchInputL") ); |
347 __LATENCY_MARK ( _L("CPcsSession::SearchInputL") ); |
369 |
348 |
370 // ------------------------------------------------------------- |
349 // ------------------------------------------------------------- |
371 |
350 |
372 // Read search query from the message |
351 // Read search query from the message |
373 HBufC8* searchQuery = HBufC8::NewLC(KBufferMaxLen); |
352 CPsQuery* psQuery = ReadQueryLC( 0, aMessage ); |
374 |
|
375 TPtr8 searchQueryPtr(searchQuery->Des()); |
|
376 aMessage.ReadL(0, searchQueryPtr); |
|
377 |
|
378 // Stream over the buffer |
|
379 RDesReadStream searchQueryStream(searchQueryPtr); |
|
380 searchQueryStream.PushL(); |
|
381 |
|
382 // Query object |
|
383 CPsQuery* psQuery = CPsQuery::NewL(); |
|
384 psQuery->InternalizeL(searchQueryStream); |
|
385 |
|
386 // searchQueryStream, searchQuery |
|
387 CleanupStack::PopAndDestroy(2, searchQuery); |
|
388 |
353 |
389 // ------------------------------------------------------------- |
354 // ------------------------------------------------------------- |
390 |
355 |
391 // Read search data from the message |
356 // Read search data from the message |
392 HBufC8* searchData = HBufC8::NewLC(KBufferMaxLen); |
357 HBufC8* searchData = HBufC8::NewLC(KBufferMaxLen); |
403 TUint16 szData = searchDataStream.ReadUint16L(); |
368 TUint16 szData = searchDataStream.ReadUint16L(); |
404 HBufC* data = HBufC::NewL(searchDataStream, szData); |
369 HBufC* data = HBufC::NewL(searchDataStream, szData); |
405 |
370 |
406 // searchQueryStream, searchQuery |
371 // searchQueryStream, searchQuery |
407 CleanupStack::PopAndDestroy(2, searchData); |
372 CleanupStack::PopAndDestroy(2, searchData); |
|
373 CleanupStack::PushL( data ); |
408 |
374 |
409 // ------------------------------------------------------------- |
375 // ------------------------------------------------------------- |
410 |
|
411 // Dynamic data buffer |
|
412 CBufFlat* buf = CBufFlat::NewL(KBufferMaxLen); |
|
413 CleanupStack::PushL(buf); |
|
414 |
|
415 // Stream over the buffer |
|
416 RBufWriteStream stream(*buf); |
|
417 stream.PushL(); |
|
418 |
376 |
419 // To hold the matches |
377 // To hold the matches |
420 RPointerArray<TDesC> searchSeqs; |
378 RPointerArray<TDesC> searchSeqs; |
421 |
379 |
422 // To hold matched location |
380 // To hold matched location |
423 RArray<TPsMatchLocation> sequenceLoc; |
381 RArray<TPsMatchLocation> sequenceLoc; |
424 |
|
425 |
382 |
426 iServer->PluginInterface()->SearchInputL(*psQuery, |
383 iServer->PluginInterface()->SearchInputL(*psQuery, |
427 *data, |
384 *data, |
428 searchSeqs, |
385 searchSeqs, |
429 sequenceLoc); |
386 sequenceLoc); |
430 |
387 |
431 |
388 |
432 // Delete the search query and search data |
389 // Delete the search query and search data |
433 delete psQuery; |
390 CleanupStack::PopAndDestroy( data ); |
434 delete data; |
391 CleanupStack::PopAndDestroy( psQuery ); |
|
392 |
|
393 // --------- create write stream --------------------------- |
|
394 // Dynamic data buffer |
|
395 CBufFlat* buf = CBufFlat::NewL(KBufferMaxLen); |
|
396 CleanupStack::PushL(buf); |
|
397 |
|
398 // Stream over the buffer |
|
399 RBufWriteStream stream(*buf); |
|
400 stream.PushL(); |
435 |
401 |
436 // --------- write match sequence --------------------------- |
402 // --------- write match sequence --------------------------- |
437 // Write the number of match seqs |
403 // Write the number of match seqs |
438 stream.WriteUint16L(searchSeqs.Count()); |
404 stream.WriteUint16L(searchSeqs.Count()); |
439 |
405 |
440 // Write the matches |
406 // Write the matches |
441 for ( int j = 0; j < searchSeqs.Count(); j++ ) |
407 for ( TInt j = 0; j < searchSeqs.Count(); j++ ) |
442 { |
408 { |
443 TInt length = searchSeqs[j]->Length(); |
409 TInt length = searchSeqs[j]->Length(); |
444 |
410 |
445 // Write the char sequence length |
411 // Write the char sequence length |
446 stream.WriteUint16L(length); |
412 stream.WriteUint16L(length); |
474 sequenceLoc.Reset(); |
440 sequenceLoc.Reset(); |
475 sequenceLoc.Close(); |
441 sequenceLoc.Close(); |
476 |
442 |
477 stream.CommitL(); |
443 stream.CommitL(); |
478 |
444 |
479 // Create a heap descriptor from the buffer |
445 aMessage.Write(2, buf->Ptr(0)); |
480 HBufC8* des = HBufC8::NewLC(buf->Size()); |
|
481 TPtr8 ptr(des->Des()); |
|
482 buf->Read(0, ptr, buf->Size()); |
|
483 |
|
484 aMessage.Write(2, *des); |
|
485 aMessage.Complete(KErrNone); |
446 aMessage.Complete(KErrNone); |
486 CleanupStack::PopAndDestroy(3, buf); // buf, stream, des |
447 |
|
448 CleanupStack::PopAndDestroy(2, buf); // buf, stream |
487 |
449 |
488 PRINT ( _L("End CPcsSession::SearchInputL") ); |
450 PRINT ( _L("End CPcsSession::SearchInputL") ); |
489 __LATENCY_MARKEND ( _L("CPcsSession::SearchInputL") ); |
451 __LATENCY_MARKEND ( _L("CPcsSession::SearchInputL") ); |
490 |
452 |
491 } |
453 } |
499 PRINT ( _L("Enter CPcsSession::SearchMatchStringL") ); |
461 PRINT ( _L("Enter CPcsSession::SearchMatchStringL") ); |
500 __LATENCY_MARK ( _L("CPcsSession::SearchMatchStringL") ); |
462 __LATENCY_MARK ( _L("CPcsSession::SearchMatchStringL") ); |
501 |
463 |
502 // ------------------------------------------------------------- |
464 // ------------------------------------------------------------- |
503 |
465 |
|
466 // Create result buffer |
|
467 HBufC* des = HBufC::NewLC(KBufferMaxLen); |
|
468 TPtr ptr(des->Des()); |
|
469 |
|
470 // ------------------------------------------------------------- |
|
471 |
504 // Read search query from the message |
472 // Read search query from the message |
505 HBufC8* searchQuery = HBufC8::NewLC(KBufferMaxLen); |
473 CPsQuery* psQuery = ReadQueryLC( 0, aMessage ); |
506 |
|
507 TPtr8 searchQueryPtr(searchQuery->Des()); |
|
508 aMessage.ReadL(0, searchQueryPtr); |
|
509 |
|
510 // Stream over the buffer |
|
511 RDesReadStream searchQueryStream(searchQueryPtr); |
|
512 searchQueryStream.PushL(); |
|
513 |
|
514 // Query object |
|
515 CPsQuery* psQuery = CPsQuery::NewL(); |
|
516 psQuery->InternalizeL(searchQueryStream); |
|
517 |
|
518 // searchQueryStream, searchQuery |
|
519 CleanupStack::PopAndDestroy(2, searchQuery); |
|
520 |
474 |
521 // ------------------------------------------------------------- |
475 // ------------------------------------------------------------- |
522 |
476 |
523 // Read search data from the message |
477 // Read search data from the message |
524 HBufC8* searchData = HBufC8::NewLC(KBufferMaxLen); |
478 HBufC8* searchData = HBufC8::NewLC(KBufferMaxLen); |
535 TUint16 szData = searchDataStream.ReadUint16L(); |
489 TUint16 szData = searchDataStream.ReadUint16L(); |
536 HBufC* data = HBufC::NewL(searchDataStream, szData); |
490 HBufC* data = HBufC::NewL(searchDataStream, szData); |
537 |
491 |
538 // searchQueryStream, searchQuery |
492 // searchQueryStream, searchQuery |
539 CleanupStack::PopAndDestroy(2, searchData); |
493 CleanupStack::PopAndDestroy(2, searchData); |
|
494 CleanupStack::PushL( data ); |
540 |
495 |
541 // ------------------------------------------------------------- |
496 // ------------------------------------------------------------- |
542 |
497 |
543 // Dynamic data buffer |
|
544 CBufFlat* buf = CBufFlat::NewL(KBufferMaxLen); |
|
545 CleanupStack::PushL(buf); |
|
546 |
|
547 // Create a heap descriptor from the buffer |
|
548 HBufC* des = HBufC::NewLC(KBufferMaxLen); |
|
549 TPtr ptr(des->Des()); |
|
550 |
|
551 iServer->PluginInterface()->SearchMatchStringL(*psQuery, |
498 iServer->PluginInterface()->SearchMatchStringL(*psQuery, |
552 *data, |
499 *data, |
553 ptr); |
500 ptr); |
554 |
501 |
555 |
502 |
556 // Delete the search query and search data |
503 // Delete the search query and search data |
557 delete psQuery; |
504 CleanupStack::PopAndDestroy( data ); |
558 delete data; |
505 CleanupStack::PopAndDestroy( psQuery ); |
559 |
506 |
560 aMessage.Write(2, *des); |
507 aMessage.Write(2, *des); |
561 aMessage.Complete(KErrNone); |
508 aMessage.Complete(KErrNone); |
562 CleanupStack::PopAndDestroy(2, buf); // buf, des |
509 CleanupStack::PopAndDestroy(des); |
563 |
510 |
564 PRINT ( _L("End CPcsSession::SearchMatchStringL") ); |
511 PRINT ( _L("End CPcsSession::SearchMatchStringL") ); |
565 __LATENCY_MARKEND ( _L("CPcsSession::SearchMatchStringL") ); |
512 __LATENCY_MARKEND ( _L("CPcsSession::SearchMatchStringL") ); |
566 |
513 |
567 } |
514 } |
611 |
558 |
612 stream1.CommitL(); |
559 stream1.CommitL(); |
613 |
560 |
614 // -------------------------------------------------------------- |
561 // -------------------------------------------------------------- |
615 |
562 |
616 // Create a heap descriptor from the buffer |
563 aMessage.Write(1, buffer1->Ptr(0)); |
617 HBufC8* des = HBufC8::NewLC(buffer1->Size()); |
|
618 TPtr8 ptr(des->Des()); |
|
619 buffer1->Read(0, ptr, buffer1->Size()); |
|
620 |
|
621 aMessage.Write(1, *des); |
|
622 aMessage.Complete(KErrNone); |
564 aMessage.Complete(KErrNone); |
623 CleanupStack::PopAndDestroy(3, buffer1); // buffer1, stream1, des |
565 CleanupStack::PopAndDestroy(2, buffer1); // buffer1, stream1 |
624 |
566 |
625 PRINT ( _L("End CPcsSession::IsLanguageSupportedL") ); |
567 PRINT ( _L("End CPcsSession::IsLanguageSupportedL") ); |
626 } |
568 } |
627 |
569 |
628 |
570 |
678 // Pack the data order fields |
620 // Pack the data order fields |
679 TInt fieldCount = dataOrder.Count(); |
621 TInt fieldCount = dataOrder.Count(); |
680 stream1.WriteUint16L(fieldCount); |
622 stream1.WriteUint16L(fieldCount); |
681 |
623 |
682 // Pack the fields |
624 // Pack the fields |
683 for ( int i = 0; i < fieldCount; i++ ) |
625 for ( TInt i = 0; i < fieldCount; i++ ) |
684 { |
626 { |
685 stream1.WriteUint16L(dataOrder[i]); |
627 stream1.WriteUint16L(dataOrder[i]); |
686 } |
628 } |
687 |
629 |
688 stream1.CommitL(); |
630 stream1.CommitL(); |
689 |
631 |
690 // -------------------------------------------------------------- |
632 // -------------------------------------------------------------- |
691 |
633 |
692 // Create a heap descriptor from the buffer |
634 aMessage.Write(1, buffer1->Ptr(0)); |
693 HBufC8* des = HBufC8::NewLC(buffer1->Size()); |
|
694 TPtr8 ptr(des->Des()); |
|
695 buffer1->Read(0, ptr, buffer1->Size()); |
|
696 |
|
697 aMessage.Write(1, *des); |
|
698 aMessage.Complete(KErrNone); |
635 aMessage.Complete(KErrNone); |
699 CleanupStack::PopAndDestroy(4, &dataOrder); // des, stream1, buffer1, dataOrder |
636 CleanupStack::PopAndDestroy(3, &dataOrder); // stream1, buffer1, dataOrder |
700 |
637 |
701 PRINT ( _L("End CPcsSession::GetDataOrderL") ); |
638 PRINT ( _L("End CPcsSession::GetDataOrderL") ); |
702 } |
639 } |
703 |
640 |
704 // ---------------------------------------------------------------------------- |
641 // ---------------------------------------------------------------------------- |
723 |
660 |
724 // Size of URI |
661 // Size of URI |
725 TInt uriSize = stream.ReadUint16L(); |
662 TInt uriSize = stream.ReadUint16L(); |
726 |
663 |
727 // URI |
664 // URI |
728 HBufC* uri = HBufC::NewLC(stream, uriSize); |
665 HBufC* uri = HBufC::NewL(stream, uriSize); |
|
666 CleanupStack::PopAndDestroy( &stream ); |
|
667 CleanupStack::PopAndDestroy( buffer ); |
|
668 CleanupStack::PushL( uri ); |
729 |
669 |
730 // -------------------------------------------------------------- |
670 // -------------------------------------------------------------- |
731 |
671 |
732 // Set the sort order |
672 // Set the sort order |
733 RArray<TInt> sortOrder; |
673 RArray<TInt> sortOrder; |
734 iServer->PluginInterface()->GetSortOrderL(*uri, sortOrder); |
674 iServer->PluginInterface()->GetSortOrderL(*uri, sortOrder); |
735 |
675 |
736 // uri, stream, buffer |
676 CleanupStack::PopAndDestroy( uri ); |
737 CleanupStack::PopAndDestroy(3, buffer); |
|
738 |
677 |
739 CleanupClosePushL( sortOrder ); |
678 CleanupClosePushL( sortOrder ); |
740 |
679 |
741 // -------------------------------------------------------------- |
680 // -------------------------------------------------------------- |
742 |
681 |
751 // Pack the data order fields |
690 // Pack the data order fields |
752 TInt fieldCount = sortOrder.Count(); |
691 TInt fieldCount = sortOrder.Count(); |
753 stream1.WriteUint16L(fieldCount); |
692 stream1.WriteUint16L(fieldCount); |
754 |
693 |
755 // Pack the fields |
694 // Pack the fields |
756 for ( int i = 0; i < fieldCount; i++ ) |
695 for ( TInt i = 0; i < fieldCount; i++ ) |
757 { |
696 { |
758 stream1.WriteUint16L(sortOrder[i]); |
697 stream1.WriteUint16L(sortOrder[i]); |
759 } |
698 } |
760 |
699 |
761 stream1.CommitL(); |
700 stream1.CommitL(); |
762 |
701 |
763 // -------------------------------------------------------------- |
702 // -------------------------------------------------------------- |
764 |
703 |
765 // Create a heap descriptor from the buffer |
704 aMessage.Write(1, buffer1->Ptr(0)); |
766 HBufC8* des = HBufC8::NewLC(buffer1->Size()); |
|
767 TPtr8 ptr(des->Des()); |
|
768 buffer1->Read(0, ptr, buffer1->Size()); |
|
769 |
|
770 aMessage.Write(1, *des); |
|
771 aMessage.Complete(KErrNone); |
705 aMessage.Complete(KErrNone); |
772 CleanupStack::PopAndDestroy(4, &sortOrder); // des, buffer1, stream1, sortOrder |
706 CleanupStack::PopAndDestroy(3, &sortOrder); // buffer1, stream1, sortOrder |
773 |
707 |
774 PRINT ( _L("End CPcsSession::GetSortOrderL") ); |
708 PRINT ( _L("End CPcsSession::GetSortOrderL") ); |
775 } |
709 } |
776 |
710 |
777 // ---------------------------------------------------------------------------- |
711 // ---------------------------------------------------------------------------- |
797 // Size of URI |
731 // Size of URI |
798 TInt uriSize = stream.ReadUint16L(); |
732 TInt uriSize = stream.ReadUint16L(); |
799 |
733 |
800 // URI |
734 // URI |
801 HBufC* uri = HBufC::NewLC(stream, uriSize); |
735 HBufC* uri = HBufC::NewLC(stream, uriSize); |
802 CleanupStack::Pop(); // uri |
|
803 |
736 |
804 // Number of data fields |
737 // Number of data fields |
805 TInt fieldCount = stream.ReadUint16L(); |
738 TInt fieldCount = stream.ReadUint16L(); |
806 RArray<TInt> sortOrder; |
739 RArray<TInt> sortOrder; |
807 |
740 CleanupClosePushL( sortOrder ); |
808 for ( int i = 0; i < fieldCount; i++ ) |
741 |
|
742 for ( TInt i = 0; i < fieldCount; i++ ) |
809 { |
743 { |
810 sortOrder.Append(stream.ReadUint16L()); |
744 sortOrder.AppendL(stream.ReadUint16L()); |
811 } |
745 } |
812 |
|
813 // stream, buffer |
|
814 CleanupStack::PopAndDestroy(2, buffer); |
|
815 |
746 |
816 // -------------------------------------------------------------- |
747 // -------------------------------------------------------------- |
817 |
748 |
818 // Set the sort order |
749 // Set the sort order |
819 iServer->PluginInterface()->ChangeSortOrderL(*uri, sortOrder); |
750 iServer->PluginInterface()->ChangeSortOrderL(*uri, sortOrder); |
820 |
751 |
821 delete uri; |
752 CleanupStack::PopAndDestroy( &sortOrder ); // Close |
822 sortOrder.Reset(); |
753 CleanupStack::PopAndDestroy( uri ); |
|
754 CleanupStack::PopAndDestroy( &stream ); |
|
755 CleanupStack::PopAndDestroy( buffer ); |
823 |
756 |
824 // -------------------------------------------------------------- |
757 // -------------------------------------------------------------- |
825 |
758 |
826 aMessage.Complete(KErrNone); |
759 aMessage.Complete(KErrNone); |
827 |
760 |
839 aMessage.Complete(KErrNone); |
772 aMessage.Complete(KErrNone); |
840 CActiveScheduler::Stop(); |
773 CActiveScheduler::Stop(); |
841 |
774 |
842 PRINT ( _L("End CPcsSession::ShutdownServerL") ); |
775 PRINT ( _L("End CPcsSession::ShutdownServerL") ); |
843 } |
776 } |
|
777 |
|
778 // ---------------------------------------------------------------------------- |
|
779 // CPcsSession::ReadQueryLC |
|
780 // |
|
781 // ---------------------------------------------------------------------------- |
|
782 CPsQuery* CPcsSession::ReadQueryLC( TInt aParam, const RMessage2& aMessage ) |
|
783 { |
|
784 TInt size = aMessage.GetDesLength( aParam ); |
|
785 HBufC8* tempBuf = HBufC8::NewLC( size ); |
|
786 |
|
787 TPtr8 ptr( tempBuf->Des() ); |
|
788 aMessage.ReadL( aParam, ptr ); |
|
789 |
|
790 // Stream over the buffer |
|
791 RDesReadStream stream( ptr ); |
|
792 stream.PushL(); |
|
793 |
|
794 // Query object |
|
795 CPsQuery* psQuery = CPsQuery::NewL(); |
|
796 CleanupStack::PushL( psQuery ); |
|
797 |
|
798 psQuery->InternalizeL( stream ); |
|
799 |
|
800 CleanupStack::Pop( psQuery ); // temporarily |
|
801 CleanupStack::PopAndDestroy( &stream ); |
|
802 CleanupStack::PopAndDestroy( tempBuf ); |
|
803 CleanupStack::PushL( psQuery ); |
|
804 |
|
805 return psQuery; |
|
806 } |