1 /*

     2 * Copyright (c) 2006 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:  MPresentityGroupContentEvent API object implementation.

    15  *

    16 */

    17 

    18 #include "presentitygroupcontenteventimp.h"

    19 #include "presentitygroupmemberinfoimp.h"

    20 #include "ximpidentityimp.h"

    21 #include "ximpdatasubscriptionstateimp.h"

    22 #include "ximpobjecthelpers.h"

    23 #include <s32strm.h>

    24 

    25 

    26 // ---------------------------------------------------------------------------

    27 // CPresentityGroupContentEventImp::NewLC()

    28 // ---------------------------------------------------------------------------

    29 //

    30 EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewLC(

    31         CXIMPIdentityImp& aGroupId,

    32         RPrGrpMemInfoImpArray* aAdded,

    33         RPrGrpMemInfoImpArray* aUpdated,

    34         RPrGrpMemInfoImpArray* aRemoved,

    35         CXIMPDataSubscriptionStateImp* aState

    36         )

    37     {

    38     CPresentityGroupContentEventImp* self = new( ELeave ) CPresentityGroupContentEventImp();

    39     CleanupStack::PushL( self );

    40     self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aState );

    41     return self;

    42     }

    43 

    44 // ---------------------------------------------------------------------------

    45 // CPresentityGroupContentEventImp::NewLC()

    46 // ---------------------------------------------------------------------------

    47 //

    48 EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewLC(

    49         CXIMPIdentityImp& aGroupId,

    50         RPrGrpMemInfoImpArray* aAdded,

    51         RPrGrpMemInfoImpArray* aUpdated,

    52         RPrGrpMemInfoImpArray* aRemoved,

    53         RPrGrpMemInfoImpArray* aCurrent,

    54         CXIMPDataSubscriptionStateImp* aState

    55         )

    56     {

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

    58     CleanupStack::PushL( self );

    59     if( aCurrent )

    60         {

    61         self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aCurrent, aState );

    62         }

    63     else

    64         {

    65         self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aState );

    66         }

    67     return self;

    68     }

    69 // ---------------------------------------------------------------------------

    70 // CPresentityGroupContentEventImp::NewL()

    71 // ---------------------------------------------------------------------------

    72 //

    73 EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewL(

    74         CXIMPIdentityImp& aGroupId,

    75         RPrGrpMemInfoImpArray* aAdded,

    76         RPrGrpMemInfoImpArray* aUpdated,

    77         RPrGrpMemInfoImpArray* aRemoved,

    78         RPrGrpMemInfoImpArray* aCurrent,

    79         CXIMPDataSubscriptionStateImp* aState

    80         )

    81     {

    82     CPresentityGroupContentEventImp* self = 

    83         NewLC( aGroupId, aAdded, aUpdated, aRemoved, aCurrent, aState );

    84     CleanupStack::Pop( self );

    85     return self;

    86     }

    87 

    88 // ---------------------------------------------------------------------------

    89 // CPresentityGroupContentEventImp::NewFromStreamLC()

    90 // ---------------------------------------------------------------------------

    91 //

    92 CXIMPApiEventBase* CPresentityGroupContentEventImp::NewFromStreamLC( RReadStream& aStream )

    93     {

    94     CPresentityGroupContentEventImp* self = new( ELeave ) CPresentityGroupContentEventImp();

    95     CleanupStack::PushL( self );

    96     self->ConstructL( aStream );

    97     return self;

    98     }

    99 

   100 // ---------------------------------------------------------------------------

   101 // CPresentityGroupContentEventImp::~CPresentityGroupContentEventImp()

   102 // ---------------------------------------------------------------------------

   103 //

   104 CPresentityGroupContentEventImp::~CPresentityGroupContentEventImp()

   105     {

   106     delete iGroupId;

   107 

   108     if( iConstructedFromStream )

   109         {

   110         delete iAddedMembers;

   111         delete iUpdatedMembers;

   112         delete iRemovedMembers;

   113         delete iCurrentMembers;

   114         iCurrentMembers = NULL;  // must be null to skip double deletion below

   115         }

   116 

   117     if ( iOwnsCurrentMembersArray )

   118         {

   119         delete iCurrentMembers;

   120         }

   121 

   122     delete iSubscriptionState;

   123     }

   124 

   125 // ---------------------------------------------------------------------------

   126 // CPresentityGroupContentEventImp::CPresentityGroupContentEventImp()

   127 // ---------------------------------------------------------------------------

   128 //

   129 CPresentityGroupContentEventImp::CPresentityGroupContentEventImp()

   130     {

   131     }

   132 

   133 

   134 // ---------------------------------------------------------------------------

   135 // CPresentityGroupContentEventImp::ConstructL()

   136 // ---------------------------------------------------------------------------

   137 //

   138 void CPresentityGroupContentEventImp::ConstructL(

   139         CXIMPIdentityImp& aGroupId,

   140         RPrGrpMemInfoImpArray* aAdded,

   141         RPrGrpMemInfoImpArray* aUpdated,

   142         RPrGrpMemInfoImpArray* aRemoved,

   143         CXIMPDataSubscriptionStateImp* aState

   144          )

   145     {

   146     iGroupId = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aGroupId );

   147     iAddedMembers = aAdded;

   148     iUpdatedMembers = aUpdated;

   149     iRemovedMembers = aRemoved;

   150 

   151     iCurrentMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

   152     iOwnsCurrentMembersArray = ETrue;

   153     

   154     iSubscriptionState = aState;

   155     }

   156 

   157 // ---------------------------------------------------------------------------

   158 // CPresentityGroupContentEventImp::ConstructL()

   159 // ---------------------------------------------------------------------------

   160 //

   161 void CPresentityGroupContentEventImp::ConstructL(

   162         CXIMPIdentityImp& aGroupId,

   163         RPrGrpMemInfoImpArray* aAdded,

   164         RPrGrpMemInfoImpArray* aUpdated,

   165         RPrGrpMemInfoImpArray* aRemoved,

   166         RPrGrpMemInfoImpArray* aCurrent,

   167         CXIMPDataSubscriptionStateImp* aState )

   168     {

   169     iGroupId = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aGroupId );

   170     iAddedMembers = aAdded;

   171     iUpdatedMembers = aUpdated;

   172     iRemovedMembers = aRemoved;

   173     iCurrentMembers = aCurrent;

   174 

   175     iSubscriptionState = aState;

   176     }

   177 

   178 // ---------------------------------------------------------------------------

   179 // CPresentityGroupContentEventImp::ConstructL()

   180 // ---------------------------------------------------------------------------

   181 //

   182 void CPresentityGroupContentEventImp::ConstructL( RReadStream& aStream )

   183     {

   184     iConstructedFromStream = ETrue;

   185     iAddedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

   186     iUpdatedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

   187     iRemovedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

   188     iCurrentMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

   189 

   190     iGroupId = CXIMPIdentityImp::NewLC();

   191     CleanupStack::Pop( 1 ); // iGroupId

   192 

   193     iGroupId->InternalizeL( aStream );

   194     FillArrayFromStreamL( *iAddedMembers, aStream );

   195     FillArrayFromStreamL( *iUpdatedMembers, aStream );

   196     FillArrayFromStreamL( *iRemovedMembers, aStream );

   197     FillArrayFromStreamL( *iCurrentMembers, aStream );

   198 

   199 

   200     iSubscriptionState = CXIMPDataSubscriptionStateImp::NewL();

   201     iSubscriptionState->InternalizeL( aStream );

   202     }

   203 

   204 // ---------------------------------------------------------------------------

   205 // Implement supported interface access.

   206 // ---------------------------------------------------------------------------

   207 //

   208 XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresentityGroupContentEventImp,

   209                                      MPresentityGroupContentEvent )

   210     XIMPIMP_IF_BASE_GET_CLASS( CXIMPApiEventBase, this )

   211 XIMPIMP_IF_BASE_GET_INTERFACE_END()

   212 

   213 XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresentityGroupContentEventImp,

   214                                            MPresentityGroupContentEvent )

   215     XIMPIMP_IF_BASE_GET_CONST_CLASS( CXIMPApiEventBase, this )                                            

   216 XIMPIMP_IF_BASE_GET_INTERFACE_END()

   217 

   218 

   219 

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

   221 // Implement methods from base event interface and base event class

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

   223 //

   224 XIMPIMP_IMPLEMENT_EVENT_BASE_METHODS( CPresentityGroupContentEventImp,

   225                                       MPresentityGroupContentEvent )

   226 

   227 

   228 // ---------------------------------------------------------------------------

   229 // CPresentityGroupContentEventImp::EqualsContent()

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

   231 //

   232 TBool CPresentityGroupContentEventImp::EqualsContent( 

   233     const CXIMPApiEventBase& aOtherInstance ) const

   234     {

   235     const CPresentityGroupContentEventImp* tmp =

   236     TXIMPGetImpClassOrPanic< const CPresentityGroupContentEventImp >::From( 

   237                                                         aOtherInstance.Base() );

   238 

   239     TBool same = ETrue;

   240 

   241     TBool x = 0 == GroupId().Identity().Compare( tmp->GroupId().Identity() );

   242     same &= x;

   243 

   244     x = CompareArrays( iAddedMembers, tmp->iAddedMembers );

   245     same &= x;

   246 

   247     x = CompareArrays( iUpdatedMembers, tmp->iUpdatedMembers );

   248     same &= x;

   249 

   250     x = CompareArrays( iRemovedMembers, tmp->iRemovedMembers );

   251     same &= x;

   252 

   253     x = CompareArrays( iCurrentMembers, tmp->iCurrentMembers );

   254     same &= x;

   255 

   256     x = iSubscriptionState->EqualsContent( *tmp->iSubscriptionState );

   257     same &= x;

   258 

   259     return same;

   260     }

   261 

   262 // ---------------------------------------------------------------------------

   263 // CPresentityGroupContentEventImp::CompareArrays

   264 // ---------------------------------------------------------------------------

   265 //

   266 TBool CPresentityGroupContentEventImp::CompareArrays(

   267         RPrGrpMemInfoImpArray* aA, RPrGrpMemInfoImpArray* aB )

   268     {

   269     TBool same = ETrue;

   270 

   271     TBool x;

   272     x = aA->Count() == aB->Count();   // counts must match

   273     same &= x;

   274 

   275     if ( ! same )

   276         {

   277         // don't bother checking further if counts mismatch

   278         return same;

   279         }

   280 

   281     // now check whole array, arrays have equal length

   282     for ( TInt i = 0; i < aA->Count(); i++ )

   283         {

   284         x = 0 == ( (*aA)[ i ]->IdentityImp().Compare(

   285                     (*aB)[ i ]->IdentityImp() ) );

   286         same &= x;

   287 

   288         x = 0 == ( (*aA)[ i ]->GroupMemberDisplayName().Compare(

   289                     (*aB)[ i ]->GroupMemberDisplayName() ) );

   290         same &= x;

   291         }

   292 

   293     return same;

   294     }

   295 

   296 // ---------------------------------------------------------------------------

   297 // From class CXIMPApiEventBase.

   298 // CPresentityGroupContentEventImp::ExternalizeL()

   299 // ---------------------------------------------------------------------------

   300 //

   301 void CPresentityGroupContentEventImp::ExternalizeL( RWriteStream& aStream ) const

   302     {

   303     iGroupId->ExternalizeL( aStream );

   304     WriteArrayToStreamL( *iAddedMembers, aStream );

   305     WriteArrayToStreamL( *iUpdatedMembers, aStream );

   306     WriteArrayToStreamL( *iRemovedMembers, aStream );

   307     WriteArrayToStreamL( *iCurrentMembers, aStream );

   308 

   309     iSubscriptionState->ExternalizeL( aStream );

   310     }

   311 

   312 

   313 // ---------------------------------------------------------------------------

   314 // From class MPresentityGroupContentEvent.

   315 // CPresentityGroupContentEventImp::GroupId()

   316 // ---------------------------------------------------------------------------

   317 //

   318 const MXIMPIdentity& CPresentityGroupContentEventImp::GroupId() const

   319     {

   320     return *iGroupId;

   321     }

   322 

   323 // ---------------------------------------------------------------------------

   324 // From class MPresentityGroupContentEvent.

   325 // CPresentityGroupContentEventImp::NewMembersCount()

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

   327 //

   328 TInt CPresentityGroupContentEventImp::NewMembersCount() const

   329     {

   330     return iAddedMembers->Count();

   331     }

   332 

   333 // ---------------------------------------------------------------------------

   334 // From class MPresentityGroupContentEvent.

   335 // CPresentityGroupContentEventImp::NewMember()

   336 // ---------------------------------------------------------------------------

   337 //

   338 const MPresentityGroupMemberInfo& 

   339     CPresentityGroupContentEventImp::NewMember( TInt aIndex ) const

   340     {

   341     return *(*iAddedMembers)[ aIndex ];

   342     }

   343 

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

   345 // From class MPresentityGroupContentEvent.

   346 // CPresentityGroupContentEventImp::UpdatedMembersCount()

   347 // ---------------------------------------------------------------------------

   348 //

   349 TInt CPresentityGroupContentEventImp::UpdatedMembersCount() const

   350     {

   351     return iUpdatedMembers->Count();

   352     }

   353 

   354 // ---------------------------------------------------------------------------

   355 // From class MPresentityGroupContentEvent.

   356 // CPresentityGroupContentEventImp::UpdatedMember()

   357 // ---------------------------------------------------------------------------

   358 //

   359 const MPresentityGroupMemberInfo& 

   360     CPresentityGroupContentEventImp::UpdatedMember( TInt aIndex ) const

   361     {

   362     return *(*iUpdatedMembers)[ aIndex ];

   363     }

   364 

   365 // ---------------------------------------------------------------------------

   366 // From class MPresentityGroupContentEvent.

   367 // CPresentityGroupContentEventImp::DisappearedMembersCount()

   368 // ---------------------------------------------------------------------------

   369 //

   370 TInt CPresentityGroupContentEventImp::DisappearedMembersCount() const

   371     {

   372     return iRemovedMembers->Count();

   373     }

   374 

   375 // ---------------------------------------------------------------------------

   376 // From class MPresentityGroupContentEvent.

   377 // CPresentityGroupContentEventImp::DisappearedMember()

   378 // ---------------------------------------------------------------------------

   379 //

   380 const MPresentityGroupMemberInfo& 

   381     CPresentityGroupContentEventImp::DisappearedMember( TInt aIndex ) const

   382     {

   383     return *(*iRemovedMembers)[ aIndex ];

   384     }

   385 

   386 // ---------------------------------------------------------------------------

   387 // From class MPresentityGroupContentEvent.

   388 // CPresentityGroupContentEventImp::CurrentMembersCount()

   389 // ---------------------------------------------------------------------------

   390 //

   391 TInt CPresentityGroupContentEventImp::CurrentMembersCount() const

   392     {

   393     return iCurrentMembers->Count();

   394     }

   395 

   396 // ---------------------------------------------------------------------------

   397 // From class MPresentityGroupContentEvent.

   398 // CPresentityGroupContentEventImp::CurrentMember()

   399 // ---------------------------------------------------------------------------

   400 //

   401 const MPresentityGroupMemberInfo& 

   402     CPresentityGroupContentEventImp::CurrentMember( TInt aIndex ) const

   403     {

   404     return *(*iCurrentMembers)[ aIndex ];

   405     }

   406 

   407 // ---------------------------------------------------------------------------

   408 // From class MPresentityGroupContentEvent.

   409 // CPresentityGroupContentEventImp::Status()

   410 // ---------------------------------------------------------------------------

   411 //

   412 const MXIMPDataSubscriptionState&

   413     CPresentityGroupContentEventImp::DataSubscriptionState() const

   414     {

   415     return *iSubscriptionState;

   416     }

   417 

   418 

   419 // ---------------------------------------------------------------------------

   420 // CPresentityGroupContentEventImp::WriteArrayToStreamL()

   421 // ---------------------------------------------------------------------------

   422 //

   423 void CPresentityGroupContentEventImp::WriteArrayToStreamL(

   424         RPrGrpMemInfoImpArray& aArray, RWriteStream& aStream ) const

   425     {

   426     TInt count = aArray.Count();

   427     aStream.WriteInt32L( count );

   428         {

   429         for( TInt a = 0; a < count; ++a )

   430             {

   431             aArray[ a ]->ExternalizeL( aStream );

   432             }

   433         }

   434     }

   435 

   436 // ---------------------------------------------------------------------------

   437 // CPresentityGroupContentEventImp::FillArrayFromStreamL

   438 // ---------------------------------------------------------------------------

   439 //

   440 void CPresentityGroupContentEventImp::FillArrayFromStreamL(

   441         RPrGrpMemInfoImpArray& aArray,

   442         RReadStream& aStream )

   443     {

   444     TInt count = aStream.ReadInt32L();

   445     for( TInt a = 0; a < count; ++a )

   446         {

   447         // the stream MUST be in order (since it was externalized by this class)

   448         CPresentityGroupMemberInfoImp* newInfo = CPresentityGroupMemberInfoImp::NewLC();

   449         newInfo->InternalizeL( aStream );

   450         aArray.AppendL( newInfo );

   451         CleanupStack::Pop(); // newInfo

   452         }

   453     }

   454 

   455 // End of file

   456