LOCAL_C void test1(CArrayFix<TText>& aFix) // { test.Next(_L("AppendL and InsertL single chars")); aFix.AppendL(_S("abcd"),4); test(aFix[0]=='a'); test(aFix[1]=='b'); test(aFix[3]=='d'); test(aFix.Count()==4); aFix.InsertL(2,_S("ef"),2); test(aFix[1]=='b'); test(aFix[2]=='e'); test(aFix[4]=='c'); test(aFix.Count()==6); aFix.AppendL(TText('z')); test(aFix[6]=='z'); aFix.InsertL(0,TText('y')); test(aFix[0]=='y'); test(aFix[1]=='a'); test(aFix.Count()==8); test.Next(_L("Delete single chars")); aFix.Delete(3); test(aFix[2]=='b'); test(aFix[3]=='f'); test(aFix[4]=='c'); aFix.Delete(1,2); test(aFix[0]=='y'); test(aFix[1]=='f'); test(aFix[2]=='c'); test(aFix.Count()==5); aFix.Compress(); }
// --------------------------------------------------------- // FavouritesUtil::ExternalizeL // --------------------------------------------------------- // void FavouritesUtil::ExternalizeL ( const CArrayFix<TInt>& aArray, RWriteStream& aStream ) { aStream.WriteInt32L( aArray.Count() ); for ( TInt i = 0; i < aArray.Count(); i++ ) { aStream.WriteInt32L( aArray[ i ] ); } }
EXPORT_C TInt FontUtils::GetAvailableHeightsInTwipsAndPointsL(const CGraphicsDevice& aDevice,const TDesC& aTypefaceName,CArrayFix<TInt>& aTwipsList,CDesCArray& aPointsList) /** Gets a list of all heights in twips, available for the named typeface and the graphics device specified. Also gets a list of heights in points, represented as character strings. @param aDevice The graphics device. @param aTypefaceName The name of the typeface. @param aTwipsList On return, contains all available heights for the typeface, in twips. @param aPointsList On return, the heights in points, represented as character strings. @return KErrNotSupported if the named typeface is not supported by the graphics device, otherwise KErrNone. */ { // static aTwipsList.Reset(); aPointsList.Reset(); TInt err=GetAvailableHeightsInTwipsL(aDevice,aTypefaceName,aTwipsList); if (err==KErrNotSupported) return err; const TInt count=aTwipsList.Count(); for (TInt ii=0;ii<count;ii++) { const TInt points=PointsFromTwips(aTwipsList[ii]); if (points<EMinFontHeight) continue; TBuf<8> num; num.Num(points); aPointsList.AppendL(num); } return KErrNone; }
// ----------------------------------------------------------------------------- // CPIMAgnToDoAdapter::ExportItemL // (other items were commented in a header) // ----------------------------------------------------------------------------- // void CPIMAgnToDoAdapter::ExportItemL(const MPIMToDoItem& aItem, CCalEntry& aEntry, TBool aResetEntry) { JELOG2(EPim); if (aResetEntry) { // Reset native entry for exporting new data aEntry.SetSummaryL(KNullDesC()); aEntry.SetDescriptionL(KNullDesC()); aEntry.SetPriorityL(0); aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL()); } // Export item data to the native ToDo calendar entry const MPIMItemData& itemData = aItem.ItemData(); CArrayFix<TPIMField>* fields = itemData.FieldsLC(); // Add default values to the calendar entry AddDefaultValuesToEntryL(itemData, aEntry); // Convert each field to the native ToDo calendar entry TInt count = fields->Count(); for (TInt i = 0; i < count; i++) { TPIMToDoField field = static_cast<TPIMToDoField>(fields->At(i)); ConvertToAgnL(field, aEntry, itemData); } CleanupStack::PopAndDestroy(fields); }
EXPORT_C TBool AknPhoneNumberTextUtils::WrapPhoneNumberToArrayL( const TDesC& aPhoneNumberToWrap, TInt aLineWidthInPixels, TInt aMaxLines, const CFont& aFont, CArrayFix<TPtrC>& aWrappedArray ) { TBool retVal( EFalse ); // Not truncated HBufC* reversedText = aPhoneNumberToWrap.AllocLC(); TPtr revPtr = reversedText->Des(); ReverseDescriptor( revPtr ); CArrayFix<TInt>* lineWidthArray = new (ELeave) CArrayFixFlat<TInt>(KLineArrayGranularity); CleanupStack::PushL( lineWidthArray ); lineWidthArray->AppendL( aLineWidthInPixels, aMaxLines ); // Perform the wrap on the reversed text AknTextUtils::WrapToArrayL( revPtr, *lineWidthArray, aFont, aWrappedArray ); // Now rearrange the TPtrCs to point to the original array TInt totalLen = reversedText->Length(); TInt count = aWrappedArray.Count(); TInt usedLen = 0; // Accumulates the length actually used for ( TInt index = 0; index < count; index++) { TPtrC& currentPtr = aWrappedArray.At(index); // The TPtrCs have to be moved. The reversing is taken into effect, but not purely reversed // because their otherwise they would have negative lengths. That is, {a,b} does not go to // { final - a, final - b }, but rather to {final - b, final - a}; they are flipped, to get // their start points before the end points // // Now, representing the start position by pos, and the end by pos+len-1 we have the TPtrC at // {pos, pos+len-1} inclusive, in reversed array. // The TPtrC must be modified to point to {total_len-1 - (pos+len-1), total_len-1 - pos} // in the unreversed array: TInt len = currentPtr.Length(); usedLen += len; TInt pos = currentPtr.Ptr() - reversedText->Ptr(); // pointer arithmetic TInt newPos = totalLen - pos - len; // If the TPtr is zero length then it must get special treatment, as the normal // calculations give an end point before the start point! i.e. {pos, pos-1} // We handle this by NOT flipping in this case. // { pos, pos-1 } -> {totalLen-1-pos, totalLen-1 - (pos-1)} // Note that a zero length wrapped line is completely possible amoung a bunch of other // lines with characters on them, as the line lengths may be of wildly different lengths. if ( len == 0 ) newPos--; currentPtr.Set( aPhoneNumberToWrap.Mid(newPos, len) ); } // If the accumulated length is less than that in the entire input descriptor, then text does not fit if ( usedLen < totalLen ) retVal = ETrue; CleanupStack::PopAndDestroy(2); // lineWidthArray first, and then reversedText return retVal; }
// ----------------------------------------------------------------------------- // CPIMEventPropertyConverter::ConvertExceptionDatesL // Inserts exceptiondates to a parser. // ----------------------------------------------------------------------------- // void CPIMEventPropertyConverter::ConvertExceptionDatesL(const CArrayFix< TPIMDate>& aDates, CParserVCalEntity& aParser) { JELOG2(EPim); TInt exDateCount = aDates.Count(); if (exDateCount > 0) { CArrayPtrFlat<TVersitDateTime>* versitExDates = new(ELeave) CArrayPtrFlat<TVersitDateTime> (exDateCount); CleanupStack::PushL(versitExDates); CleanupResetAndDestroyPushL(*versitExDates); for (TInt i = 0; i < exDateCount; i++) { TVersitDateTime * versitDateTime = new(ELeave) TVersitDateTime(aDates.At(i).DateTime(), TVersitDateTime::EIsUTC); CleanupDeletePushL(versitDateTime); versitExDates->AppendL(versitDateTime); CleanupStack::Pop(versitDateTime); // versitDateTime } CParserPropertyValue* propertyValue = new(ELeave) CParserPropertyValueMultiDateTime(versitExDates); CleanupStack::Pop(2); // versitExDates is now owned by propertyValue AddPropertyToParserL(propertyValue, KVersitTokenEXDATE(), aParser); // Needed cleanup stack items are popped out in the AddPropretyToParserL } }
void QtFallbackWebPopup::showS60BrowserDialog() { static MBrCtlDialogsProvider* dialogs = CBrowserDialogsProvider::NewL(0); if (!dialogs) return; int size = itemCount(); CArrayFix<TBrCtlSelectOptionData>* options = new CArrayFixFlat<TBrCtlSelectOptionData>(qMax(1, size)); RPointerArray<HBufC> items(qMax(1, size)); CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &items)); for (int i = 0; i < size; i++) { if (itemType(i) == Separator) { TBrCtlSelectOptionData data(_L("----------"), false, false, false); options->AppendL(data); } else { HBufC16* itemStr = HBufC16::NewL(itemText(i).length()); itemStr->Des().Copy((const TUint16*)itemText(i).utf16(), itemText(i).length()); CleanupStack::PushL(itemStr); TBrCtlSelectOptionData data(*itemStr, i == currentIndex(), false, itemIsEnabled(i)); options->AppendL(data); items.AppendL(itemStr); CleanupStack::Pop(); } } dialogs->DialogSelectOptionL(KNullDesC(), (TBrCtlSelectOptionType)(ESelectTypeSingle | ESelectTypeWithFindPane), *options); CleanupStack::PopAndDestroy(&items); int newIndex; for (newIndex = 0; newIndex < options->Count() && !options->At(newIndex).IsSelected(); newIndex++) {} if (newIndex == options->Count()) newIndex = currentIndex(); m_popupVisible = false; popupDidHide(); if (currentIndex() != newIndex && newIndex >= 0) valueChanged(newIndex); delete options; }
// ----------------------------------------------------------------------------- // CPIMAgnEventAdapter::ConvertFieldsToAgnL // Reads PIM Item fields and converts them into Agenda entry's fields. // ----------------------------------------------------------------------------- // void CPIMAgnEventAdapter::ConvertFieldsToAgnL(const MPIMEventItem& aItem, CCalEntry& aEntry) { JELOG2(EPim); CArrayFix<TPIMField>* fields = aItem.ItemData().FieldsLC(); TInt amount = fields->Count(); for (int i = 0; i < amount; i++) { TPIMEventField field = static_cast<TPIMEventField>(fields->At(i)); switch (field) { case EPIMEventSummary: // Fallthrough case EPIMEventLocation: // Fallthrough case EPIMEventNote: { ConvertStringFieldToAgnL(aItem, aEntry, field); break; } case EPIMEventAlarm: { ConvertAlarmToAgnL(aItem, aEntry); break; } case EPIMEventStart: // Fallthrough case EPIMEventEnd: { ConvertDateFieldToAgnL(aItem, aEntry, field); break; } case EPIMEventClass: { ConvertClassToAgnL(aItem, aEntry); break; } case EPIMEventRevision: // fallthrough case EPIMEventUid: { // nothing break; } default: { User::Leave(KErrArgument); } } } CleanupStack::PopAndDestroy(fields); }
// ----------------------------------------------------------------------------- // CPIMEventPropertyConverter::GetRepeatRuleFieldsL // Gets the fields from a repeat rule // ----------------------------------------------------------------------------- // void CPIMEventPropertyConverter::GetRepeatRuleFieldsL( const MPIMRepeatRuleData* aRepeat, // Fields are read from this TInt* aInterval, // interval is stored here TInt* aFrequency, // frequency is stored here TVersitDateTime** aVersitEndDate) // end date is stored here { JELOG2(EPim); TBool endExists = EFalse; CArrayFix<TPIMField>* repeatFields = aRepeat->GetFieldsL(); CleanupStack::PushL(repeatFields); TInt fieldCount = repeatFields->Count(); for (TInt i = 0; i < fieldCount; i++) { switch (repeatFields->At(i)) { case EPIMRepeatRuleFrequency: { *aFrequency = aRepeat->GetIntL(EPIMRepeatRuleFrequency); break; } case EPIMRepeatRuleInterval: { *aInterval = aRepeat->GetIntL(EPIMRepeatRuleInterval); break; } case EPIMRepeatRuleEnd: { endExists = ETrue; break; } default: { // We ignore other fields } } } CleanupStack::PopAndDestroy(repeatFields); if (endExists) { TPIMDate endDate = aRepeat->GetDateL(EPIMRepeatRuleEnd); *aVersitEndDate = new(ELeave) TVersitDateTime(endDate.DateTime(), TVersitDateTime::EIsUTC); } }
TInt TDmAdUtil::FindLargestLocallyCreated(const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList) { TRACE("TDmAdUtil::FindLargestLocallyCreated"); TInt largest = 0; for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++) { const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); if (mappingInfo.iURISeg.Find(KDmAdLocallyCreatedRtNodeUriSegPrefix) == 0) { TPtrC8 numberPart(mappingInfo.iURISeg.Mid(KDmAdLocallyCreatedRtNodeUriSegPrefix().Length())); TInt number = TDmAdUtil::DesToInt(numberPart); if (number > largest) { largest = number; } } } return largest; }
EXPORT_C TInt FontUtils::IndexOfNearestHeight(CArrayFix<TInt>& aTwipsList,TInt aHeight) /** Gets the index into the supplied list of font heights of the closest match to the font height specified. @param aTwipsList The twips list. @param aHeight The requested font height. This may be generated by a call to GetAvailableHeightsInTwipsL() or GetAvailableHeightsInTwipsAndPointsL(). @return The index into the list of the closest font height to aHeight. */ { // static TInt pos=0; const TInt count=aTwipsList.Count(); for (TInt ii=0; ii<count; ii++) { if (aTwipsList[ii]>aHeight) break; pos=ii; } return pos; }
TBool CDataWrapperBase::GetPointListFromConfigL(const TDesC& aSectName, const TDesC& aKeyName, CArrayFix<TPoint>& aResult) { TBuf<KMaxTestExecuteCommandLength> tempStore; TPoint point; aResult.Reset(); TBool ok=ETrue; for ( TInt index=0; ok; ) { tempStore.Format(KFormatFieldNumber, &aKeyName, ++index); ok=GetPointFromConfig(aSectName, tempStore, point); if ( ok ) { aResult.AppendL(point); } } return aResult.Count()>0; }
/** Convert between view indexes and contact ids. This method makes the request to the server. @capability ReadUserData */ void RContactRemoteView::GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds) { CBufBase* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); const TInt count = aIndexes.Count(); writeStream.WriteUint32L(count); for (TInt i=0; i<count; ++i) { writeStream.WriteUint32L(aIndexes[i]); } writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); //writeStream.Close() TPtr8 indexes(buffer->Ptr(0)); const TInt bufferSize = buffer->Size(); TPckg<TInt> size(bufferSize); HBufC8* buf=HBufC8::NewLC(bufferSize); TPtr8 ids(buf->Des()); TIpcArgs args(&size, &indexes, &ids); User::LeaveIfError(SendReceive(ECntGetContactIds,args)); RDesReadStream readStream(ids); CleanupClosePushL(readStream); CContactIdArray* array = CContactIdArray::NewLC(); readStream >> *array; const TInt arrayCount = array->Count(); for(TInt loop=0;loop<arrayCount;loop++) aContactIds.AddL((*array)[loop]); CleanupStack::PopAndDestroy(4,buffer); //array, &readStream, buf, buffer }
RPointerArray<CX509Certificate> PkiUtil::GetCaCertListL(RPKIServiceAPI& aPkiService, const CArrayFixFlat<TCertInfo*>& aIkeCAList) { __ASSERT_ALWAYS(aIkeCAList.Count() > 0, User::Invariant()); _LIT8(KEmptyString, ""); RPointerArray<CX509Certificate> certificateArray; ResetAndDestroyPushL(certificateArray); RArray<TUid> applUidArray; CleanupClosePushL(applUidArray); for (TInt i = 0; i < aIkeCAList.Count(); ++i) { const TCertInfo* certInfo = aIkeCAList[i]; switch(certInfo->iFormat) { case CA_NAME: { // Reserve enough space for UTF-8 TInt len = 3*( certInfo->iData.Length() ); HBufC8* caName = HBufC8::NewLC(len); TPtr8 caNamePtr(caName->Des()); if (CnvUtfConverter::ConvertFromUnicodeToUtf8(caNamePtr, certInfo->iData) != 0) { User::Leave(KErrCorrupt); } CX509Certificate* cert = ReadCertificateLC(aPkiService, KEmptyString, *caName, KEmptyString, EPKICACertificate); User::LeaveIfError(certificateArray.Append(cert)); CleanupStack::Pop(cert); CleanupStack::PopAndDestroy(caName); } break; case KEY_ID: { TPKIKeyIdentifier keyId(NULL); for (TInt j = 0; j < certInfo->iData.Length(); j += 2) { TPtrC hexByte(certInfo->iData.Mid(j, 2)); TLex lex(hexByte); TUint8 value; User::LeaveIfError(lex.Val(value, EHex)); keyId.Append(&value, 1); } CX509Certificate* cert = ReadCertificateLC(aPkiService, keyId); User::LeaveIfError(certificateArray.Append(cert)); CleanupStack::Pop(cert); } break; case APPL_UID: { TLex lex(certInfo->iData); TUint32 value; User::LeaveIfError(lex.Val(value, EHex)); TUid id = { value }; User::LeaveIfError(applUidArray.Append(id)); } break; default: User::Leave(KErrArgument); break; } } if (applUidArray.Count() > 0) { CArrayFix<TCertificateListEntry>* certListArray = NULL;; aPkiService.ListApplicableCertificatesL(applUidArray, certListArray); CleanupStack::PushL(certListArray); if (certListArray->Count() == 0) { User::Leave(KErrNotFound); } for (TInt i = 0; i < certListArray->Count(); ++i) { TCertificateListEntry entry = (*certListArray)[i]; if (entry.iOwnerType == EPKICACertificate) { CX509Certificate* cert = ReadCertificateLC(aPkiService, KEmptyString, entry.iIdentitySubjectName, KEmptyString, EPKICACertificate); User::LeaveIfError(certificateArray.Append(cert)); CleanupStack::Pop(cert); } } CleanupStack::PopAndDestroy(certListArray); } CleanupStack::PopAndDestroy(); //applUidArray CleanupStack::Pop(); return certificateArray; }
DMAD_EXPORT_C void TDmAdUtil::BuildRtNodeChildUriListL(MDmAdCallBack* aDmAdCallBack, MDmAdStoreApi* aStoreApi, const TDesC8& aUri, const TDesC8& aParentLuid, const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList, CBufBase& aCurrentList) { #ifdef DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST DEBUG_LOG(_L("BuildRtNodeChildUriListL:")); { for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++) { const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); DEBUG_LOG1(_L("entry %d:"), i); DEBUG_LOG1(_L8("Uri: %S"), &(mappingInfo.iURISeg)); DEBUG_LOG_HEX(mappingInfo.iURISegLUID); } } #endif RPointerArray<HBufC8> luidList; CleanupStack::PushL(TCleanupItem(PointerArrayCleanup, &luidList)); aStoreApi->LuidListL(aUri, aParentLuid, luidList); // Finds largest number used in cli<x> named nodes. TInt largest = FindLargestLocallyCreated(aPreviousUriSegmentList); DEBUG_LOG1(_L("largest is cli%d"), largest); TInt countLuidList = luidList.Count(); for (TInt j=0; j < countLuidList; j++) { const HBufC8* luidElem = luidList[j]; HBufC8* uriSeg = 0; //Tries to find the luid from the aPreviousUriSegmentList for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++) { const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); if (mappingInfo.iURISegLUID.Compare(*luidElem) == 0) { uriSeg = mappingInfo.iURISeg.AllocLC(); break; } } if (uriSeg == 0) { //Uri was not found from the aPreviousUriSegmentList uriSeg = BuildLocallyCreatedRtNodeUriSegLC(largest); DEBUG_LOG2(_L8("uriSeg %S, largest %d"), uriSeg, largest); HBufC8* wholeUri = TDmAdUtil::BuildUriLC(aUri, *uriSeg); aDmAdCallBack->SetMappingL(*wholeUri, *luidElem); CleanupStack::PopAndDestroy(); //wholeUri } //If this is not the first element, inserts slash at the beginning //of the result list. if (j > 0) { aCurrentList.InsertL(aCurrentList.Size(), KDmAdSeparator); } aCurrentList.InsertL(aCurrentList.Size(), *uriSeg); CleanupStack::PopAndDestroy(); // uriSeg } CleanupStack::PopAndDestroy(); //luidList }
LOCAL_C TBool TestGetBodyTextL() { __UHEAP_MARK; // Retrieve the store from the current context... CMsvStore* store = pContext->EditStoreL(); CleanupStack::PushL(store); // Populate CMsvBodyText from the data in the store... CMsvBodyText* obj = CMsvBodyText::NewLC(); obj->RestoreL(*store); // Create a rich text object... CParaFormatLayer* paraLayer = CParaFormatLayer::NewL(); CleanupStack::PushL(paraLayer); CCharFormatLayer* charLayer = CCharFormatLayer::NewL(); CleanupStack::PushL(charLayer); CRichText* richText = CRichText::NewL(paraLayer, charLayer); CleanupStack::PushL(richText); // Create an array of available character sets... CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* charSets; CCnvCharacterSetConverter* converter = CCnvCharacterSetConverter::NewL(); CleanupStack::PushL(converter); charSets = converter->CreateArrayOfCharacterSetsAvailableLC(gFs); // For each available character set, call GetBodyTextL... TInt i; for (i = 0; i < charSets->Count(); i++) { // Over-ride the stored character set. obj->SetCharacterSet((*charSets)[i].Identifier()); // Convert the 8 bit data to the specified character set. obj->GetBodyTextL(gFs, *store, *richText); test(richText->HasChanged()); richText->Reset(); } // Instead of decoding 10 bytes of data, increase the amount of data to 4000 bytes. obj->SetCharacterSet(0); obj->SetDefaultCharacterSet((*charSets)[0].Identifier()); const TInt KTextBufferSize=4000; CBufBase *buffer=CBufFlat::NewL(KTextBufferSize); CleanupStack::PushL(buffer); while(buffer->Size()<KTextBufferSize) { buffer->InsertL(buffer->Size(),K10BytesData); } obj->StoreL(*store, *buffer); CleanupStack::PopAndDestroy(buffer); store->CommitL(); obj->RestoreL(*store); obj->GetBodyTextL(gFs, *store, *richText); test(richText->HasChanged()); // Clean up and release resources... CleanupStack::PopAndDestroy(charSets); CleanupStack::PopAndDestroy(converter); CleanupStack::PopAndDestroy(richText); CleanupStack::PopAndDestroy(charLayer); CleanupStack::PopAndDestroy(paraLayer); CleanupStack::PopAndDestroy(obj); CleanupStack::PopAndDestroy(store); __UHEAP_MARKEND; return ETrue; }
void CIkeV2PkiService::ImportNextCaElemFromIkeDataListL() { __ASSERT_DEBUG(iIkeDataCAList != NULL, User::Invariant()); __ASSERT_DEBUG(iIkeDataCAList->Count() > 0, User::Invariant()); const TCertInfo certInfo = (*iIkeDataCAList)[0]; switch(certInfo.iFormat) { case CA_NAME: delete iSubjName; iSubjName = NULL; iSubjName = HBufC8::NewL(certInfo.iData.Length()); iSubjName->Des().Copy(certInfo.iData); iPkiService.ReadCertificateL(KEmptyString, *iSubjName, KEmptyString, EPKICACertificate, 0, EPKIRSA, iCertPtr, &iResArray, iStatus); SET_ACTIVE; break; case KEY_ID: if (!IkeParser::TextToHexOctets(certInfo.iData, iCertKeyId)) { User::Leave(KErrArgument); } iPkiService.ReadCertificateL(iCertKeyId, iCertPtr, &iResArray, iStatus); SET_ACTIVE; break; case APPL_UID: { //Get the list of applicable CA certs and appends it //to the original list, which was defined in the policy. //After this removes the currently handled node and //calls the method recursively. RArray<TUid>* applUidList = IkeParser::GetApplUidListL(certInfo.iData); CleanupStack::PushL(TCleanupItem(CIkeV2PkiServiceApplUidArrayCleanup, applUidList)); CArrayFix<TCertificateListEntry>* applicableCaCertList; iPkiService.ListApplicableCertificatesL(*applUidList, applicableCaCertList); CleanupStack::PopAndDestroy(); //applUidList if (applicableCaCertList->Count() > 0) { CleanupStack::PushL(applicableCaCertList); TCertInfo* info = new (ELeave) TCertInfo; CleanupDeletePushL(info); for (TInt i = 0; i < applicableCaCertList->Count(); i++) { const TCertificateListEntry& entry = (*applicableCaCertList)[i]; info->iFormat = CA_NAME; info->iData.Zero(); info->iData.Copy(entry.iIdentitySubjectName); iIkeDataCAList->AppendL(*info); DEBUG_LOG1(_L("Appending Applicable cert to the list (%S)"), &(info->iData)); } CleanupStack::PopAndDestroy(info); CleanupStack::PopAndDestroy(applicableCaCertList); iIkeDataCAList->Delete(0); ImportNextCaElemFromIkeDataListL(); } else { delete applicableCaCertList; applicableCaCertList = NULL; iStatus = KRequestPending; SET_ACTIVE; TRequestStatus* status = &iStatus; User::RequestComplete(status, KErrNotFound); } } break; default: User::Leave(KErrArgument); break; } }
LOCAL_C void testFix(CArrayFix<TBuf<0x10> >& aFix) // // Test all methods // { test.Next(_L("Test all methods")); test(aFix.Count()==0); test(aFix.Length()==sizeof(TBuf<0x10>)); aFix.Compress(); test(TRUE); aFix.Reset(); test(TRUE); TKeyArrayFix kk(0,ECmpNormal,0x10); test(TRUE); aFix.Sort(kk); test(TRUE); TBuf<0x10> aa(_L("aaaaa")); aFix.InsertL(0,aa); test(TRUE); aFix[0].Fill(' '); test(TRUE); TBuf<0x10> z(aFix[0]); z.Length(); test(TRUE); aFix[0].Fill('a'); test(TRUE); TInt pp; test(aFix.Find(aa,kk,pp)==0); test(pp==0); aFix.Delete(0); TBuf<0x10> bb(_L("bbbbb")); aFix.AppendL(bb); test(aFix.Count()==1); test(aFix.InsertIsqAllowDuplicatesL(aa,kk)==0); test(aFix.InsertIsqAllowDuplicatesL(bb,kk)==2); test(aFix.FindIsq(aa,kk,pp)==0); test(pp==0); aFix.Reset(); for(TInt index=0;index<KTestGranularity*7/2;index++) aFix.AppendL(aa); const TBuf<0x10> *end=NULL; const TBuf<0x10> *ptr=NULL; for(TInt index2=0;index2<KTestGranularity*7/2;index2++) { if (end==ptr) { end=aFix.End(index2); ptr=&aFix[index2]; TInt seglen=end-ptr; test(seglen==KTestGranularity || seglen==(aFix.Count()-index2)); } test(&aFix[index2]==ptr++); } const TBuf<0x10> *bak=NULL; ptr=NULL; for(TInt index3=KTestGranularity*7/2;index3>0;index3--) { if (bak==ptr) { bak=aFix.Back(index3); ptr=&aFix[index3-1]+1; TInt seglen=ptr-bak; test(seglen==KTestGranularity || seglen==index3 || seglen==index3%KTestGranularity); } test(&aFix[index3-1]==--ptr); } //Test ExpandL //Expand array in slot 1 TBuf16<0x10> exp; exp=_L("abc AbC"); aFix.InsertL(0,exp); aFix.InsertL(1,exp); aFix.InsertL(2,exp); exp=aFix.ExpandL(1); test(aFix[0]==_L("abc AbC")); test(aFix[1]==_L("")); test(aFix[2]==_L("abc AbC")); test(aFix[3]==_L("abc AbC")); //Test ResizeL and InsertReplL //Resize the array to containing 20 records, //copying a record into any new slots. TBuf<0x10> res(_L("bbbbb")); aFix.Reset(); aFix.ResizeL(20,res); for(TInt i=0;i<20;i++) { test(aFix[1]==_L("bbbbb")); } }
LOCAL_C void test2(CArrayFix<TArr<TText,4> >& aFix) // { test(aFix.Length()==sizeof(TArr<TText,4>)); test.Next(_L("AppendL and insert strings of length 4")); TPtrC des1=_L("abcd"); TPtrC des2=_L("efgh"); aFix.AppendL(*(const TArr<TText,4>*)des1.Ptr()); aFix.AppendL(*(const TArr<TText,4>*)des2.Ptr()); test(aFix.Count()==2); TPtrC des3(&aFix[0][0],4); TPtrC des4(&aFix[1][0],4); test(des3==_L("abcd")); test(des4==_L("efgh")); aFix.InsertL(1,*(const TArr<TText,4>*)_S("ijkl")); test(aFix.Count()==3); TPtrC des5(&aFix[2][0],4); test(des3==_L("abcd")); test(des4==_L("ijkl")); test(des5==_L("efgh")); test.Next(_L("Reset and Compress")); aFix.Reset(); TBuf<0x10> buf1=_L("abcdefgh"); aFix.AppendL((const TArr<TText,4>*)buf1.Ptr(),2); aFix.Compress(); TPtrC des6(&aFix[0][0],4); test(des6==_L("abcd")); TPtrC des7(&aFix[1][0],4); test(des7==_L("efgh")); buf1=_L("ghighhxy"); aFix.InsertL(1,(const TArr<TText,4>*)buf1.Ptr(),2); aFix.Compress(); TPtrC des8(&aFix[0][0],4); test(des8==_L("abcd")); TPtrC des9(&aFix[1][0],4); test(des9==_L("ghig")); TPtrC des10(&aFix[2][0],4); test(des10==_L("hhxy")); TPtrC des11(&aFix[3][0],4); test(des11==_L("efgh")); test.Next(_L("Sort strings")); TKeyArrayFix kk(0,ECmpNormal,0x04); aFix.Sort(kk); TPtrC des12(&aFix[0][0],4); test(des12==_L("abcd")); TPtrC des13(&aFix[1][0],4); test(des13==_L("efgh")); TPtrC des14(&aFix[2][0],4); test(des14==_L("ghig")); TPtrC des15(&aFix[3][0],4); test(des15==_L("hhxy")); test.Next(_L("Find and FindIsq")); aFix.Compress(); test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk)==2); aFix.Compress(); test(aFix.InsertIsqAllowDuplicatesL(*(const TArr<TText,4>*)_S("ffff"),kk)==3); aFix.Compress(); TRAPD(r,aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk)) test(r==KErrAlreadyExists); TInt aPos=0; test(aFix.Find(*(const TArr<TText,4>*)_S("xxxx"),kk,aPos)==1); test(aPos==6); test(aFix.Find(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0); test(aPos==0); test(aFix.Find(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0); test(aPos==4); test(aFix.Find(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0); test(aPos==2); test(aFix.Find(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0); test(aPos==5); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("bbbb"),kk,aPos)!=0); test(aPos==1); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0); test(aPos==0); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0); test(aPos==4); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0); test(aPos==2); test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("fghz"),kk)==4); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("fghz"),kk,aPos)==0); test(aPos==4); test(aFix.FindIsq(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0); test(aPos==6); }
// ----------------------------------------------------------------------------- // CWPRoot::CreateLinksL // ----------------------------------------------------------------------------- // void CWPRoot::CreateLinksL() { FLOG( _L( "[Provisioning] CWPRoot::ParameterL2:" ) ); iNeeders.Reset(); delete iNeededIDs; iNeededIDs = NULL; iNeededIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity ); delete iProviderIDs; iProviderIDs = NULL; iProviderIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity ); AcceptL( *this ); // We now have arrays of links and targets of links. Put them together. for( TInt i( 0 ); i < iNeeders.Count(); i++ ) { CWPCharacteristic* needer = iNeeders[i]; TPtrC neededID( iNeededIDs->MdcaPoint( i ) ); TBool foundProvider( EFalse ); for( TInt j( 0 ); j < iProviders.Count() && !foundProvider; j++ ) { CWPCharacteristic* needed = iProviders[j]; TPtrC providerID( iProviderIDs->MdcaPoint( j ) ); if( providerID == neededID ) { if ( needer->Type() == KWPPxPhysical && needed->Type() != KWPNapDef) { // incorrect link found. do nothing. } else { #ifndef __SYNCML_DM_OTA FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL*********** __SYNCML_DM_OTA ***********" ) ); if (KWPApplication == needer->Type()) { _LIT( KNSmlDMProvisioningDMAppIdVal, "w7" ); FLOG (_L( "[Provisioning] CWPRoot::CreateLinksL:Needer is Application" ) ); CArrayFix<TPtrC>* name = new(ELeave) CArrayFixFlat<TPtrC>(1); CleanupStack::PushL(name); needer->ParameterL(EWPParameterAppID, name); if ((name->Count() > 0) && 0 == name->At(0).Compare(KNSmlDMProvisioningDMAppIdVal) ) { CleanupStack::PopAndDestroy(); // name continue; } CleanupStack::PopAndDestroy(); // name } FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL:*********** __SYNCML_DM_OTA ***********" ) ); #endif needer->InsertLinkL( *needed ); foundProvider = ETrue; } } } } // Free the temporary memory iNeeders.Reset(); iProviders.Reset(); delete iNeededIDs; iNeededIDs = NULL; delete iProviderIDs; iProviderIDs = NULL; }