// ---------------------------------------------------------------------------
// CPresenceXDM::GetConditionChildNodeL()
// ---------------------------------------------------------------------------
//
CXdmDocumentNode* CPresenceXDM::GetConditionChildNodeL(const TDesC& aRuleId,
const TDesC& aCondChild, TBool aCreate)
{
OPENG_DP(D_OPENG_LIT( " CPresenceXDM::GetConditionChildNodeL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleId = %S, aCondChild = %S, aCreate = %d"),
&aRuleId, &aCondChild, aCreate);
CXdmDocumentNode* conditionNode = GetRuleChildNodeL(aRuleId, KXdmConditions,
aCreate);
if (!conditionNode)
return NULL;
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* condChildNode(NULL);
// Finding condition child node
conditionNode->Find(aCondChild, nodes);
OPENG_DP(D_OPENG_LIT( " GetcondChildNodeL nodeCount = %d"),nodes.Count());
if(nodes.Count()) // if condition child node exist
{
condChildNode = nodes[0]; // only one condition child node can exist
}
else if (aCreate) // if asked to create
{
condChildNode = conditionNode->CreateChileNodeL(aCondChild);
}
nodes.Close();
return condChildNode;
}
// ---------------------------------------------------------------------------
// CPresenceXDM::GetAllRulesL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceXDM::GetAllRulesL(CDesCArray& aRuleIds)
{
OPENG_DP(D_OPENG_LIT( "CPresenceXDM::GetAllRulesL" ) );
CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot();
if (!myRootNode)
return;
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* idAttribute(NULL);
// Find all rules under root
if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone)
{ // go through all found rules
TInt ruleCountInNode = nodes.Count();
OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode );
for (TInt i=0;i<ruleCountInNode;i++)
{ // get the id attribute
idAttribute = (nodes[i])->Attribute(KXdmId);
// push it to given discriptor array
aRuleIds.AppendL(idAttribute->AttributeValue());
}
}
nodes.Close();
return;
}
void UT_CFCSession::UT_CFCSession_IsFmtAttributeValid2L()
{
RPointerArray<CSdpFmtAttributeField>* atts =
new (ELeave) RPointerArray<CSdpFmtAttributeField>(1);
CleanupStack::PushL(atts);
CSdpFmtAttributeField* fmtatt = CSdpFmtAttributeField::DecodeLC(KInvalid4);
atts->AppendL(fmtatt);
iFCSession->SetFormatAttributeFieldsL(atts);
RPointerArray<CSdpFmtAttributeField>& temparray=iFCSession->FormatAttributeFields();
TInt temp;
for (TInt aCount=0; aCount < temparray.Count(); aCount++)
{
if (fmtatt == temparray[ aCount ])
{
temp=aCount;
}
}
EUNIT_ASSERT(iFCSession->IsFmtAttributeValid()==false)
EUNIT_PRINT(_L( "test is fmtAttributeValid"));
temparray.Close();
CleanupStack::Pop(fmtatt);//fmtatt
atts->Close();
CleanupStack::Pop(atts);//atts
}
// ---------------------------------------------------------------------------
// CPresenceXDM::IsRuleExistInt()
// ---------------------------------------------------------------------------
//
CXdmDocumentNode* CPresenceXDM::IsRuleExistInt(const TDesC& aRuleId)
{
OPENG_DP(D_OPENG_LIT( " CPresenceXDM::IsRuleExistInt(%S)" ),&aRuleId );
CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot();
if (!myRootNode)
return NULL;
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* desiredNode(NULL);
CXdmNodeAttribute* idAttribute(NULL);
// Find all rules under root Node
if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone)
{ // go through all found rules
TInt ruleCountInNode = nodes.Count();
OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode );
for (TInt k=0;k<ruleCountInNode;k++)
{ // get the id attribute
idAttribute = (nodes[k])->Attribute(KXdmId);
// match it with given attr
if (idAttribute->AttributeValue() == aRuleId)
{
desiredNode = nodes[k];
break;
}
}
}
nodes.Close();
return desiredNode;
}
void FmBkupEnginePrivate::ResetAndDestroyArchives( TAny* aPtr )
{
RPointerArray< CMMCScBkupArchiveInfo >* archive =
static_cast< RPointerArray< CMMCScBkupArchiveInfo >* >( aPtr );
archive->ResetAndDestroy();
archive->Close();
}
void UpdateListBoxL()
{
iSettingItemArray->ResetAndDestroy();
RPointerArray<MSettingFactory> activated;
for (TInt ordinal = 0; ordinal < iItemDefs.Count(); ordinal++)
{
TItemDef def = iItemDefs[ ordinal ];
MSettingFactory* factory = def.iFactory;
if ( activated.Find( factory) == KErrNotFound )
{
factory->ActivateL();
activated.AppendL( factory );
}
CAknSettingItem* item = factory->CreateItemL( def.iIdentifier, ordinal );
iSettingItemArray->InsertL( ordinal, item );
//item->SetParentListBox( iListbox );
}
activated.Close();
iSettingItemArray->RecalculateVisibleIndicesL();
// Calling HandleItemAdditional redraws whole list.
iListbox->HandleItemAdditionL();
iListbox->UpdateScrollBarsL();
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::AddIdentitiesInManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::AddIdentitiesInManyExceptL(const TDesC& aRuleID,
const CDesCArray& aIds, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::AddIdentitiesInManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S"),
&aRuleID, &aDomain);
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* exceptNode(NULL);
CXdmNodeAttribute* idattr(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
TInt entitiesCount = aIds.MdcaCount();
if(manyNode!=NULL)
{
for (TInt i = 0; i<entitiesCount; i++)
{
// if id doesnt exists in except
if (!(IsIdentityExistsInManyExceptL(aRuleID, aIds.MdcaPoint(i), aDomain)))
{
exceptNode = manyNode->CreateChileNodeL(KXdmExcept);
idattr = exceptNode->CreateAttributeL(KXdmId);
idattr->SetAttributeValueL(aIds.MdcaPoint(i));
ret = KErrNone;
}
}
ret = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
void RemoveContainerL()
{
if ( iContainer )
{
AppUi()->RemoveFromViewStack( *this, iContainer );
}
RPointerArray<MSettingFactory> deactivated;
for (TInt ordinal = 0; ordinal < iItemDefs.Count(); ordinal++)
{
TItemDef def = iItemDefs[ ordinal ];
MSettingFactory* factory = def.iFactory;
if ( deactivated.Find( factory) == KErrNotFound )
{
factory->DeactivateL();
deactivated.AppendL( factory );
}
}
deactivated.Close();
delete iListbox;
iListbox = NULL;
if ( iSettingItemArray )
iSettingItemArray->ResetAndDestroy();
delete iSettingItemArray;
iSettingItemArray = NULL;
delete iContainer;
iContainer = NULL;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::GetManyIdentityElementsL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::GetManyIdentityElementsL(const TDesC& aRuleID,
CDesCArray& aDomains)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::GetManyIdentityElementsL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID = %S" ),&aRuleID);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID,
KXdmIdentity, EFalse);
if(identityNode==NULL)
return 0;
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* domainAttr(NULL);
// finding 'many' nodes
TInt err = identityNode->Find(KXdmMany, nodes);
// extracting entities from id nodes
TInt manyCountInNode = nodes.Count();
OPENG_DP(D_OPENG_LIT( " manyCountInNode = %d" ),manyCountInNode);
for (TInt i=0; i<manyCountInNode; i++)
{ // get the domain attribute
domainAttr = (nodes[i])->Attribute(KXdmDomain);
if(domainAttr)
// push it to given discriptor array
aDomains.AppendL(domainAttr->AttributeValue());
}
nodes.Close();
return manyCountInNode;
}
// ---------------------------------------------------------------------------
// CPresenceXDM::DeleteEmptyRules()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceXDM::DeleteEmptyRulesL()
{
OPENG_DP(D_OPENG_LIT( "CPresenceXDM::DeleteEmptyRules" ));
CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot();
if (!myRootNode)
return; // return if no rule exists
RPointerArray<CXdmDocumentNode> nodes;
// Find all rules under root Node
if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone)
{ // go through all found rules
TInt ruleCountInNode = nodes.Count();
OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode );
for (TInt i=0;i<ruleCountInNode;i++)
{
if ( ((nodes[i])->NodeCount()) == 0)// if rule is empty
{
iPresDocument->RemoveFromModelL(nodes[i]);
OPENG_DP(D_OPENG_LIT( " delete at i = %d" ), i);
}
}
}
nodes.Close();
}
void CNSmlDummyDataProvider_Test::DoSupportedServerFiltersL()
{
RPointerArray< CSyncMLFilter > filterArray;
filterArray = iCNSmlDummyDataProvider->DoSupportedServerFiltersL();
filterArray.ResetAndDestroy();
filterArray.Close();
}
// ---------------------------------------------------------------------------
// TPresCondValidity::GetValidityNode()
// ---------------------------------------------------------------------------
//
CXdmDocumentNode* TPresCondValidity::GetValidityNodeL(const TDesC& aRuleID,
TBool aCreate)
{
OPENG_DP(D_OPENG_LIT( " TPresCondValidity::GetValidityNodeL()" ) );
OPENG_DP(D_OPENG_LIT( " GetValidityNodeL aRuleID = %S, aCreate = %d"),
&aRuleID, aCreate);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
CXdmDocumentNode* conditionNode = iPresXDM->GetRuleChildNodeL(aRuleID,
KXdmConditions, aCreate);
if (conditionNode==NULL)
return conditionNode;
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* validityNode(NULL);
// Finding sphere node
conditionNode->Find(KXdmValidity, nodes);
OPENG_DP(D_OPENG_LIT( " GetValidityNodeL nodeCount = %d"),nodes.Count());
if(nodes.Count()) // if identity node exist
{
validityNode = nodes[0]; // only one sphere node can exist
}
else if (aCreate) // if asked to create
{
validityNode = conditionNode->CreateChileNodeL(KXdmValidity);
}
nodes.Close();
return validityNode;
}
// ----------------------------------------------------------
// CSimplePresenceList::ResetAndDestroy
// ----------------------------------------------------------
//
void CSimplePresenceList::ResetAndDestroy( TAny* aPtrArray )
{
RPointerArray<CBodyPart>* array =
static_cast<RPointerArray<CBodyPart>*>( aPtrArray );
array->ResetAndDestroy();
array->Close();
}
void CTzUserData::CleanupPointerArray(TAny* aArray)
{
RPointerArray<CTzId>* array = static_cast<RPointerArray<CTzId>* >(aArray);
if (array)
{
array->ResetAndDestroy();
array->Close();
}
}
LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)
{
RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(aPtr);
if (ids)
{
ids->ResetAndDestroy();
ids->Close();
}
}
// -----------------------------------------------------------------------------
// CSvgTimeContainer::UserPlay
// Called to handle user/client generated play event
// -----------------------------------------------------------------------------
//
void CSvgTimeContainer::UserPlay()
{
if ( !iTimer )
{
// Check whether this time container has a parent
// then we do not have to create the timer
if ( !iIsParentTcPresent )
{
// Obtain the post order list of media elements
RPointerArray<CSvgElementImpl> lMediaEleList;
lMediaEleList.Reset();
CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
//Parse postorderr only if there are media elements
if(iTcTimedEntities.Count() > 1 )
{
iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
}
// Rearrange as per Post order
RearrangeTimedEntityList( lMediaEleList );
// Done with the list
lMediaEleList.Close();
TRAPD( lTimerCreateErr, iTimer = CSvgTimer::NewL( this ) );
if ( lTimerCreateErr != KErrNone )
{
// Error Processing
return;
}
iTimer->SetStartTime();
// the current home time needs to be updated.
if ( iOwnerDoc && iCurrentTime != 0 )
{
iCurrentTime = 0;
iCurrentTick.iParentTcTick = 0;
iCurrentTick.iRealTimeTick = 0;
TSvgTimerEvent timeEvent( iCurrentTime );
iOwnerDoc->Reset( &timeEvent );
}
if ( !iTimer->IsActive() )
{
iTimer->After( 1000 );
}
}
}
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::RemoveIdentityFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::RemoveIdentityFromManyExceptL(
const TDesC& aRuleID, const TDesC& aId, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::RemoveIdentityFromManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S,aId:%S"),
&aRuleID, &aDomain, &aId);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* attrId(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
TInt err = manyNode->Find(KXdmExcept, nodes);
TInt exceptNodeCount = nodes.Count();
//go through all except nodes
for (TInt i=0; i<exceptNodeCount; i++)
{
attrId = (nodes[i])->Attribute(KXdmId);
// for now we are supposing that except has only 1 id
if(attrId!=NULL)
{
if (aId==(attrId->AttributeValue()))
{
OPENG_DP(D_OPENG_LIT( " RemoveFromModelL: i=%d" ),i);
iPresXDM->RemoveFromModelL(attrId);
//if except node is empty after this
if( (nodes[i])->AttributeCount() == 0)
{
// remove except node also
iPresXDM->RemoveFromModelL(nodes[i]);
}
ret = KErrNone;
break;
}
}
attrId = NULL;
}
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
void CBURTestStepBackup::BackupPublicDataL()
/**
@internalComponent
@released
*/
{
_LIT(KPublic, "Backup Public Data...");
Log(LOG_LEVEL2, KPublic);
RPointerArray<CSBGenericDataType> array;
TRAP_IGNORE(GeneratePublicTransferTypesL(array));
TRAP_IGNORE(DoPublicBackupL(array));
array.ResetAndDestroy();
array.Close();
}
void UT_CFCSession::UT_CFCSession_IsFmtAttributeValidL()
{
RPointerArray<CSdpFmtAttributeField>* atts =
new (ELeave) RPointerArray<CSdpFmtAttributeField>(1);
CleanupStack::PushL(atts);
CSdpFmtAttributeField* fmtatt = CSdpFmtAttributeField::DecodeLC(KFmtAttribute);
atts->AppendL(fmtatt);
CleanupStack::Pop(fmtatt);//fmtatt
iFCSession->SetFormatAttributeFieldsL(atts);
EUNIT_ASSERT(iFCSession->IsFmtAttributeValid()==true)
EUNIT_PRINT(_L( "test is fmtAttributeValid"));
atts->ResetAndDestroy();
atts->Close();
CleanupStack::Pop(atts);//atts
}
/**
Store the entry in the calendar file
@param aCalEntryView Pointer to the CCalEntryView
@param aCalEntry Pointer to CCalEntry
*/
void CTestCalInterimApiSuiteStepBase::StoreCalendarEntryL(CCalEntryView* aCalEntryView, CCalEntry* aCalEntry)
{
RPointerArray<CCalEntry> entriesStored;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyEntryArray, &entriesStored));
entriesStored.AppendL(aCalEntry);
TInt numOfEntries(0);
aCalEntryView->StoreL(entriesStored, numOfEntries);
if( entriesStored.Count() != numOfEntries )
{
ERR_PRINTF1(KErrEntryNotStored);
SetTestStepResult(EFail);
}
CleanupStack::Pop(&entriesStored);
entriesStored.Close();
}
// -----------------------------------------------------------------------------
// CSvgTimeContainer::AddTimedEntityL
// Add a timed entity to the time container.
// -----------------------------------------------------------------------------
//
void CSvgTimeContainer::AddTimedEntityL(
MSvgTimedEntityInterface* aTimedEntity )
{
if ( !aTimedEntity )
{
User::Leave( KErrArgument );
}
// check to see if entity is already in list and simply return
TInt lTimedEntityListCnt = iTcTimedEntities.Count();
for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
{
if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
{
return;
}
}
TSvgTimedEntityListItem lListItem;
lListItem.iTimedEntity = aTimedEntity;
//Media State initially Idle
lListItem.iMediaState = ESvgMediaIdle;
//User state initially is running
lListItem.iUserState =ESvgUserRunning ;
// Sync State is Playing
lListItem.iIsSyncPaused = EFalse;
// Append to Timed Entity List
iTcTimedEntities.AppendL( lListItem );
// Obtain the post order list of media elements
RPointerArray<CSvgElementImpl> lMediaEleList;
lMediaEleList.Reset();
CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
// Rearrange as per Post order
RearrangeTimedEntityList( lMediaEleList );
// Done with the list
lMediaEleList.Close();
}
// ----------------------------------------------------------------------------
// CSIPRequireHeader::DecodeL
// ----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CSIPRequireHeader>
CSIPRequireHeader::DecodeL (const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> headers = BaseDecodeL(aValue);
CSIPHeaderBase::PushLC(&headers);
RPointerArray<CSIPRequireHeader> requireHeaders;
CleanupClosePushL(requireHeaders);
TInt count = headers.Count();
for (TInt i=0; i<count; i++)
{
CSIPRequireHeader* header = static_cast<CSIPRequireHeader*>(headers[i]);
User::LeaveIfError(requireHeaders.Append(header));
}
CleanupStack::Pop(2); // requireHeaders, headers
headers.Close();
return requireHeaders;
}
EXPORT_C void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,
const CCertAttributeFilter& aFilter,
const TDesC8& aIssuer,
TRequestStatus& aStatus)
{
RPointerArray<const TDesC8> array;
if (array.Append(&aIssuer) != KErrNone)
{
TRequestStatus* status = &aStatus;
User::RequestComplete(status, KErrNoMemory);
}
else
{
List(aCertInfos, aFilter, array, aStatus);
array.Close();
}
}
// -----------------------------------------------------------------------------
// CSIPSecurityVerifyHeader::DecodeL
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CSIPSecurityVerifyHeader>
CSIPSecurityVerifyHeader::DecodeL (const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);
CSIPHeaderBase::PushLC(&baseheaders);
RPointerArray<CSIPSecurityVerifyHeader> verifyHeaders;
CleanupClosePushL(verifyHeaders);
TInt count = baseheaders.Count();
for (TInt i=0; i < count; i++)
{
CSIPSecurityVerifyHeader* header =
static_cast<CSIPSecurityVerifyHeader*>(baseheaders[i]);
verifyHeaders.AppendL(header);
}
CleanupStack::Pop(2); //verifyHeaders, baseheaders
baseheaders.Close();
return verifyHeaders;
}
// -----------------------------------------------------------------------------
// CSIPSecurityClientHeader::DecodeL
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CSIPSecurityClientHeader>
CSIPSecurityClientHeader::DecodeL (const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);
CSIPHeaderBase::PushLC(&baseheaders);
RPointerArray<CSIPSecurityClientHeader> clientHeaders;
CleanupClosePushL(clientHeaders);
TInt count = baseheaders.Count();
for (TInt i=0; i < count; i++)
{
CSIPSecurityClientHeader* header =
static_cast<CSIPSecurityClientHeader*>(baseheaders[i]);
User::LeaveIfError (clientHeaders.Append(header));
}
CleanupStack::Pop(2); //clientHeaders, baseheaders
baseheaders.Close();
return clientHeaders;
}
/*
Print out current tree content
*/
void CLeafDirTree::DumpTreeContentL() const
{
RPointerArray<CLeafDirTreeNode>* nodeStack = new(ELeave) RPointerArray<CLeafDirTreeNode>(4);
RFs fs;
TInt nRes = fs.Connect();
User::LeaveIfError(nRes);
const TUint32 debugRegister = DebugRegister();
fs.SetDebugRegister(debugRegister|KFSYS);
if (iRoot != NULL)
{
nodeStack->Insert(iRoot, 0);
while(nodeStack->Count() > 0)
{
CLeafDirTreeNode* current = (*nodeStack)[0];
if (current->Parent() != NULL)
{
__PRINT3(_L("(\"%S\") -> \"%S\" : (%d)\n"), ¤t->Parent()->Path(), ¤t->Path(), current->StartClusterNum());
}
else
{
__PRINT2(_L("\"%S\" : (%d)\n"), ¤t->Path(), current->StartClusterNum());
}
nodeStack->Remove(0);
TInt currentCount = current->Children().Count();
if (currentCount > 0)
{
RPointerArray<CLeafDirTreeNode> children = current->Children();
for (TInt i = 0; i < currentCount; i++)
{
nodeStack->Insert(children[i], 0);
}
}
}
}
fs.SetDebugRegister(debugRegister);
fs.Close();
nodeStack->Close();
delete nodeStack;
}
void CBadRRule::CheckInstancesL(RArray<TTime> &insTimes)
{
RPointerArray<CCalInstance> instanceArray ;
TCalTime startTime ;
TCalTime endTime ;
startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 1, 10, 1, 0, 0))) ;
endTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 30, 10, 5, 0, 0))) ;
CalCommon::TCalTimeRange timeRange(startTime, endTime);
CCalInstanceView &insView = iTestLib->SynCGetInstanceViewL();
insView.FindInstanceL(instanceArray, CalCommon::EIncludeAll, timeRange);
TInt count = instanceArray.Count() ;
TInt count1 = insTimes.Count() ;
test(count == count1) ;
TInt i, j ;
for(i = 0; i < count1; i++)
{
for(j = 0; j < count; j++)
{
if (instanceArray[j] == NULL)
{
continue ;
}
TTime t1 = instanceArray[j]->Time().TimeUtcL() ;
TDateTime d1 = t1.DateTime() ;
if (insTimes[i] == t1)
{
delete instanceArray[j] ;
instanceArray[j] = NULL ;
break ;
}
}
test(j < count) ;
}
instanceArray.Close() ;
}
// -----------------------------------------------------------------------------
// MceSip::ToContactHeaderL
// -----------------------------------------------------------------------------
//
CSIPContactHeader* MceSip::ToContactHeaderL( const TDesC8& aContact )
{
CSIPContactHeader* contact = NULL;
RPointerArray< CSIPContactHeader > contacts = CSIPContactHeader::DecodeL( aContact );
if ( contacts.Count() > 0 )
{
contact = contacts[0];
contacts.Remove(0);
contacts.ResetAndDestroy();
}
else
{
contacts.Close();
User::Leave( KErrNotFound );
}
return contact;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TInt CEmailMailbox::GetFoldersL( RFolderArray& aFolders ) const
{
TFSMailMsgId rootId = TFSMailMsgId();
RPointerArray<CFSMailFolder> folders;
CleanupResetAndDestroyPushL( folders );
iPlugin->ListFoldersL( FsMailboxId(), rootId, folders );
TInt res( folders.Count() );
for ( TInt i = 0; i < res; i++ )
{
const CFSMailFolder* fsfolder = folders[i];
const TEntryId id = fsfolder->GetFolderId().Id();
const TFolderId folderId( id, iMailboxId );
CEmailFolder* folder = CEmailFolder::NewLC( iPluginData, folderId, folders[i] );
aFolders.AppendL( folder );
CleanupStack::Pop( folder );
}
CleanupStack::Pop( &folders );
folders.Close(); // close but don't delete folders because they are
// owned by CEmailFolder
return res;
}
void UT_CIceCheckPrioritizer::UT_CICECheckPrioritizer_PrioritizeChecksL()
{
CNATFWCandidate* candidate1 = CNATFWCandidate::NewLC();
CNATFWCandidate* candidate2 = CNATFWCandidate::NewLC();
CNATFWCandidatePair* pair = CNATFWCandidatePair::NewLC(
*candidate1, *candidate2 );
CNATFWCandidatePair* pair2 = CNATFWCandidatePair::NewLC( *pair );
RPointerArray<CNATFWCandidatePair> checks;
checks.Append( pair );
checks.Append( pair2 );
iPrioritizer->PrioritizePairs( checks, EIceRoleControlling );
CleanupStack::PopAndDestroy( pair2 );
CleanupStack::PopAndDestroy( pair );
CleanupStack::PopAndDestroy( candidate2 );
CleanupStack::PopAndDestroy( candidate1 );
checks.Close();
}