C++ HBufC::Mid方法代码示例

EXPORT_C HBufC* CScriptFile::ReplaceLC(const TDesC& aOld, const TDesC& aNew, const TDesC& aOldString)
	{
	HBufC* rString = aOldString.AllocLC();
	TInt oldLen = aOld.Length();
	TInt newLen = aNew.Length();

	if (!oldLen)
		return rString;

	for (TInt pos = 0; pos < rString->Length(); pos += newLen)
		{
		TPtrC ptrC = rString->Mid(pos);
		TInt find = ptrC.Find(aOld);

		if (find == KErrNotFound)
			return rString;
	
		pos += find;

		if (newLen > oldLen)
			{
			rString = rString->ReAllocL(rString->Length() + newLen - oldLen);
			CleanupStack::Pop();
			CleanupStack::PushL(rString);
			}

		TPtr ptr(rString->Des());
		ptr.Replace(pos, oldLen, aNew);
		}

	return rString;
	}

void CZipFileDecompressor::DecompressNextMemberL(CZipFileMember& aMember)
    {
    __ASSERT_ALWAYS(!iUncompressedFile.SubSessionHandle(), 
                    User::Invariant());
    __ASSERT_ALWAYS(!iUncompressedData, User::Invariant());
    
    
    //Ignore entries that has zero uncompressed size.
    //(This includes e.g. directories) 
    if (aMember.UncompressedSize() > 0)
        {
        const TChar KDirectorySeparator('\\');
        
        TUint32 uncompressedSize = aMember.UncompressedSize();
        HBufC8* uncompressedData = HBufC8::NewLC(uncompressedSize);
        
        RZipFileMemberReaderStream* readerStream;
        User::LeaveIfError(iZipFile->GetInputStreamL(&aMember, readerStream));
        CleanupStack::PushL(readerStream);
        
        TPtr8 uncompressedDataPtr = uncompressedData->Des();
        User::LeaveIfError(readerStream->Read(uncompressedDataPtr, 
                                              uncompressedDataPtr.MaxLength()));
        
        CleanupStack::PopAndDestroy(readerStream);
        
        HBufC* fileName = aMember.Name()->AllocLC();
        TPtr fileNamePtr= fileName->Des();
        TInt lastDirectorySeparator = fileName->LocateReverse(KDirectorySeparator);
        if (lastDirectorySeparator >= 0)
            {
            fileNamePtr = fileName->Mid(lastDirectorySeparator+1);
            }
        
        TParsePtr fileNameParser(fileNamePtr);
        
        User::LeaveIfError(iUncompressedFile.Replace(iFileServer, 
                                                     fileNameParser.NameAndExt(), 
                                                     EFileWrite));            
        CleanupStack::PopAndDestroy(fileName);
        
        CleanupStack::Pop(uncompressedData);
        iUncompressedData = uncompressedData;
        
        iUncompressedFile.Write(*iUncompressedData, iStatus);
        SetActive();
        }
    else
        {
        iStatus = KRequestPending;
        SetActive();
        TRequestStatus* ownStatus = &iStatus;
        User::RequestComplete(ownStatus, KErrNone);
        }
    }

// -----------------------------------------------------------------------------
// CWidgetUiObserver::TranslateURLToFilenameL
// Translate the file name from a URL to a valid file name in the system.
// -----------------------------------------------------------------------------
//
TBool CWidgetUiObserver::TranslateURLToFilenameL( const TDesC& aFileName, const TDesC& aLanguageDir )
    {
    // This function accepts URLs in the following format:
    // file://filename.xxx
    // file:///filename.xxx
    // file://c:/filename.xxx
    // file:///c:/filename.xxx
    // c:/dir/file.txt (the browser engine can send these too!)
    TInt count( 0 );
    TInt index( 0 );
    TBool drvLetter = EFalse;
    TUint16 c;
    
    HBufC* decodedUrl = EscapeUtils::EscapeDecodeL(aFileName);
    CleanupStack::PushL( decodedUrl );
    
    // Throw away the intial file:// part, if present
    TPtrC urlPtr( aFileName );
    if (urlPtr.FindF( KFileScheme) == 0 )
        {
        urlPtr.Set( decodedUrl->Mid( KFileScheme().Length() ) );    
        }
    
    // Make sure there are enough characters in the filename before
    // trying to check them
    count = urlPtr.Length() + aLanguageDir.Length() + KLprojExt().Length() + KPathChar().Length();
    if ( urlPtr.Length() > 0 ) //do nothing for trivial input
        {  
    // Skip the first '/' if there is one
    if ( urlPtr[0] == '/' )
        {
        urlPtr.Set( urlPtr.Mid( 1 ) );
        }
    // Is there a drive letter?
    if ( urlPtr.Length() > 1 )
        {
        // Can check for drive letter
        if ( urlPtr[1 + index] == ':' )
            {
            drvLetter = ETrue;
            }
        }
    if ( drvLetter == EFalse )
        {
        // Plan for a c:\ type drive prefix to what we already tallied above
        count += KDefaultDrivePath().Length();
        }
    delete iFileName;
    iFileName = NULL;
    iFileName = HBufC::NewL( count );
    if ( !drvLetter )
        {
        iFileName->Des().Append( KDefaultDrivePath );
        }

    TBool fragment( EFalse );
    // Convert relative path containing /./ and /../ to absolute path
    for ( ; index < urlPtr.Length() && !fragment; index ++ )
        {
        switch ( urlPtr[index] )
            {
            case '#':    // Check if there is a fragment '#'
                {
                fragment = ETrue;
                continue; // Just stop there
                }

            case '/':
                {
                iFileName->Des().Append( KPathChar );
                break;
                }
            case '.':
                {
                if ( index > 1 && urlPtr[index - 1] == '/' )
                    {
                    if ( index < count - 1 && urlPtr[ index + 1 ] == '/' )
                        {
                        index ++; // Skip  ./
                        break;
                        }
                    if ( index > 2 && index < count - 3 &&
                         urlPtr[ index + 1 ] == '.' && urlPtr[ index + 2 ] == '/' )
                        {
                        TInt i = index - 2;

                        for ( ; i > 0 && urlPtr[i] != '/'; i-- ) {} // Skip  /../

                        iFileName->Des().SetLength( iFileName->Des().Length() - (index - i) );
                        index += 2;
                        break;
                        }
                    }
                }
                // No break
//.........这里部分代码省略.........

void CHandleOutSearch::HandleChildElement(TiXmlNode* aElement)
{
	
	TInt index=iPointArray.Count()-1;
	TInt itemIndex=iPointArray[index]->GetItemCount()-1;
	if(itemIndex<0)
	{
		iPointArray[index]->CreatNewItem();
		itemIndex=0;
	}
	if(aElement->NoChildren())
	{
		if(iFlag)
		{
			HBufC* buf = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8((const TUint8*)aElement->Value()));
			CleanupStack::PushL(buf);

			if(buf->Compare(_L("br"))==0)
			{
				if(!iPointArray[index]->GetItem(itemIndex).IsNull())
					iPointArray[index]->CreatNewItem();
			}

			if(buf->Compare(_L("br"))!=0&&buf->Compare(_L("img"))!=0&&buf->Compare(_L("input"))!=0&&buf->Compare(_L("|"))!=0)
			{
				if(buf->Left(2).Compare(_L("--"))==0)
				{
					TInt f=0;
					for(TInt i=0;i<buf->Length();i++)
					{
						if(buf->Mid(i,1).Compare(_L("-"))!=0)
						{
							f=1;
							break;
						}
					}
					
					if(f==0)
					{
						iFlag=EFalse;
					}
				}
				if(iFlag)
					iPointArray[index]->GetItem(itemIndex).SetName(*buf);
				else
				{
					if(!iPointArray[index]->GetItem(itemIndex).IsNull())
						iPointArray[index]->CreatNewItem();
				}
			}

			iMainEngine.WriteLog16(*buf);
			CleanupStack::PopAndDestroy(1);
		}
	}
	else
	{
		HBufC8* tag=TPtrC8((const TUint8*)aElement->Value()).Alloc();
		CleanupStack::PushL(tag);
		TInt value=CheckTag(*tag);
		CleanupStack::PopAndDestroy(1);
		if(value>0)
		{
			switch(value)
			{
				case 1:  //P±êÇ©
					{
						TiXmlNode* element=aElement->FirstChild();
							while(element!=0)
							{
								HandleChildElement(element);
								element=element->NextSibling();
							}
					}
					
					break;
				case 2: //Á¬½Ó±êÇ©
					{
						HBufC8* bufUrl = TPtrC8((const TUint8*)aElement->ToElement()->Attribute("href")).Alloc();
						CleanupStack::PushL(bufUrl);
						TInt urlFlag=CheckUrl(*bufUrl);

						if(urlFlag>0)
						{
							iPointArray[index]->GetItem(itemIndex).SetUrl(*bufUrl);
						}
						CleanupStack::PopAndDestroy(1);

						if(urlFlag==1||urlFlag==2)
						{
							HBufC* buf = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8((const TUint8*)aElement->FirstChild()->Value()));
							CleanupStack::PushL(buf);
							iPointArray[index]->GetItem(itemIndex).SetName(*buf);
							iMainEngine.WriteLog16(*buf);
							CleanupStack::PopAndDestroy(1);

							iPointArray[index]->GetItem(itemIndex).SetIsLink(ETrue);
							iPointArray[index]->CreatNewItem();
						}
						else
//.........这里部分代码省略.........

// -----------------------------------------------------------------------------
// CSisxUIAppInfo::PrepareIteratorL
// Prepares the iterator to be shown in details dialog.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSisxUIAppInfo::PrepareIteratorL( const Swi::CAppInfo& /*aInfo*/ )
    {
    FreeIterator();

    iKeys = new( ELeave )CDesCArrayFlat( 6 );
    iValues = new( ELeave )CDesCArrayFlat( 6 );

    // Name
    SetFieldL( R_SWCOMMON_DETAIL_NAME, Name() );

    // Version
    HBufC* stringBuf = CommonUI::CUIUtils::ConstructVersionStringLC( Version().iMajor,
                                                                     Version().iMinor,
                                                                     Version().iBuild );    
    TPtr ptr = stringBuf->Des();
    AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr ); 
    HBufC* tmpBuf = HBufC::NewLC( KLRE().Length() + stringBuf->Length() + KPDF().Length() ); 
    TInt position = stringBuf->Find( KLeftParenthes() );
    if ( position >= 0 )
        {
        tmpBuf->Des() = stringBuf->Mid( 0, position );
        tmpBuf->Des() += KLRE();
        tmpBuf->Des() += stringBuf->Mid( position, stringBuf->Length() - position );
        tmpBuf->Des() += KPDF();
        }
    else
        {
        tmpBuf->Des() = *stringBuf;	
        }   
    SetFieldL( R_SWCOMMON_DETAIL_VERSION, *tmpBuf );
    CleanupStack::PopAndDestroy( tmpBuf );
    CleanupStack::PopAndDestroy( stringBuf );

     // Supplier
    if ( IsTrusted() )
        {        
        SetFieldL( R_SWCOMMON_DETAIL_SUPPLIER, Vendor() );
        }
    else
        {
        tmpBuf = StringLoader::LoadLC( R_SWCOMMON_DETAIL_VALUE_UNKNOWN_SUPPLIER );
        SetFieldL( R_SWCOMMON_DETAIL_SUPPLIER, *tmpBuf );
        CleanupStack::PopAndDestroy( tmpBuf );        
        }  

    // size
    tmpBuf = StringLoader::LoadLC( R_SWCOMMON_DETAIL_VALUE_UNKNOWN_SIZE );
    SetFieldL( R_SWCOMMON_DETAIL_APPSIZE, *tmpBuf );  
    CleanupStack::PopAndDestroy( tmpBuf );

    // Technology
    tmpBuf = HBufC::NewLC( KLRE().Length() + KSymbian().Length() + KPDF().Length() );
    tmpBuf->Des() = KLRE(); 
    tmpBuf->Des() += KSymbian();
    tmpBuf->Des() += KPDF();
    SetFieldL( R_SWCOMMON_DETAIL_TECHNOLOGY, *tmpBuf ); 
    CleanupStack::PopAndDestroy( tmpBuf );  

    // Type
    tmpBuf = StringLoader::LoadLC( R_SWCOMMON_DETAIL_VALUE_APPLICATION );    
    SetFieldL( R_SWCOMMON_DETAIL_TYPE, *tmpBuf );
    CleanupStack::PopAndDestroy( tmpBuf );    
    }

void CCmdIniEdit::DoRunL()
	{
	TBool interactive = ETrue;
	if (iForce)
		{
		iReader = CIniReader::NewL(iIniFile);
		}
	else
		{
		iReader = CIniFile::NewL(iIniFile, iDescriptionFile);
		}
	TBool updated = EFalse;
		
	if (iSet)
		{
		TInt eqPos = iSet->Find(KEquals);
		TPtrC value(KNullDesC);
		TPtrC id(KNullDesC);
		if (eqPos == KErrNotFound)
			{
			id.Set(*iSet);
			
			Stdin().SetReadModeL(RIoReadHandle::ELine);
			iBuf.CreateL(0x100);
			Stdin().ReadL(iBuf);
			value.Set(iBuf);
			}
		else
			{
			id.Set(iSet->Left(eqPos));
			value.Set(iSet->Mid(eqPos+1));
			}
		
		iReader->SetValueL(Trim(id), value);
		updated = ETrue;
		interactive = EFalse;
		}
	if (iRemove)
		{
		iReader->RemoveValueL(*iRemove);
		updated = ETrue;
		interactive = EFalse;
		}
	
	if (iGet)
		{
		const TDesC* value = iReader->GetValue(*iGet);
		if (!value) LeaveIfErr(KErrNotFound, _L("id '%S' not found in %S"), iGet, &iIniFile);
		Write(*value);
		interactive = EFalse;
		}
	else if (iDump)
		{
		RPointerArray<CValue> values;
		CleanupClosePushL(values);
		iReader->GetValuesL(values);
		for (TInt i=0; i<values.Count(); ++i)
			{
			if (iForce)
				{
				Printf(_L("%S: %S\n"), &values[i]->Id(), &values[i]->Value());
				}
			else
				{
				CSetting* setting = (CSetting*)values[i];
				Printf(_L("%S: %S\n"), &setting->Name(), &setting->Value());
				}
			}
		CleanupStack::PopAndDestroy(&values);
		interactive = EFalse;
		}
	
	if (interactive)
		{
		// TODO enter interactive mode
		LeaveIfErr(KErrNotSupported, _L("Interactive mode not implemented yet."));
		}

	if (updated)
		{
		WriteIniFileL(iIniFile, *iReader);
		}
	}

// -----------------------------------------------------------------------------
// CAknKeyRotatorImpl::GetKeyRotatorCompensationL
// Parses wsini.ini to read key rotator compensation value.
// -----------------------------------------------------------------------------
//
TInt CAknKeyRotatorImpl::GetKeyRotatorCompensationL()
    {
    TInt result = 0;
    HBufC* wsiniText = GetWsiniLC();
    
    // Now look for keyword
    const TInt pos = wsiniText->Find( KAknKeyRotatorKey );
    if ( pos != KErrNotFound )
        {        
        // Keyword was found. Check that it is the beginning of line.
        // Three cases:
        // 1. Keyword could be at the beginning of the file.
        // 2. Keyword could be at the beginning of the file 
        //    after byte ordering marker.
        // 3. Previous character can be end of line marker.
        const TInt previousPos = pos - 1;
        if ( previousPos < 0 || 
             ( !previousPos && 
               IsByteOrderingMarker( (*wsiniText)[ previousPos ] ) ) || 
             IsEndOfLine( (*wsiniText)[ previousPos ] ) )
            {
            TLex text( wsiniText->Mid( pos + KAknKeyRotatorKey().Length() ) );
            
            // First, there must be at least a space after keyword.
            TBool fail = !( SkipSpaces( text ) & EAknWasSpace );
           
            // Case 1: Disabled
            TBool wasDisabled = EFalse;
            if ( !fail )
                {
                wasDisabled = 
                    !text.Remainder().Left( KAknKeyRotatorDisabled().Length() ).
                    CompareF( KAknKeyRotatorDisabled );

                if ( wasDisabled )
                    {
                    // wasDisabled == True, KAknKeyRotatorDisabled was prefix
                    // of text. So skip over it
                    text.Inc( KAknKeyRotatorDisabled().Length() );
                    }
                }
            
            // Case 2: Then follows a sequence of digits, optionally preceded by '-'.
            if ( !wasDisabled && !fail )
                {
                // Check optional -
                TBool negate = EFalse;
                if ( !text.Eos() && text.Peek() == '-' )
                    {
                    negate = ETrue;
                    text.Inc();
                    }
                    
                // Get digit sequence and convert to integer value.
                TPtrC token = GetDigits( text );
                fail = !token.Length() || 
                       ( TLex( token ).Val( result ) != KErrNone );
                
                // Handle negation
                if ( !fail && negate )
                    {
                    result = -result;
                    }
                }

            // That sequence of digits is followed by sequence of spaces until
            // end of line or end of file.
            fail = fail || ( SkipSpaces( text ) & EAknWasCharacter );
            
            if ( !wasDisabled )
                {
                // Finally, that sequence of digits must represent
                // one valid decimal value of the following: 
                // -270, -180, -90, 0, 90, 180, 270.
                fail = fail || !CheckCompensationValue( result );
                }
                
            // If any of above checks failed, use default value 0.
            if ( fail )
                {
                result = 0;
                }
            else
                {
                if ( wasDisabled )
                    {
                    result = KMaxTInt;
                    }
                }
            }
        }
        
    CleanupStack::PopAndDestroy( wsiniText );   
    return result;
    }