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:  Transaction status implementation.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "CPEngDetailedResultEntry.h"

    20 #include "CPEngDataResultEntry.h"

    21 #include "CPEngTransactionStatus.h"

    22 #include <S32Strm.h>

    23 #include <s32mem.h>

    24 

    25 

    26 //DATA TYPES

    27 

    28 /**

    29  * Transaction status panic reasons.

    30  * @since 3.0

    31  */

    32 enum TPEngTransactionStatusPanicReasons

    33     {

    34     EPEngDetailedAccessOutOfBounds = 1,

    35     EPEngNoCriteriaForNextDetailByOperation = 2,

    36     EPEngNoCriteriaForNextDataByOperation = 3

    37     };

    38 

    39 

    40 /**

    41  * Transaction status panic category.

    42  * @since 3.0

    43  */

    44 _LIT( KPEngTransStatPanicCategory, "PEngTransStat" );

    45 

    46 

    47 

    48 

    49 // ============================ MEMBER FUNCTIONS ===============================

    50 // -----------------------------------------------------------------------------

    51 // CPEngTransactionStatus::NewL()

    52 // Two-phased constructor.

    53 // -----------------------------------------------------------------------------

    54 //

    55 EXPORT_C CPEngTransactionStatus* CPEngTransactionStatus::NewL()

    56     {

    57     CPEngTransactionStatus* self = new ( ELeave ) CPEngTransactionStatus();

    58     return self;

    59     }

    60 

    61 

    62 // Destructor

    63 CPEngTransactionStatus::~CPEngTransactionStatus()

    64     {

    65     Reset();

    66 

    67 #if _BullseyeCoverage

    68     cov_write();

    69 #endif

    70     }

    71 

    72 

    73 // -----------------------------------------------------------------------------

    74 // CPEngTransactionStatus::CPEngTransactionStatus

    75 // C++ default constructor can NOT contain any code, that

    76 // might leave.

    77 // -----------------------------------------------------------------------------

    78 //

    79 CPEngTransactionStatus::CPEngTransactionStatus()

    80         : iDetailedResultsQ( _FOFF( CPEngDetailedResultEntry, iLink ) ), // CSI: 33 #

    81         iDetailedResultsQIter( iDetailedResultsQ ),

    82         iDetailedResultsCount( 0 ),

    83         iDetResCurrentOperationId( KErrUnknown ),

    84         iDetResCurrentIndex( 0 ),

    85         iDataResultsQ( _FOFF( CPEngDataResultEntry, iLink ) ),         // CSI: 33 #

    86         iDataResultsQIter( iDataResultsQ ),

    87         iDataResultsCount( 0 ),

    88         iDataResCurrentOperationId( KErrUnknown ),

    89         iDataResCurrentIndex( 0 )

    90     {

    91     }

    92 

    93 

    94 // -----------------------------------------------------------------------------

    95 // CPEngTransactionStatus::Status()

    96 // -----------------------------------------------------------------------------

    97 //

    98 TInt CPEngTransactionStatus::Status() const

    99     {

   100     return iStatusCode;

   101     }

   102 

   103 

   104 // -----------------------------------------------------------------------------

   105 // CPEngTransactionStatus::DetailedResultCount()

   106 // -----------------------------------------------------------------------------

   107 //

   108 TInt CPEngTransactionStatus::DetailedResultCount() const

   109     {

   110     return iDetailedResultsCount;

   111     }

   112 

   113 

   114 // -----------------------------------------------------------------------------

   115 // CPEngTransactionStatus::DetailedResult()

   116 // -----------------------------------------------------------------------------

   117 //

   118 const MPEngDetailedResultEntry2& CPEngTransactionStatus::DetailedResult(

   119     TInt aIndex ) const

   120     {

   121     //a pointer to detailed result entry

   122     //If passed index is out of bounds, panics with

   123     //KPEngTransStatPanicCategory, EPEngDetailedAccessOutOfBounds.

   124 

   125     __ASSERT_ALWAYS( aIndex < iDetailedResultsCount,

   126                      CPEngTransactionStatus::Panic( EPEngDetailedAccessOutOfBounds ) );

   127 

   128 

   129     //Details

   130     CPEngTransactionStatus* self = const_cast<CPEngTransactionStatus*>( this );

   131     self->iDetailedResultsQIter.SetToFirst();

   132 

   133     TInt index = 0;

   134     while ( index < aIndex )

   135         {

   136         self->iDetailedResultsQIter++;

   137         index++;

   138         }

   139 

   140     const CPEngDetailedResultEntry* entry = self->iDetailedResultsQIter;

   141     return *entry;

   142     }

   143 

   144 

   145 // -----------------------------------------------------------------------------

   146 // CPEngTransactionStatus::GetFirstDetailedResultByOperation()

   147 // -----------------------------------------------------------------------------

   148 //

   149 TInt CPEngTransactionStatus::GetFirstDetailedResultByOperation(

   150     TInt aOperationID,

   151     const MPEngDetailedResultEntry2*& aDetailedResult )

   152     {

   153     //a pointer to "first" detailed result entry of asked operation.

   154     //If there isn't any detailed result of asked operation, returns KErrNotFound and NULL.

   155     //Else returns KErrNone.

   156 

   157     iDetResCurrentOperationId = aOperationID;

   158     iDetResCurrentIndex = 0; // start searching entries from first element

   159 

   160     return LocateNextDetailByOperation( aDetailedResult );

   161     }

   162 

   163 

   164 

   165 // -----------------------------------------------------------------------------

   166 // CPEngTransactionStatus::GetNextDetailedResultByOperation()

   167 // -----------------------------------------------------------------------------

   168 //

   169 TInt CPEngTransactionStatus::GetNextDetailedResultByOperation(

   170     const MPEngDetailedResultEntry2*& aDetailedResult )

   171     {

   172     //A pointer to next found detailed result entry.

   173     //If operation criteria hasn't been set previously, panics with

   174     //KPEngTransStatPanicCategory, EPEngNoCriteriaForNextByOrigin.

   175 

   176     __ASSERT_ALWAYS( iDetResCurrentOperationId != KErrUnknown,

   177                      CPEngTransactionStatus::Panic( EPEngNoCriteriaForNextDetailByOperation ) );

   178 

   179     // returns KErrNone if a detailed result of the asked operation ID is found.

   180     // Else KErrNotFound and NULL.

   181     return LocateNextDetailByOperation( aDetailedResult );

   182     }

   183 

   184 

   185 // -----------------------------------------------------------------------------

   186 // CPEngTransactionStatus::GetDesc()

   187 // -----------------------------------------------------------------------------

   188 //

   189 TInt CPEngTransactionStatus::GetDesc(

   190     TPtrC& /*aDescriptionText*/,

   191     TPEngTransStatusDescriptionText2 /*aDescriptionID*/ ) const

   192     {

   193     return KErrNotFound;

   194     }

   195 

   196 

   197 // -----------------------------------------------------------------------------

   198 // CPEngTransactionStatus::GetInt()

   199 // -----------------------------------------------------------------------------

   200 //

   201 TInt CPEngTransactionStatus::GetInt(

   202     TUint32& /*aDescriptionInt*/,

   203     TPEngTransStatusDescriptionInteger2 /*aDescriptionID*/ ) const

   204     {

   205     return KErrNotFound;

   206     }

   207 

   208 

   209 // -----------------------------------------------------------------------------

   210 // CPEngTransactionStatus::CloneLC()

   211 // -----------------------------------------------------------------------------

   212 //

   213 MPEngTransactionStatusCopy2* CPEngTransactionStatus::CloneLC() const

   214     {

   215     return BaseCloneLC();

   216     }

   217 

   218 

   219 

   220 // -----------------------------------------------------------------------------

   221 // CPEngTransactionStatus::StatusExtension()

   222 // -----------------------------------------------------------------------------

   223 //

   224 MPEngTransactionStatusExtension2* CPEngTransactionStatus::StatusExtension()

   225     {

   226     return NULL;

   227     }

   228 

   229 

   230 // -----------------------------------------------------------------------------

   231 // CPEngTransactionStatus::Close()

   232 // from MPEngTransactionStatusCopy

   233 // -----------------------------------------------------------------------------

   234 //

   235 void CPEngTransactionStatus::Close()

   236     {

   237     delete this;

   238     }

   239 

   240 

   241 // -----------------------------------------------------------------------------

   242 // From MPEngAdvTransactionStatus

   243 // -----------------------------------------------------------------------------

   244 

   245 

   246 // -----------------------------------------------------------------------------

   247 // CPEngTransactionStatus::SetStatus()

   248 // -----------------------------------------------------------------------------

   249 //

   250 void CPEngTransactionStatus::SetStatus( TInt aStatus )

   251     {

   252     iStatusCode = aStatus;

   253     }

   254 

   255 

   256 

   257 

   258 // -----------------------------------------------------------------------------

   259 // CPEngTransactionStatus::AddDetailedResultL()

   260 // -----------------------------------------------------------------------------

   261 //

   262 void CPEngTransactionStatus::AddDetailedResultL( TInt aOperationID,

   263                                                  TInt aErrorCode,

   264                                                  const TUint32* aAttributeTypeID,

   265                                                  const TDesC* aPresenceID,

   266                                                  const TDesC* aContactListID,

   267                                                  const TDesC* aDescription )

   268     {

   269     CPEngDetailedResultEntry* entry = CPEngDetailedResultEntry::NewLC( aOperationID,

   270                                                                        aErrorCode,

   271                                                                        aAttributeTypeID,

   272                                                                        aPresenceID,

   273                                                                        aContactListID,

   274                                                                        aDescription );

   275 

   276 

   277 

   278     iDetailedResultsQ.AddLast( *entry );

   279     iDetailedResultsCount++;

   280     CleanupStack::Pop(); //entry

   281     }

   282 

   283 

   284 // -----------------------------------------------------------------------------

   285 // CPEngTransactionStatus::AddDataResultL()

   286 // -----------------------------------------------------------------------------

   287 //

   288 void CPEngTransactionStatus::AddDataResultL( TInt aOperationID,

   289                                              HBufC16* aDataResult )

   290 

   291     {

   292     //This function behaves like array append.

   293     //It takes the aDataResult ownership only in full success.

   294     CPEngDataResultEntry* entry = CPEngDataResultEntry::NewLC( aOperationID,

   295                                                                aDataResult );

   296 

   297 

   298 

   299     iDataResultsQ.AddLast( *entry );

   300     iDataResultsCount++;

   301     CleanupStack::Pop(); //entry

   302     }

   303 

   304 

   305 

   306 // -----------------------------------------------------------------------------

   307 // CPEngTransactionStatus::GetFirstDataResultByOperation()

   308 // -----------------------------------------------------------------------------

   309 //

   310 TInt CPEngTransactionStatus::GetFirstDataResultByOperation( TInt aOperationID,

   311                                                             TPtrC16& aDataResult )

   312     {

   313     //a pointer to "first" detailed result entry of asked operation.

   314     //If there isn't any detailed result of asked operation, returns KErrNotFound and

   315     //empty descriptor. Else returns KErrNone.

   316 

   317     iDataResCurrentOperationId = aOperationID;

   318     iDataResCurrentIndex = 0; // start searching entries from first element

   319 

   320     return LocateNextDataByOperation( aDataResult );

   321     }

   322 

   323 

   324 // -----------------------------------------------------------------------------

   325 // CPEngTransactionStatus::GetNextDataResultByOperation()

   326 // -----------------------------------------------------------------------------

   327 //

   328 TInt CPEngTransactionStatus::GetNextDataResultByOperation( TPtrC16& aDataResult )

   329     {

   330     //A pointer to next found detailed result entry.

   331     //If operation criteria hasn't been set previously, panics with

   332     //KPEngTransStatPanicCategory, EPEngNoCriteriaForNextByOrigin.

   333 

   334     __ASSERT_ALWAYS( iDataResCurrentOperationId != KErrUnknown,

   335                      CPEngTransactionStatus::Panic( EPEngNoCriteriaForNextDataByOperation ) );

   336 

   337     // returns KErrNone if a detailed result of the asked operation ID is found.

   338     // Else KErrNotFound and NULL.

   339     return LocateNextDataByOperation( aDataResult );

   340     }

   341 

   342 

   343 

   344 // -----------------------------------------------------------------------------

   345 // CPEngTransactionStatus::Reset()

   346 // -----------------------------------------------------------------------------

   347 //

   348 EXPORT_C void CPEngTransactionStatus::Reset()

   349     {

   350     CPEngDetailedResultEntry* detailEntry;

   351     iDetailedResultsQIter.SetToFirst();

   352 

   353     while ( ( detailEntry = iDetailedResultsQIter++ ) != NULL ) // CSI: 64 #

   354         {

   355         iDetailedResultsQ.Remove( *detailEntry );

   356         delete detailEntry;

   357         }

   358 

   359 

   360 

   361     CPEngDataResultEntry* dataEntry;

   362 

   363     iDataResultsQIter.SetToFirst();

   364     while ( ( dataEntry = iDataResultsQIter++ ) != NULL )       // CSI: 64 #

   365         {

   366         iDataResultsQ.Remove( *dataEntry );

   367         delete dataEntry;

   368         }

   369 

   370 

   371     iDetailedResultsCount = 0;

   372     iStatusCode = KErrNone;

   373     iDetResCurrentOperationId = KErrUnknown;

   374     iDetResCurrentIndex = 0;

   375     }

   376 

   377 

   378 

   379 // -----------------------------------------------------------------------------

   380 // CPEngTransactionStatus::ImportStatusFrom()

   381 // -----------------------------------------------------------------------------

   382 //

   383 EXPORT_C void CPEngTransactionStatus::ImportStatusFrom(

   384     CPEngTransactionStatus& aSource )

   385     {

   386     MergeStatusCodes( aSource );

   387 

   388     CPEngDetailedResultEntry* detailEntry;

   389     aSource.iDetailedResultsQIter.SetToFirst();

   390 

   391     while ( ( detailEntry = aSource.iDetailedResultsQIter++ ) != NULL ) // CSI: 64 #

   392         {

   393         aSource.iDetailedResultsQ.Remove( *detailEntry );

   394 

   395         iDetailedResultsQ.AddLast( *detailEntry );

   396         iDetailedResultsCount++;

   397         }

   398 

   399 

   400 

   401     CPEngDataResultEntry* dataEntry;

   402     aSource.iDataResultsQIter.SetToFirst();

   403     while ( ( dataEntry = aSource.iDataResultsQIter++ ) != NULL )       // CSI: 64 #

   404         {

   405         aSource.iDataResultsQ.Remove( *dataEntry );

   406 

   407         iDataResultsQ.AddLast( *dataEntry );

   408         iDataResultsCount++;

   409         }

   410 

   411     delete &aSource;

   412     }

   413 

   414 

   415 

   416 // -----------------------------------------------------------------------------

   417 // CPEngTransactionStatus::FullCloneLC()

   418 // -----------------------------------------------------------------------------

   419 //

   420 CPEngTransactionStatus* CPEngTransactionStatus::FullCloneLC() const

   421     {

   422     CPEngTransactionStatus* self = const_cast<CPEngTransactionStatus*>( this );

   423 

   424     CPEngTransactionStatus* copy = BaseCloneLC();

   425 

   426 

   427     //Copy internal details

   428     self->iDataResultsQIter.SetToFirst();

   429     CPEngDataResultEntry* dataEntry;

   430 

   431     while ( ( dataEntry = self->iDataResultsQIter++ ) != NULL )     // CSI: 64 #

   432         {

   433         CPEngDataResultEntry* newEntry = CPEngDataResultEntry::NewLC( *dataEntry );

   434         copy->iDataResultsQ.AddLast( *newEntry );

   435         copy->iDataResultsCount++;

   436         CleanupStack::Pop(); //newEntry

   437         }

   438 

   439     return copy;

   440     }

   441 

   442 

   443 

   444 // -----------------------------------------------------------------------------

   445 // CPEngTransactionStatus::PackResultsL()

   446 // -----------------------------------------------------------------------------

   447 //

   448 EXPORT_C HBufC8* CPEngTransactionStatus::PackResultsL() const

   449     {

   450     TInt size = ExternalizeSize();

   451     CBufFlat* dynBuffer = CBufFlat::NewL( size );

   452     CleanupStack::PushL( dynBuffer );

   453 

   454     RBufWriteStream wstream;

   455     wstream.Open( *dynBuffer );

   456     CleanupClosePushL( wstream );

   457 

   458     ExternalizeL( wstream );

   459 

   460     wstream.CommitL();

   461     CleanupStack::PopAndDestroy(); //wstream

   462 

   463     TPtrC8 dynBufferPtr( dynBuffer->Ptr( 0 ) );

   464     HBufC8* heapBuffer = dynBufferPtr.AllocL();

   465     CleanupStack::PopAndDestroy(); //dynBuffer

   466 

   467     return heapBuffer;

   468     }

   469 

   470 

   471 // -----------------------------------------------------------------------------

   472 // CPEngTransactionStatus::UnpackResultsL()

   473 // -----------------------------------------------------------------------------

   474 //

   475 EXPORT_C void CPEngTransactionStatus::UnpackResultsL( const TDesC8& aResultPkg )

   476     {

   477     RDesReadStream rstream;

   478     rstream.Open( aResultPkg );

   479     CleanupClosePushL( rstream );

   480 

   481     InternalizeL( rstream );

   482 

   483     CleanupStack::PopAndDestroy(); //rs

   484     }

   485 

   486 

   487 

   488 // -----------------------------------------------------------------------------

   489 // CPEngTransactionStatus::LocateNextDetailByOperation()

   490 // -----------------------------------------------------------------------------

   491 //

   492 TInt CPEngTransactionStatus::LocateNextDetailByOperation(

   493     const MPEngDetailedResultEntry2*& aDetailedResult )

   494     {

   495     iDetailedResultsQIter.SetToFirst();

   496     CPEngDetailedResultEntry* entry;

   497     TInt index = 0;

   498     while ( index < iDetResCurrentIndex )

   499         {

   500         iDetailedResultsQIter++;

   501         index++;

   502         }

   503 

   504 

   505     while ( ( entry = iDetailedResultsQIter++ ) != NULL )  // CSI: 64 #

   506         {

   507         index++;

   508         if ( entry->Operation() == iDetResCurrentOperationId )

   509             {

   510             //match found, update position and return entry

   511             iDetResCurrentIndex = index;

   512             aDetailedResult = entry;

   513             return KErrNone;

   514             }

   515         }

   516 

   517 

   518     aDetailedResult = NULL;

   519     return KErrNotFound;

   520     }

   521 

   522 

   523 // -----------------------------------------------------------------------------

   524 // CPEngTransactionStatus::LocateNextDataByOperation()

   525 // -----------------------------------------------------------------------------

   526 //

   527 TInt CPEngTransactionStatus::LocateNextDataByOperation( TPtrC16& aDataResult )

   528     {

   529     iDataResultsQIter.SetToFirst();

   530     CPEngDataResultEntry* entry;

   531     TInt index = 0;

   532     while ( index < iDataResCurrentIndex )

   533         {

   534         iDataResultsQIter++;

   535         index++;

   536         }

   537 

   538     while ( ( entry = iDataResultsQIter++ ) != NULL )  // CSI: 64 #

   539         {

   540         index++;

   541         if ( entry->Operation() == iDataResCurrentOperationId )

   542             {

   543             //match found, update position and return entry

   544             iDataResCurrentIndex = index;

   545             aDataResult.Set( entry->Data() );

   546             return KErrNone;

   547             }

   548         }

   549 

   550     aDataResult.Set( NULL, 0 );

   551     return KErrNotFound;

   552     }

   553 

   554 

   555 

   556 

   557 // -----------------------------------------------------------------------------

   558 // CPEngTransactionStatus::MergeStatusCodes()

   559 // -----------------------------------------------------------------------------

   560 //

   561 void CPEngTransactionStatus::MergeStatusCodes( const CPEngTransactionStatus& aSource )

   562     {

   563     //If no error yet in this container, take the one from imported one

   564     if ( iStatusCode == KErrNone )

   565         {

   566         iStatusCode = aSource.iStatusCode;

   567         return;

   568         }

   569     }

   570 

   571 

   572 // -----------------------------------------------------------------------------

   573 // CPEngTransactionStatus::BaseCloneLC()

   574 // -----------------------------------------------------------------------------

   575 //

   576 CPEngTransactionStatus* CPEngTransactionStatus::BaseCloneLC() const

   577     {

   578     CPEngTransactionStatus* self = const_cast<CPEngTransactionStatus*>( this );

   579 

   580 

   581     CPEngTransactionStatus* copy = CPEngTransactionStatus::NewL();

   582     CleanupStack::PushL( copy );

   583 

   584     //Main status code

   585     copy->iStatusCode = iStatusCode;

   586 

   587 

   588     //Clone only base details - e.g. only those visible to clients

   589     self->iDetailedResultsQIter.SetToFirst();

   590 

   591     CPEngDetailedResultEntry* entry;

   592     while ( ( entry = self->iDetailedResultsQIter++ ) != NULL ) // CSI: 64 #

   593         {

   594         CPEngDetailedResultEntry* newEntry = CPEngDetailedResultEntry::NewLC( *entry );

   595         copy->iDetailedResultsQ.AddLast( *newEntry );

   596         copy->iDetailedResultsCount++;

   597         CleanupStack::Pop(); //newEntry

   598         }

   599 

   600     return copy;

   601     }

   602 

   603 

   604 // -----------------------------------------------------------------------------

   605 // CPEngTransactionStatus::ExternalizeSize()

   606 // -----------------------------------------------------------------------------

   607 //

   608 TInt CPEngTransactionStatus::ExternalizeSize() const

   609     {

   610     CPEngTransactionStatus* self = const_cast<CPEngTransactionStatus*>( this );

   611 

   612     TInt size = 12; //iStatusCode: 4 bytes

   613     //iDetailedResultsCount: 4 bytes

   614     //iDataResultsCount: 4 bytes

   615 

   616 

   617     self->iDetailedResultsQIter.SetToFirst();

   618     CPEngDetailedResultEntry* detailedEntry;

   619     while ( ( detailedEntry = self->iDetailedResultsQIter++ ) != NULL ) // CSI: 64 #

   620         {

   621         size += detailedEntry->ExternalizeSize();

   622         }

   623 

   624 

   625     self->iDataResultsQIter.SetToFirst() ;

   626     CPEngDataResultEntry* dataEntry;

   627     while ( ( dataEntry = self->iDataResultsQIter++ ) != NULL ) // CSI: 64 #

   628         {

   629         size += dataEntry->ExternalizeSize();

   630         }

   631 

   632     return size;

   633     }

   634 

   635 

   636 // -----------------------------------------------------------------------------

   637 // CPEngTransactionStatus::ExternalizeL()

   638 // -----------------------------------------------------------------------------

   639 //

   640 void CPEngTransactionStatus::ExternalizeL( RWriteStream& aStream ) const

   641     {

   642     CPEngTransactionStatus* self = const_cast<CPEngTransactionStatus*>( this );

   643 

   644     aStream.WriteInt32L( iStatusCode );

   645 

   646 

   647     //Details

   648     aStream.WriteInt32L( iDetailedResultsCount );

   649     self->iDetailedResultsQIter.SetToFirst();

   650     CPEngDetailedResultEntry* detailedEntry;

   651     while ( ( detailedEntry = self->iDetailedResultsQIter++ ) != NULL )  // CSI: 64 #

   652         {

   653         detailedEntry->ExternalizeL( aStream );

   654         }

   655 

   656 

   657     //Datas

   658     aStream.WriteInt32L( iDataResultsCount );

   659 

   660     self->iDataResultsQIter.SetToFirst();

   661     CPEngDataResultEntry* dataEntry;

   662     while ( ( dataEntry = self->iDataResultsQIter++ ) != NULL ) // CSI: 64 #

   663         {

   664         dataEntry->ExternalizeL( aStream );

   665         }

   666     }

   667 

   668 

   669 

   670 // -----------------------------------------------------------------------------

   671 // CPEngTransactionStatus::InternalizeL()

   672 // -----------------------------------------------------------------------------

   673 //

   674 void CPEngTransactionStatus::InternalizeL( RReadStream& aStream )

   675     {

   676     Reset();

   677 

   678     iStatusCode = aStream.ReadInt32L();

   679     TInt ii;

   680 

   681     const TInt detailedCount = aStream.ReadInt32L();

   682     for ( ii = 0; ii < detailedCount; ii++ )

   683         {

   684         CPEngDetailedResultEntry* entry = CPEngDetailedResultEntry::NewLC( aStream );

   685 

   686         iDetailedResultsQ.AddLast( *entry );

   687         iDetailedResultsCount++;

   688 

   689         CleanupStack::Pop(); //entry

   690         }

   691 

   692 

   693     const TInt dataCount = aStream.ReadInt32L();

   694     for ( ii = 0; ii < dataCount; ii++ )

   695         {

   696         CPEngDataResultEntry* entry = CPEngDataResultEntry::NewLC( aStream );

   697 

   698         iDataResultsQ.AddLast( *entry );

   699         iDataResultsCount++;

   700 

   701         CleanupStack::Pop(); //entry

   702         }

   703     }

   704 

   705 // -----------------------------------------------------------------------------

   706 // CPEngTransactionStatus::Panic()

   707 // -----------------------------------------------------------------------------

   708 void CPEngTransactionStatus::Panic( TInt aReason )

   709     {

   710     User::Panic( KPEngTransStatPanicCategory, aReason );

   711     }

   712 

   713 

   714 

   715 //  End of File

   716