Symbian

开发平台：

C/C++

S60UIExampledocument.inc：源码内容

inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr),TAny *aPtr)
: iFunction(aFunction),iPtr(aPtr)
#line 294
{}
#line 313
inline TInt TCallBack::CallBack() const
{ return (iFunction ? (*iFunction)(iPtr) : 0); }
template <class T>
inline TSglQue<T>::TSglQue()
#line 335
{}
template <class T>
inline TSglQue<T>::TSglQue(TInt aOffset)
: TSglQueBase(aOffset)
#line 354
{}
template <class T>
inline void TSglQue<T>::AddFirst(T &aRef)
#line 370
{DoAddFirst(&aRef);}
template <class T>
inline void TSglQue<T>::AddLast(T &aRef)
#line 387
{DoAddLast(&aRef);}
template <class T>
inline TBool TSglQue<T>::IsFirst(const T *aPtr) const
#line 402
{return(PtrAdd(aPtr,iOffset)==(T *)iHead);}
template <class T>
inline TBool TSglQue<T>::IsLast(const T *aPtr) const
#line 417
{return(PtrAdd(aPtr,iOffset)==(T *)iLast);}
template <class T>
inline T *TSglQue<T>::First() const
{return(PtrSub((T *)iHead,iOffset));}
template <class T>
inline T *TSglQue<T>::Last() const
{return(PtrSub((T *)iLast,iOffset));}
template <class T>
inline void TSglQue<T>::Remove(T &aRef)
#line 461
{DoRemove(&aRef);}
template <class T>
inline TDblQue<T>::TDblQue()
#line 482
{}
template <class T>
inline TDblQue<T>::TDblQue(TInt aOffset)
: TDblQueBase(aOffset)
#line 501
{}
template <class T>
inline void TDblQue<T>::AddFirst(T &aRef)
#line 517
{DoAddFirst(&aRef);}
template <class T>
inline void TDblQue<T>::AddLast(T &aRef)
#line 534
{DoAddLast(&aRef);}
template <class T>
inline TBool TDblQue<T>::IsHead(const T *aPtr) const
#line 554
{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
template <class T>
inline TBool TDblQue<T>::IsFirst(const T *aPtr) const
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
template <class T>
inline TBool TDblQue<T>::IsLast(const T *aPtr) const
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
template <class T>
inline T *TDblQue<T>::First() const
{
__DbgTestEmpty();
return(PtrSub((T *)iHead.iNext,iOffset));
}
template <class T>
inline T *TDblQue<T>::Last() const
{
__DbgTestEmpty();
return(PtrSub((T *)iHead.iPrev,iOffset));
}
template <class T>
inline TPriQue<T>::TPriQue()
#line 643
{}
template <class T>
inline TPriQue<T>::TPriQue(TInt aOffset)
: TDblQueBase(aOffset)
#line 660
{}
template <class T>
inline void TPriQue<T>::Add(T &aRef)
#line 675
{DoAddPriority(&aRef);}
template <class T>
inline TBool TPriQue<T>::IsHead(const T *aPtr) const
#line 695
{return(PtrAdd(aPtr,iOffset)==(T *)&iHead);}
template <class T>
inline TBool TPriQue<T>::IsFirst(const T *aPtr) const
#line 710
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iNext);}
template <class T>
inline TBool TPriQue<T>::IsLast(const T *aPtr) const
#line 725
{return(PtrAdd(aPtr,iOffset)==(T *)iHead.iPrev);}
template <class T>
inline T *TPriQue<T>::First() const
{return(PtrSub((T *)iHead.iNext,iOffset));}
template <class T>
inline T *TPriQue<T>::Last() const
{return(PtrSub((T *)iHead.iPrev,iOffset));}
template <class T>
inline TDeltaQue<T>::TDeltaQue()
#line 776
{}
template <class T>
inline TDeltaQue<T>::TDeltaQue(TInt aOffset)
: TDeltaQueBase(aOffset)
#line 797
{}
template <class T>
inline void TDeltaQue<T>::Add(T &aRef,TInt aDelta)
#line 815
{DoAddDelta(&aRef,aDelta);}
template <class T>
inline void TDeltaQue<T>::Remove(T &aRef)
#line 830
{DoRemove(&aRef);}
template <class T>
inline T *TDeltaQue<T>::RemoveFirst()
{return((T *) DoRemoveFirst());}
template <class T>
inline TSglQueIter<T>::TSglQueIter(TSglQueBase &aQue)
: TSglQueIterBase(aQue)
#line 871
{}
template <class T>
inline void TSglQueIter<T>::Set(T &aLink)
#line 887
{DoSet(&aLink);}
template <class T>
inline TSglQueIter<T>::operator T *()
#line 902
{return((T *)DoCurrent());}
template <class T>
inline T *TSglQueIter<T>::operator++(TInt)
#line 919
{return((T *)DoPostInc());}
template <class T>
inline TDblQueIter<T>::TDblQueIter(TDblQueBase &aQue)
: TDblQueIterBase(aQue)
#line 948
{}
template <class T>
inline void TDblQueIter<T>::Set(T &aLink)
#line 964
{DoSet(&aLink);}
template <class T>
inline TDblQueIter<T>::operator T *()
#line 985
{return((T *) DoCurrent());}
template <class T>
inline T *TDblQueIter<T>::operator++(TInt)
#line 1003
{return((T *) DoPostInc());}
template <class T>
inline T *TDblQueIter<T>::operator--(TInt)
#line 1021
{return((T *) DoPostDec());}
inline void TKey::SetPtr(const TAny *aPtr)
#line 1042
{iPtr=aPtr;}
inline TCharF::TCharF(TUint aChar)
: TChar(User::Fold(aChar))
{}
inline TCharF::TCharF(const TChar& aChar)
: TChar(User::Fold(aChar))
{}
inline TCharF& TCharF::operator=(TUint aChar)
{SetChar(User::Fold(aChar));return(*this);}
inline TCharF& TCharF::operator=(const TChar& aChar)
{SetChar(User::Fold(aChar));return(*this);}
inline TCharLC::TCharLC(TUint aChar)
: TChar(User::LowerCase(aChar))
{}
inline TCharLC::TCharLC(const TChar& aChar)
: TChar(User::LowerCase(aChar))
{}
inline TCharLC& TCharLC::operator=(TUint aChar)
{SetChar(User::LowerCase(aChar));return(*this);}
inline TCharLC& TCharLC::operator=(const TChar& aChar)
#line 1150
{SetChar(User::LowerCase(aChar));return(*this);}
inline TCharUC::TCharUC(TUint aChar)
: TChar(User::UpperCase(aChar))
{}
inline TCharUC::TCharUC(const TChar& aChar)
: TChar(User::UpperCase(aChar))
{}
inline TCharUC& TCharUC::operator=(TUint aChar)
{SetChar(User::UpperCase(aChar));return(*this);}
inline TCharUC& TCharUC::operator=(const TChar& aChar)
#line 1204
{SetChar(User::UpperCase(aChar));return(*this);}
inline TDateTime::TDateTime()
: iYear(1980),
iMonth(EJanuary),
iDay(1),
iHour(0),
iMinute(0),
iSecond(0),
iMicroSecond(0)
{}
inline TInt TDateTime::Year() const
{return(iYear);}
inline TMonth TDateTime::Month() const
{return(iMonth);}
inline TInt TDateTime::Day() const
{return(iDay);}
inline TInt TDateTime::Hour() const
{return(iHour);}
inline TInt TDateTime::Minute() const
{return(iMinute);}
inline TInt TDateTime::Second() const
{return(iSecond);}
inline TInt TDateTime::MicroSecond() const
{return(iMicroSecond);}
inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds()
{}
inline TTimeIntervalMicroSeconds::TTimeIntervalMicroSeconds(const TInt64& aInterval)
: iInterval(aInterval)
{}
inline TTimeIntervalMicroSeconds& TTimeIntervalMicroSeconds::operator=(const TInt64& aInterval)
{iInterval=aInterval;return(*this);}
inline TBool TTimeIntervalMicroSeconds::operator==(const TTimeIntervalMicroSeconds& aInterval) const
#line 1354
{return(iInterval==aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator!=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1368
{return(iInterval!=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator>=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1383
{return(iInterval>=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator<=(const TTimeIntervalMicroSeconds& aInterval) const
#line 1398
{return(iInterval<=aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator>(const TTimeIntervalMicroSeconds& aInterval) const
#line 1413
{return(iInterval>aInterval.iInterval);}
inline TBool TTimeIntervalMicroSeconds::operator<(const TTimeIntervalMicroSeconds& aInterval) const
#line 1428
{return(iInterval<aInterval.iInterval);}
inline const TInt64& TTimeIntervalMicroSeconds::Int64() const
{return(iInterval);}
inline TTimeIntervalBase::TTimeIntervalBase()
{}
inline TTimeIntervalBase::TTimeIntervalBase(TInt aInterval)
: iInterval(aInterval)
{}
inline TBool TTimeIntervalBase::operator==(TTimeIntervalBase aInterval) const
{return(iInterval==aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator!=(TTimeIntervalBase aInterval) const
#line 1488
{return(iInterval!=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator>=(TTimeIntervalBase aInterval) const
#line 1503
{return(iInterval>=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator<=(TTimeIntervalBase aInterval) const
#line 1518
{return(iInterval<=aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator>(TTimeIntervalBase aInterval) const
#line 1532
{return(iInterval>aInterval.iInterval);}
inline TBool TTimeIntervalBase::operator<(TTimeIntervalBase aInterval) const
#line 1546
{return(iInterval<aInterval.iInterval);}
inline TInt TTimeIntervalBase::Int() const
{return(iInterval);}
inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32()
{}
inline TTimeIntervalMicroSeconds32::TTimeIntervalMicroSeconds32(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMicroSeconds32& TTimeIntervalMicroSeconds32::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalSeconds::TTimeIntervalSeconds()
{}
inline TTimeIntervalSeconds::TTimeIntervalSeconds(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalSeconds& TTimeIntervalSeconds::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalMinutes::TTimeIntervalMinutes()
{}
inline TTimeIntervalMinutes::TTimeIntervalMinutes(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMinutes& TTimeIntervalMinutes::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalHours::TTimeIntervalHours()
{}
inline TTimeIntervalHours::TTimeIntervalHours(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalHours& TTimeIntervalHours::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalDays::TTimeIntervalDays()
{}
inline TTimeIntervalDays::TTimeIntervalDays(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalDays& TTimeIntervalDays::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalMonths::TTimeIntervalMonths()
{}
inline TTimeIntervalMonths::TTimeIntervalMonths(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalMonths& TTimeIntervalMonths::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTimeIntervalYears::TTimeIntervalYears()
{}
inline TTimeIntervalYears::TTimeIntervalYears(TInt aInterval)
: TTimeIntervalBase(aInterval)
{}
inline TTimeIntervalYears& TTimeIntervalYears::operator=(TInt aInterval)
{iInterval=aInterval;return(*this);}
inline TTime::TTime()
{}
inline TTime::TTime(const TInt64& aTime)
: iTime(aTime)
{}
inline TTime &TTime::operator=(const TInt64& aTime)
{iTime=aTime;return(*this);}
inline TBool TTime::operator==(TTime aTime) const
{return(iTime==aTime.iTime);}
inline TBool TTime::operator!=(TTime aTime) const
{return(iTime!=aTime.iTime);}
inline TBool TTime::operator>=(TTime aTime) const
#line 1890
{return(iTime>=aTime.iTime);}
inline TBool TTime::operator<=(TTime aTime) const
#line 1905
{return(iTime<=aTime.iTime);}
inline TBool TTime::operator>(TTime aTime) const
#line 1919
{return(iTime>aTime.iTime);}
inline TBool TTime::operator<(TTime aTime) const
#line 1933
{return(iTime<aTime.iTime);}
inline const TInt64& TTime::Int64() const
{return(iTime);}
inline TLexMark8::TLexMark8()
: iPtr(0 )
{}
inline TLexMark8::TLexMark8(const TUint8 *aString)
: iPtr(aString)
{}
inline TLex8::TLex8(const TUint8 *aString)
#line 1977
{Assign(TPtrC8(aString));}
inline TLex8::TLex8(const TDesC8 &aDes)
#line 1991
{Assign(aDes);}
inline TLex8& TLex8::operator=(const TUint8* aString)
{Assign(TPtrC8(aString));return(*this);}
inline TLex8& TLex8::operator=(const TDesC8& aBuf)
{Assign(aBuf);return(*this);}
inline TBool TLex8::Eos() const
{return(iNext==iEnd);}
inline void TLex8::Mark()
{Mark(iMark);}
inline void TLex8::Mark(TLexMark8& aMark) const
{aMark.iPtr=iNext;}
inline void TLex8::UnGetToMark()
{UnGetToMark(iMark);}
inline void TLex8::SkipAndMark(TInt aNumber)
#line 2074
{SkipAndMark(aNumber,iMark);}
inline void TLex8::SkipSpaceAndMark()
{SkipSpaceAndMark(iMark);}
inline TInt TLex8::TokenLength() const
#line 2100
{return(iNext-iMark.iPtr);}
inline TInt TLex8::MarkedOffset() const
{return(iMark.iPtr-iBuf);}
inline TInt TLex8::Val(TInt &aVal)
#line 2129
{return(Val((TInt32&)aVal));}
inline TInt TLex8::Val(TUint &aVal,TRadix aRadix)
#line 2149
{return(Val((TUint32&)aVal,aRadix));}
inline void TLex8::Assign(const TLex8& aLex)
{new(this) TLex8(aLex);}
inline TLexMark16::TLexMark16()
: iPtr(0 )
{}
inline TLexMark16::TLexMark16(const TUint16 *aString)
: iPtr(aString)
{}
inline TLex16::TLex16(const TUint16 *aString)
#line 2193
{Assign(TPtrC16(aString));}
inline TLex16::TLex16(const TDesC16 &aDes)
#line 2207
{Assign(aDes);}
inline TLex16& TLex16::operator=(const TUint16* aString)
{Assign(TPtrC16(aString));return(*this);}
inline TLex16& TLex16::operator=(const TDesC16& aBuf)
{Assign(aBuf);return(*this);}
inline TBool TLex16::Eos() const
{return(iNext==iEnd);}
inline void TLex16::Mark(TLexMark16& aMark) const
{aMark.iPtr=iNext;}
inline void TLex16::Mark()
{iMark.iPtr=iNext;}
inline void TLex16::UnGetToMark()
{UnGetToMark(iMark);}
inline void TLex16::SkipAndMark(TInt aNumber)
#line 2289
{SkipAndMark(aNumber,iMark);}
inline void TLex16::SkipSpaceAndMark()
{SkipSpaceAndMark(iMark);}
inline TInt TLex16::TokenLength() const
#line 2315
{return(iNext-iMark.iPtr);}
inline TInt TLex16::MarkedOffset() const
{return(iMark.iPtr-iBuf);}
inline TInt TLex16::Val(TInt &aVal)
#line 2344
{return(Val((TInt32&)aVal));}
inline TInt TLex16::Val(TUint &aVal,TRadix aRadix)
#line 2364
{return(Val((TUint32&)aVal,aRadix));}
inline void TLex16::Assign(const TLex16& aLex)
{new(this) TLex16(aLex);}
inline TLocale::TLocale(TInt)
{}
inline TInt TLocale::CountryCode() const
#line 2393
{return(iCountryCode);}
inline void TLocale::SetCountryCode(TInt aCode)
#line 2410
{iCountryCode=aCode;}
inline TTimeIntervalSeconds TLocale::UniversalTimeOffset() const
#line 2426
{return(iUniversalTimeOffset);}
inline TDateFormat TLocale::DateFormat() const
{return(iDateFormat);}
inline void TLocale::SetDateFormat(TDateFormat aFormat)
{iDateFormat=aFormat;}
inline TTimeFormat TLocale::TimeFormat() const
{return(iTimeFormat);}
inline void TLocale::SetTimeFormat(TTimeFormat aFormat)
{iTimeFormat=aFormat;}
inline TLocalePos TLocale::CurrencySymbolPosition() const
#line 2486
{return(iCurrencySymbolPosition);}
inline void TLocale::SetCurrencySymbolPosition(TLocalePos aPos)
{iCurrencySymbolPosition=aPos;}
inline TBool TLocale::CurrencySpaceBetween() const
#line 2513
{return(iCurrencySpaceBetween);}
inline void TLocale::SetCurrencySpaceBetween(TBool aSpace)
{iCurrencySpaceBetween=aSpace;}
inline TInt TLocale::CurrencyDecimalPlaces() const
{return(iCurrencyDecimalPlaces);}
inline void TLocale::SetCurrencyDecimalPlaces(TInt aPlaces)
{iCurrencyDecimalPlaces=aPlaces;}
inline TBool TLocale::CurrencyNegativeInBrackets() const
#line 2567
{return((TBool)iNegativeCurrencyFormat);}
inline void TLocale::SetCurrencyNegativeInBrackets(TBool aBool)
#line 2587
{iNegativeCurrencyFormat=(aBool)?EInBrackets:ELeadingMinusSign;}
inline TBool TLocale::CurrencyTriadsAllowed() const
{return(iCurrencyTriadsAllowed);}
inline void TLocale::SetCurrencyTriadsAllowed(TBool aBool)
{iCurrencyTriadsAllowed=aBool;}
inline TChar TLocale::ThousandsSeparator() const
#line 2625
{return(iThousandsSeparator);}
inline void TLocale::SetThousandsSeparator(const TChar& aChar)
#line 2640
{iThousandsSeparator=aChar;}
inline TChar TLocale::DecimalSeparator() const
{return(iDecimalSeparator);}
inline void TLocale::SetDecimalSeparator(const TChar& aChar)
{iDecimalSeparator=aChar;}
inline TChar TLocale::DateSeparator(TInt aIndex) const
#line 2682
{return(iDateSeparator[aIndex]);}
inline void TLocale::SetDateSeparator(const TChar& aChar,TInt aIndex)
#line 2700
{(void)((aIndex>=0 && aIndex<KMaxDateSeparators)||(User::Invariant(),0)) ;
iDateSeparator[aIndex]=aChar;}
inline TChar TLocale::TimeSeparator(TInt aIndex) const
#line 2721
{return(iTimeSeparator[aIndex]);}
inline void TLocale::SetTimeSeparator(const TChar& aChar,TInt aIndex)
#line 2739
{(void)((aIndex>=0 && aIndex<KMaxTimeSeparators)||(User::Invariant(),0)) ;
iTimeSeparator[aIndex]=aChar;}
inline TLocalePos TLocale::AmPmSymbolPosition() const
{return(iAmPmSymbolPosition);}
inline void TLocale::SetAmPmSymbolPosition(TLocalePos aPos)
{iAmPmSymbolPosition=aPos;}
inline TBool TLocale::AmPmSpaceBetween() const
{return(iAmPmSpaceBetween);}
inline void TLocale::SetAmPmSpaceBetween(TBool aSpace)
{iAmPmSpaceBetween=aSpace;}
inline TUint TLocale::DaylightSaving() const
#line 2817
{return(iDaylightSaving);}
inline TBool TLocale::QueryHomeHasDaylightSavingOn() const
#line 2832
{return((iHomeDaylightSavingZone|EDstHome) & iDaylightSaving);}
inline TDaylightSavingZone TLocale::HomeDaylightSavingZone() const
{return(iHomeDaylightSavingZone);}
inline TUint TLocale::WorkDays() const
#line 2859
{return(iWorkDays);}
inline void TLocale::SetWorkDays(TUint aMask)
{iWorkDays=aMask;}
inline TDay TLocale::StartOfWeek() const
{return(iStartOfWeek);}
inline void TLocale::SetStartOfWeek(TDay aDay)
{iStartOfWeek=aDay;}
inline TClockFormat TLocale::ClockFormat() const
{return(iClockFormat);}
inline void TLocale::SetClockFormat(TClockFormat aFormat)
{iClockFormat=aFormat;}
inline TUnitsFormat TLocale::UnitsGeneral() const
#line 2930
{return(iUnitsGeneral);}
inline void TLocale::SetUnitsGeneral(TUnitsFormat aFormat)
{iUnitsGeneral=aFormat;}
inline TUnitsFormat TLocale::UnitsDistanceShort() const
#line 2957
{return(iUnitsDistanceShort);}
inline void TLocale::SetUnitsDistanceShort(TUnitsFormat aFormat)
#line 2971
{iUnitsDistanceShort=aFormat;}
inline TUnitsFormat TLocale::UnitsDistanceLong() const
#line 2985
{return(iUnitsDistanceLong);}
inline void TLocale::SetUnitsDistanceLong(TUnitsFormat aFormat)
#line 2999
{iUnitsDistanceLong=aFormat;}
inline void TLocale::SetNegativeCurrencyFormat(TLocale::TNegativeCurrencyFormat aNegativeCurrencyFormat)
{iNegativeCurrencyFormat = aNegativeCurrencyFormat;}
inline TLocale::TNegativeCurrencyFormat TLocale::NegativeCurrencyFormat() const
{return(iNegativeCurrencyFormat);}
inline TBool TLocale::NegativeLoseSpace() const
{
if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeLoseSpace)==iExtraNegativeCurrencyFormatFlags)
return ETrue;
else
return EFalse;
}
inline void TLocale::SetNegativeLoseSpace(TBool aBool)
{
if(aBool)
iExtraNegativeCurrencyFormatFlags |= EFlagNegativeLoseSpace;
else
iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeLoseSpace;
}
inline TBool TLocale::NegativeCurrencySymbolOpposite() const
#line 3074
{
if((iExtraNegativeCurrencyFormatFlags|EFlagNegativeCurrencySymbolOpposite)==iExtraNegativeCurrencyFormatFlags)
return ETrue;
else
return EFalse;
}
inline void TLocale::SetNegativeCurrencySymbolOpposite(TBool aBool)
#line 3097
{
if (aBool)
iExtraNegativeCurrencyFormatFlags |= EFlagNegativeCurrencySymbolOpposite;
else
iExtraNegativeCurrencyFormatFlags &= ~EFlagNegativeCurrencySymbolOpposite;
}
inline TLanguage TLocale::LanguageDowngrade(TInt aIndex) const
#line 3130
{
(void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
return static_cast<TLanguage>(iLanguageDowngrade[aIndex]);
}
inline void TLocale::SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage)
#line 3151
{
(void)((0 <= aIndex && aIndex < 3)||( User::Invariant(),0)) ;
iLanguageDowngrade[aIndex] = static_cast<TUint16>(aLanguage);
}
#line 3164
inline TDigitType TLocale::DigitType() const
{ return iDigitType; }
#line 3175
inline void TLocale::SetDigitType(TDigitType aDigitType)
{ iDigitType=aDigitType; }
#line 3188
inline void TLocale::SetDeviceTime(TDeviceTimeState aState)
{
iDeviceTimeState=aState;
}
inline TLocale* TExtendedLocale::GetLocale()
{ return &iLocale; }
#line 3205
inline TLocale::TDeviceTimeState TLocale::DeviceTime() const
{
return iDeviceTimeState;
}
inline TInt TFindHandleBase::Handle() const
#line 3225
{return(iFindHandle);}
inline TFindSemaphore::TFindSemaphore()
: TFindHandleBase()
#line 3244
{}
inline TFindSemaphore::TFindSemaphore(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3264
{}
inline TFindMutex::TFindMutex()
: TFindHandleBase()
#line 3283
{}
inline TFindMutex::TFindMutex(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3303
{}
inline TFindChunk::TFindChunk()
: TFindHandleBase()
#line 3322
{}
inline TFindChunk::TFindChunk(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3339
{}
inline TFindThread::TFindThread()
: TFindHandleBase()
#line 3358
{}
inline TFindThread::TFindThread(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3373
{}
inline TFindProcess::TFindProcess()
: TFindHandleBase()
#line 3392
{}
inline TFindProcess::TFindProcess(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3407
{}
inline TFindLogicalDevice::TFindLogicalDevice()
: TFindHandleBase()
{}
inline TFindLogicalDevice::TFindLogicalDevice(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TFindPhysicalDevice::TFindPhysicalDevice()
: TFindHandleBase()
{}
inline TFindPhysicalDevice::TFindPhysicalDevice(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TFindServer::TFindServer()
: TFindHandleBase()
#line 3446
{}
inline TFindServer::TFindServer(const TDesC &aMatch)
: TFindHandleBase(aMatch)
#line 3463
{}
inline TFindLibrary::TFindLibrary()
: TFindHandleBase()
{}
inline TFindLibrary::TFindLibrary(const TDesC &aMatch)
: TFindHandleBase(aMatch)
{}
inline TInt RDevice::Open(const TFindLogicalDevice& aFind,TOwnerType aType)
{return(RHandleBase::Open(aFind,aType));}
inline TBool RCriticalSection::IsBlocked() const
{return(iBlocked!=1);}
inline TInt RMutex::Open(const TFindMutex& aFind,TOwnerType aType)
#line 3536
{return(RHandleBase::Open(aFind,aType));}
inline TInt RChunk::Open(const TFindChunk& aFind,TOwnerType aType)
#line 3560
{return(RHandleBase::Open(aFind,aType));}
inline TBool RChunk::IsReadable() const
{return (Attributes()&RHandleBase::EDirectReadAccess); }
inline TBool RChunk::IsWritable() const
{return (Attributes()&RHandleBase::EDirectWriteAccess); }
inline TObjectId::TObjectId()
{}
inline TObjectId::TObjectId(TUint64 aId)
: iId(aId)
{}
inline TUint64 TObjectId::Id() const
{ return iId; }
inline TObjectId::operator TUint() const
{ return TUint(iId); }
inline TBool TObjectId::operator==(TObjectId aId) const
{return iId==aId.iId;}
inline TBool TObjectId::operator!=(TObjectId aId) const
{return iId!=aId.iId;}
inline TThreadId::TThreadId()
: TObjectId()
{}
inline TThreadId::TThreadId(TUint64 aId)
: TObjectId(aId)
{}
inline RThread::RThread()
: RHandleBase(KCurrentThreadHandle)
#line 3691
{}
inline TInt RThread::Open(const TFindThread& aFind,TOwnerType aType)
#line 3714
{return(RHandleBase::Open(aFind,aType));}
inline TBool RThread::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline TBool RThread::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 3761
inline TProcessId::TProcessId()
: TObjectId()
{}
inline TProcessId::TProcessId(TUint64 aId)
: TObjectId(aId)
{}
inline RProcess::RProcess()
: RHandleBase(KCurrentProcessHandle)
#line 3795
{}
inline RProcess::RProcess(TInt aHandle)
: RHandleBase(aHandle)
{}
inline TInt RProcess::Open(const TFindProcess& aFind,TOwnerType aType)
#line 3830
{return(RHandleBase::Open(aFind,aType));}
inline TBool RProcess::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline TBool RProcess::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 3902
inline TInt RSessionBase::CreateSession(const TDesC& aServer,const TVersion& aVersion)
{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
#line 3926
inline TInt RSessionBase::CreateSession(RServer2 aServer,const TVersion& aVersion)
{return CreateSession(aServer,aVersion,-1,EIpcSession_Unsharable,0 ,0);}
#line 3950
inline TInt RSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSend(aFunction,&aArgs);}
#line 3971
inline void RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
{DoSendReceive(aFunction,&aArgs,aStatus);}
#line 3992
inline TInt RSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSendReceive(aFunction,&aArgs);}
#line 4014
inline TInt RSessionBase::Send(TInt aFunction) const
{return DoSend(aFunction,0 );}
#line 4033
inline void RSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
{ DoSendReceive(aFunction,0 ,aStatus);}
#line 4055
inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError)
{ return RHandleBase::SetReturnedHandle(aHandleOrError);}
inline TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle)
{ return RHandleBase::SetReturnedHandle(aHandleOrError,aHandle);}
#line 4076
inline TInt RSessionBase::SendReceive(TInt aFunction) const
{return DoSendReceive(aFunction,0 );}
inline RSubSessionBase::RSubSessionBase()
: iSubSessionHandle(0)
{}
inline TInt RSubSessionBase::SubSessionHandle() const
#line 4102
{return iSubSessionHandle;}
inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs)
{ return DoCreateSubSession(aSession,aFunction,&aArgs); }
inline TInt RSubSessionBase::CreateSubSession(const RSessionBase& aSession,TInt aFunction)
{ return DoCreateSubSession(aSession,aFunction,0 ); }
inline TInt RSubSessionBase::Send(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSend(aFunction,&aArgs);}
inline void RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const
{DoSendReceive(aFunction,&aArgs,aStatus);}
inline TInt RSubSessionBase::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const
{return DoSendReceive(aFunction,&aArgs);}
inline TInt RSubSessionBase::Send(TInt aFunction) const
{return DoSend(aFunction,0 );}
inline void RSubSessionBase::SendReceive(TInt aFunction,TRequestStatus& aStatus) const
{ DoSendReceive(aFunction,0 ,aStatus);}
inline TInt RSubSessionBase::SendReceive(TInt aFunction) const
{return DoSendReceive(aFunction,0 );}
#line 4132
inline RRefBase::RRefBase()
: iPtr(0 )
{}
#line 4143
inline RRefBase::RRefBase(const RRefBase &aRef)
{Copy(aRef);}
#line 4155
template <class T>
inline RRef<T>::RRef()
{}
#line 4171
template <class T>
inline RRef<T>::RRef(const RRef<T> &anObject)
{Copy(anObject);}
#line 4188
template <class T>
inline void RRef<T>::operator=(const RRef<T> &anObject)
{Copy(anObject);}
#line 4200
template <class T>
inline T *RRef<T>::operator->()
{return((T *)iPtr);}
#line 4212
template <class T>
inline RRef<T>::operator T*()
{return((T *)iPtr);}
#line 4228
template <class T>
void RRef<T>::Alloc(const T &anObject)
{DoAlloc(&anObject,sizeof(T));}
#line 4245
template <class T>
void RRef<T>::Alloc(const T &anObject,TInt aSize)
{DoAlloc(&anObject,aSize);}
#line 4261
template <class T>
void RRef<T>::AllocL(const T &anObject)
{DoAllocL(&anObject,sizeof(T));}
#line 4278
template <class T>
void RRef<T>::AllocL(const T &anObject,TInt aSize)
{DoAllocL(&anObject,aSize);}
inline TBool TRegion::CheckError() const
#line 4307
{return(iError);}
inline TInt TRegion::Count() const
{return(iCount);}
inline const TRect *TRegion::RectangleList() const
#line 4333
{return(((TRegion *)this)->RectangleListW());}
inline TRegion::TRegion()
{}
inline TInt RRegion::CheckSpare() const
#line 4354
{return(iAllocedRects-iCount);}
template <TInt S>
inline TRegionFix<S>::TRegionFix() : TRegion(-S)
{}
template <TInt S>
inline TRegionFix<S>::TRegionFix(const TRect &aRect) : TRegion(-S)
{AddRect(aRect);}
template <TInt S>
inline TRegionFix<S>::TRegionFix(const TRegionFix<S> &aRegion)
{*this=aRegion;}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf() : RRegion(-S&(~ERRegionBuf),S)
{}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const RRegion &aRegion)
{*this=aRegion;}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const TRect &aRect) : RRegion(-S&(~ERRegionBuf),S)
#line 4427
{AddRect(aRect);}
template <TInt S>
inline RRegionBuf<S>::RRegionBuf(const RRegionBuf<S> &aRegion)
{*this=aRegion;}
inline TTimerLockSpec &operator++(TTimerLockSpec &aLock)
{
return aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
}
inline TTimerLockSpec operator++(TTimerLockSpec &aLock, TInt)
{
TTimerLockSpec l=aLock;
aLock=((aLock==ETwelveOClock) ? EOneOClock : (TTimerLockSpec)((TInt)aLock+1));
return l;
}
inline const TUidType& TCheckedUid::UidType() const
{return(iType);}
template <class T>
void _DeleteArray(T** aBegin,T** aEnd)
{for (;;) if (aBegin<aEnd) delete *aBegin++; else return;}
template <class T>
struct _ArrayUtil
{
static inline void Delete(T* aBegin,T* aEnd,CBase*)
{::_DeleteArray((CBase**)aBegin,(CBase**)aEnd);}
static inline void Delete(T* aBegin,T* aEnd,TAny*)
{::_DeleteArray(aBegin,aEnd);}
static inline void Delete(T* aArray,TInt aCount)
{Delete(aArray,aArray+aCount,*aArray);}
};
__declspec(dllexport) void PanicTFixedArray();
template <class T,TInt S>
inline TFixedArray<T,S>::TFixedArray()
{}
template <class T,TInt S>
inline void TFixedArray<T,S>::Copy(const T* aList,TInt aLength)
#line 4529
{(void)((TUint(aLength)<=TUint(S))||(PanicTFixedArray(),0)) ;Mem::Copy(iRep,aList,aLength*sizeof(T));}
template <class T,TInt S>
inline TFixedArray<T,S>::TFixedArray(const T* aList,TInt aLength)
#line 4547
{Copy(aList,aLength);}
template <class T,TInt S>
inline void TFixedArray<T,S>::Reset()
{Mem::FillZ(iRep,sizeof(iRep));}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::Count() const
#line 4572
{return S;}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::Length() const
{return sizeof(T);}
template <class T,TInt S>
inline TBool TFixedArray<T,S>::InRange(TInt aIndex)
{return TUint(aIndex)<S;}
template <class T,TInt S>
inline T& TFixedArray<T,S>::operator[](TInt aIndex)
#line 4610
{(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
template <class T,TInt S>
inline const T& TFixedArray<T,S>::operator[](TInt aIndex) const
#line 4630
{return (const_cast<ThisClass&>(*this)) [aIndex];}
template <class T,TInt S>
inline T& TFixedArray<T,S>::At(TInt aIndex)
#line 4649
{(void)((InRange(aIndex))||(PanicTFixedArray(),0)) ;return iRep[aIndex];}
template <class T,TInt S>
inline const T& TFixedArray<T,S>::At(TInt aIndex) const
#line 4669
{return (const_cast<ThisClass&>(*this)) .At(aIndex);}
template <class T,TInt S>
inline T* TFixedArray<T,S>::Begin()
{return &iRep[0];}
template <class T,TInt S>
inline T* TFixedArray<T,S>::End()
{return &iRep[S];}
template <class T,TInt S>
inline const T* TFixedArray<T,S>::Begin() const
{return &iRep[0];}
template <class T,TInt S>
inline const T* TFixedArray<T,S>::End() const
{return &iRep[S];}
template <class T,TInt S>
inline TInt TFixedArray<T,S>::CountFunctionR(const CBase*)
{return S;}
template <class T,TInt S>
inline const TAny* TFixedArray<T,S>::AtFunctionR(const CBase* aThis,TInt aIndex)
{return &(reinterpret_cast<const ThisClass&>(*aThis)) [aIndex];}
template <class T,TInt S>
inline TArray<T> TFixedArray<T,S>::Array() const
{return TArray<T>(CountFunctionR,AtFunctionR,(reinterpret_cast<const CBase*>(this)) );}
template <class T,TInt S>
inline void TFixedArray<T,S>::DeleteAll()
#line 4759
{_ArrayUtil<T>::Delete(iRep,S);}
inline RHeap* User::SwitchHeap(RAllocator* aHeap)
{ return (RHeap*)SwitchAllocator(aHeap); }
inline RHeap& User::Heap()
{ return (RHeap&)Allocator(); }
inline TBool User::CreatorHasCapability(TCapability aCapability, const char* aDiagnostic)
{
return DoCreatorHasCapability(aCapability, aDiagnostic);
}
inline TBool User::CreatorHasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic)
{
return DoCreatorHasCapability(aCapability1, aCapability2, aDiagnostic);
}
#line 4833
inline void TSecurityInfo::SetToCurrentInfo()
{ new (this) TSecurityInfo(RProcess()); }
inline void TSecurityInfo::Set(RProcess aProcess)
{ new (this) TSecurityInfo(aProcess); }
inline void TSecurityInfo::Set(RThread aThread)
{ new (this) TSecurityInfo(aThread); }
inline void TSecurityInfo::Set(RMessagePtr2 aMsgPtr)
{ new (this) TSecurityInfo(aMsgPtr); }
#line 4869
inline TBool TSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
{
return DoCheckPolicy(aProcess, aDiagnostic);
}
#line 4892
inline TBool TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
{
return DoCheckPolicy(aThread, aDiagnostic);
}
#line 4914
inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
{
return DoCheckPolicy(aMsgPtr, aDiagnostic);
}
#line 4938
inline TBool TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
{
return DoCheckPolicy(aMsgPtr, aMissing, aDiagnostic);
}
#line 4958
inline TBool TSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
{
return DoCheckPolicyCreator(aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RProcess aProcess, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aProcess, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aThread, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aMsgPtr, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const
{
return (&(*this))->CheckPolicy(aMsgPtr, aMissing, aDiagnostic);
}
inline TBool TStaticSecurityPolicy::CheckPolicyCreator(const char* aDiagnostic) const
{
return (&(*this))->CheckPolicyCreator(aDiagnostic);
}
#line 5241
template <class T>
inline void RPointerArray<T>::AppendL(const T* anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5262
template <class T>
inline void RPointerArray<T>::InsertL(const T* anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry,aPos)); }
#line 5282
template <class T>
inline TInt RPointerArray<T>::FindL(const T* anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5306
template <class T>
inline TInt RPointerArray<T>::FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const
{ return User::LeaveIfError(Find(anEntry, anIdentity));}
#line 5324
template <class T>
inline TInt RPointerArray<T>::FindInAddressOrderL(const T* anEntry) const
{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
#line 5347
template <class T>
inline TInt RPointerArray<T>::FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const
{ return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
#line 5370
template <class T>
inline void RPointerArray<T>::FindInAddressOrderL(const T* anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
#line 5398
template <class T>
inline void RPointerArray<T>::FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder)); }
#line 5430
template <class T>
inline TInt RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
#line 5466
template <class T>
inline TInt RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
#line 5504
template <class T>
inline void RPointerArray<T>::SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
#line 5546
template <class T>
inline void RPointerArray<T>::SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode)); }
#line 5564
template <class T>
inline void RPointerArray<T>::InsertInAddressOrderL(const T* anEntry)
{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
#line 5592
template <class T>
inline void RPointerArray<T>::InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrder(anEntry, anOrder)); }
#line 5614
template <class T>
inline void RPointerArray<T>::InsertInAddressOrderAllowRepeatsL(const T* anEntry)
{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
#line 5639
template <class T>
inline void RPointerArray<T>::InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder)); }
#line 5656
template <class T>
inline void RPointerArray<T>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 5673
inline void RPointerArray<TAny>::AppendL(const TAny* anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5693
inline void RPointerArray<TAny>::InsertL(const TAny* anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry,aPos)); }
#line 5712
inline TInt RPointerArray<TAny>::FindL(const TAny* anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5729
inline TInt RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry) const
{ return User::LeaveIfError(FindInAddressOrder(anEntry));}
#line 5751
inline void RPointerArray<TAny>::FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInAddressOrder(anEntry, anIndex)); }
#line 5782
inline TInt RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInAddressOrder(anEntry, aMode));}
#line 5819
inline void RPointerArray<TAny>::SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInAddressOrder(anEntry, anIndex, aMode)); }
#line 5835
inline void RPointerArray<TAny>::InsertInAddressOrderL(const TAny* anEntry)
{ User::LeaveIfError(InsertInAddressOrder(anEntry)); }
#line 5856
inline void RPointerArray<TAny>::InsertInAddressOrderAllowRepeatsL(const TAny* anEntry)
{ User::LeaveIfError(InsertInAddressOrderAllowRepeats(anEntry)); }
#line 5869
template <class T>
inline void RArray<T>::AppendL(const T& anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 5890
template <class T>
inline void RArray<T>::InsertL(const T& anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 5912
template <class T>
inline TInt RArray<T>::FindL(const T& anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 5937
template <class T>
inline TInt RArray<T>::FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const
{ return User::LeaveIfError(Find(anEntry, anIdentity));}
#line 5956
template <class T>
inline TInt RArray<T>::FindInSignedKeyOrderL(const T& anEntry) const
{ return User::LeaveIfError(FindInSignedKeyOrder(anEntry));}
#line 5975
template <class T>
inline TInt RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry) const
{ return User::LeaveIfError(FindInUnsignedKeyOrder(anEntry));}
#line 5997
template <class T>
inline TInt RArray<T>::FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const
{ return User::LeaveIfError(FindInOrder(anEntry, anOrder));}
#line 6018
template <class T>
inline void RArray<T>::FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInSignedKeyOrder(anEntry, anIndex));}
#line 6039
template <class T>
inline void RArray<T>::FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInUnsignedKeyOrder(anEntry, anIndex));}
#line 6063
template <class T>
inline void RArray<T>::FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex, anOrder));}
#line 6096
template <class T>
inline TInt RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, aMode));}
#line 6130
template <class T>
inline TInt RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, aMode));}
#line 6166
template <class T>
inline TInt RArray<T>::SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, anOrder, aMode));}
#line 6207
template <class T>
inline void RArray<T>::SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInSignedKeyOrder(anEntry, anIndex, aMode));}
#line 6246
template <class T>
inline void RArray<T>::SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInUnsignedKeyOrder(anEntry, anIndex, aMode));}
#line 6288
template <class T>
inline void RArray<T>::SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, anOrder, aMode));}
#line 6309
template <class T>
inline void RArray<T>::InsertInSignedKeyOrderL(const T& anEntry)
{ User::LeaveIfError(InsertInSignedKeyOrder(anEntry));}
#line 6329
template <class T>
inline void RArray<T>::InsertInUnsignedKeyOrderL(const T& anEntry)
{ User::LeaveIfError(InsertInUnsignedKeyOrder(anEntry));}
#line 6355
template <class T>
inline void RArray<T>::InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrder(anEntry, anOrder));}
#line 6378
template <class T>
inline void RArray<T>::InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry)
{ User::LeaveIfError(InsertInSignedKeyOrderAllowRepeats(anEntry));}
#line 6401
template <class T>
inline void RArray<T>::InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry)
{ User::LeaveIfError(InsertInUnsignedKeyOrderAllowRepeats(anEntry));}
#line 6427
template <class T>
inline void RArray<T>::InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry, anOrder));}
#line 6444
template <class T>
inline void RArray<T>::ReserveL(TInt aCount)
{ User::LeaveIfError(RArrayBase::DoReserve(aCount)); }
#line 6460
inline void RArray<TInt>::AppendL(TInt anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 6479
inline void RArray<TInt>::InsertL(TInt anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 6497
inline TInt RArray<TInt>::FindL(TInt anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 6514
inline TInt RArray<TInt>::FindInOrderL(TInt anEntry) const
{ return User::LeaveIfError(FindInOrder(anEntry));}
#line 6535
inline void RArray<TInt>::FindInOrderL(TInt anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
#line 6566
inline TInt RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
#line 6603
inline void RArray<TInt>::SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
#line 6623
inline void RArray<TInt>::InsertInOrderL(TInt anEntry)
{ User::LeaveIfError(InsertInOrder(anEntry));}
#line 6645
inline void RArray<TInt>::InsertInOrderAllowRepeatsL(TInt anEntry)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
#line 6661
inline void RArray<TInt>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 6676
inline void RArray<TUint>::AppendL(TUint anEntry)
{ User::LeaveIfError(Append(anEntry));}
#line 6696
inline void RArray<TUint>::InsertL(TUint anEntry, TInt aPos)
{ User::LeaveIfError(Insert(anEntry, aPos));}
#line 6713
inline TInt RArray<TUint>::FindL(TUint anEntry) const
{ return User::LeaveIfError(Find(anEntry));}
#line 6731
inline TInt RArray<TUint>::FindInOrderL(TUint anEntry) const
{ return User::LeaveIfError(FindInOrder(anEntry));}
#line 6755
inline void RArray<TUint>::FindInOrderL(TUint anEntry, TInt& anIndex) const
{ User::LeaveIfError(FindInOrder(anEntry, anIndex));}
#line 6786
inline TInt RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt aMode) const
{ return User::LeaveIfError(SpecificFindInOrder(anEntry, aMode));}
#line 6822
inline void RArray<TUint>::SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const
{ User::LeaveIfError(SpecificFindInOrder(anEntry, anIndex, aMode));}
#line 6842
inline void RArray<TUint>::InsertInOrderL(TUint anEntry)
{ User::LeaveIfError(InsertInOrder(anEntry));}
#line 6864
inline void RArray<TUint>::InsertInOrderAllowRepeatsL(TUint anEntry)
{ User::LeaveIfError(InsertInOrderAllowRepeats(anEntry));}
#line 6880
inline void RArray<TUint>::ReserveL(TInt aCount)
{ User::LeaveIfError(RPointerArrayBase::DoReserve(aCount)); }
#line 6891
inline void RMessagePtr2::SetProcessPriorityL(TProcessPriority aPriority) const
{ User::LeaveIfError(SetProcessPriority(aPriority));}
#line 6903
inline void RMessagePtr2::ClientL(RThread& aClient, TOwnerType aOwnerType) const
{ User::LeaveIfError(Client(aClient, aOwnerType));}
inline TBool RMessagePtr2::HasCapability(TCapability aCapability, const char* aDiagnostic) const
{
return DoHasCapability(aCapability, aDiagnostic);
}
inline void RMessagePtr2::HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage) const
{
if (!HasCapability(aCapability, aDiagnosticMessage))
{
User::Leave(KErrPermissionDenied);
}
}
inline TBool RMessagePtr2::HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic) const
{
return DoHasCapability(aCapability1, aCapability2, aDiagnostic);
}
inline void RMessagePtr2::HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage) const
{
if (!HasCapability(aCapability1, aCapability2, aDiagnosticMessage))
{
User::Leave(KErrPermissionDenied);
}
}
#line 6995
inline TInt RThread::RenameMe(const TDesC& aName)
{ return User::RenameThread(aName); }
inline TInt RProcess::RenameMe(const TDesC& aName)
{ return User::RenameProcess(aName); }
#line 7044
extern "C" bool __uncaught_exception(void);
namespace std {
inline bool uncaught_exception(void) { return ::__uncaught_exception(); }
}
#line 4892 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 6 */
#line 10 "C:\Symbian\9.1\S60_3rd\epoc32\include\coeaui.h" /* stack depth 5 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 6 */
#line 13
class CBase
#line 42
{
public:
inline CBase() {}
__declspec(dllexport) virtual ~CBase();
inline TAny* operator new(TUint aSize, TAny* aBase) throw() ;
inline TAny* operator new(TUint aSize) throw() ;
inline TAny* operator new(TUint aSize, TLeave);
inline TAny* operator new(TUint aSize, TUint aExtraSize) throw() ;
inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
__declspec(dllexport) static void Delete(CBase* aPtr);
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
CBase(const CBase&);
CBase& operator=(const CBase&);
private:
};
class CBufBase : public CBase
#line 86
{
public:
__declspec(dllexport) ~CBufBase();
inline TInt Size() const;
__declspec(dllexport) void Reset();
__declspec(dllexport) void Read(TInt aPos,TDes8& aDes) const;
__declspec(dllexport) void Read(TInt aPos,TDes8& aDes,TInt aLength) const;
__declspec(dllexport) void Read(TInt aPos,TAny* aPtr,TInt aLength) const;
__declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes);
__declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes,TInt aLength);
__declspec(dllexport) void Write(TInt aPos,const TAny* aPtr,TInt aLength);
__declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes);
__declspec(dllexport) void InsertL(TInt aPos,const TDesC8& aDes,TInt aLength);
__declspec(dllexport) void InsertL(TInt aPos,const TAny* aPtr,TInt aLength);
__declspec(dllexport) void ExpandL(TInt aPos,TInt aLength);
__declspec(dllexport) void ResizeL(TInt aSize);
#line 117
virtual void Compress()=0;
#line 131
virtual void Delete(TInt aPos,TInt aLength)=0;
#line 147
virtual TPtr8 Ptr(TInt aPos)=0;
#line 168
virtual TPtr8 BackPtr(TInt aPos)=0;
private:
virtual void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength)=0;
protected:
__declspec(dllexport) CBufBase(TInt anExpandSize);
protected:
TInt iSize;
TInt iExpandSize;
};
class CBufFlat : public CBufBase
#line 195
{
public:
__declspec(dllexport) ~CBufFlat();
__declspec(dllexport) static CBufFlat* NewL(TInt anExpandSize);
inline TInt Capacity() const;
__declspec(dllexport) void SetReserveL(TInt aSize);
__declspec(dllexport) void Compress();
__declspec(dllexport) void Delete(TInt aPos,TInt aLength);
__declspec(dllexport) TPtr8 Ptr(TInt aPos);
__declspec(dllexport) TPtr8 BackPtr(TInt aPos);
protected:
__declspec(dllexport) CBufFlat(TInt anExpandSize);
private:
__declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
TInt iMaxSize;
TUint8* iPtr;
};
class TBufSegLink;
class CBufSeg : public CBufBase
#line 238
{
public:
__declspec(dllexport) ~CBufSeg();
__declspec(dllexport) static CBufSeg* NewL(TInt anExpandSize);
__declspec(dllexport) void Compress();
__declspec(dllexport) void Delete(TInt aPos,TInt aLength);
__declspec(dllexport) TPtr8 Ptr(TInt aPos);
__declspec(dllexport) TPtr8 BackPtr(TInt aPos);
protected:
__declspec(dllexport) CBufSeg(TInt anExpandSize);
void InsertIntoSegment(TBufSegLink* aSeg,TInt anOffset,const TAny* aPtr,TInt aLength);
void DeleteFromSegment(TBufSegLink* aSeg,TInt anOffset,TInt aLength);
void FreeSegment(TBufSegLink* aSeg);
void SetSBO(TInt aPos);
void AllocSegL(TBufSegLink* aSeg,TInt aNumber);
private:
__declspec(dllexport) void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
TDblQue<TBufSegLink> iQue;
TBufSegLink* iSeg;
TInt iBase;
TInt iOffset;
};
class TKeyArrayFix : public TKey
#line 289
{
public:
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayFix(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase,TInt aRecordLength);
__declspec(dllexport) TAny* At(TInt anIndex) const;
protected:
TInt iRecordLength;
CBufBase* iBase;
friend class CArrayFixBase;
};
typedef CBufBase*(*TBufRep)(TInt anExpandSize);
class CArrayFixBase : public CBase
#line 319
{
public:
__declspec(dllexport) ~CArrayFixBase();
inline TInt Count() const;
inline TInt Length() const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) TInt Sort(TKeyArrayFix& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) TAny* End(TInt anIndex) const;
__declspec(dllexport) TAny* Back(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr);
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aCount);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TKeyArrayFix& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TKeyArrayFix& aKey);
__declspec(dllexport) void ResizeL(TInt aCount,const TAny* aPtr);
protected:
__declspec(dllexport) CArrayFixBase(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
__declspec(dllexport) void InsertRepL(TInt anIndex,const TAny* aPtr,TInt aReplicas);
__declspec(dllexport) void SetKey(TKeyArrayFix& aKey) const;
__declspec(dllexport) void SetReserveFlatL(TInt aCount);
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TInt iLength;
TBufRep iCreateRep;
CBufBase* iBase;
};
template <class T>
class CArrayFix : public CArrayFixBase
#line 370
{
public:
inline CArrayFix(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline const T* End(TInt anIndex) const;
inline const T* Back(TInt anIndex) const;
inline T& At(TInt anIndex);
inline T* End(TInt anIndex);
inline T* Back(TInt anIndex);
inline void AppendL(const T& aRef);
inline void AppendL(const T* aPtr,TInt aCount);
inline void AppendL(const T& aRef,TInt aReplicas);
inline T& ExpandL(TInt anIndex);
inline T& ExtendL();
inline TInt Find(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayFix& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef);
inline void InsertL(TInt anIndex,const T* aPtr,TInt aCount);
inline void InsertL(TInt anIndex,const T& aRef,TInt aReplicas);
inline TInt InsertIsqL(const T& aRef,TKeyArrayFix& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TKeyArrayFix& aKey);
inline void ResizeL(TInt aCount);
inline void ResizeL(TInt aCount,const T& aRef);
inline const TArray<T> Array() const;
};
template<> class CArrayFix<TAny> : public CArrayFixBase
#line 413
{
public:
inline CArrayFix(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline const TAny* End(TInt anIndex) const;
inline const TAny* Back(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline TAny* End(TInt anIndex);
inline TAny* Back(TInt anIndex);
inline void AppendL(const TAny* aPtr);
inline void AppendL(const TAny* aPtr,TInt aCount);
inline TAny* ExtendL();
};
template <class T>
class CArrayFixFlat : public CArrayFix<T>
#line 452
{
public:
inline explicit CArrayFixFlat(TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TAny> : public CArrayFix<TAny>
#line 479
{
public:
inline CArrayFixFlat(TInt aRecordLength,TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TInt> : public CArrayFix<TInt>
#line 498
{
public:
__declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
__declspec(dllexport) ~CArrayFixFlat();
inline void SetReserveL(TInt aCount);
};
template<> class CArrayFixFlat<TUid> : public CArrayFix<TUid>
#line 518
{
public:
__declspec(dllexport) explicit CArrayFixFlat(TInt aGranularity);
__declspec(dllexport) ~CArrayFixFlat();
inline void SetReserveL(TInt aCount);
};
template <class T>
class CArrayFixSeg : public CArrayFix<T>
#line 545
{
public:
inline explicit CArrayFixSeg(TInt aGranularity);
};
template<> class CArrayFixSeg<TAny> : public CArrayFix<TAny>
#line 571
{
public:
inline CArrayFixSeg(TInt aRecordLength,TInt aGranularity);
};
template <class T>
class CArrayPtr : public CArrayFix<T*>
#line 591
{
public:
inline CArrayPtr(TBufRep aRep,TInt aGranularity);
void ResetAndDestroy();
};
template <class T>
class CArrayPtrFlat : public CArrayPtr<T>
#line 624
{
public:
inline explicit CArrayPtrFlat(TInt aGranularity);
inline void SetReserveL(TInt aCount);
};
template <class T>
class CArrayPtrSeg : public CArrayPtr<T>
#line 652
{
public:
inline explicit CArrayPtrSeg(TInt aGranularity);
};
class TKeyArrayVar : public TKey
#line 689
{
public:
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayVar(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase);
__declspec(dllexport) TAny* At(TInt anIndex) const;
protected:
CBufBase* iBase;
friend class CArrayVarBase;
};
class CArrayVarBase : public CBase
#line 718
{
public:
__declspec(dllexport) ~CArrayVarBase();
inline TInt Count() const;
__declspec(dllexport) TInt Length(TInt anIndex) const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) TInt Sort(TKeyArrayVar& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
protected:
__declspec(dllexport) CArrayVarBase(TBufRep aRep,TInt aGranularity);
__declspec(dllexport) void SetKey(TKeyArrayVar& aKey) const;
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TBufRep iCreateRep;
CBufBase* iBase;
};
template <class T>
class CArrayVar : public CArrayVarBase
#line 762
{
public:
inline CArrayVar(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline T& At(TInt anIndex);
inline void AppendL(const T& aRef,TInt aLength);
inline T& ExpandL(TInt anIndex,TInt aLength);
inline T& ExtendL(TInt aLength);
inline TInt Find(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayVar& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayVar& aKey);
inline const TArray<T> Array() const;
};
template<> class CArrayVar<TAny> : public CArrayVarBase
#line 799
{
public:
inline CArrayVar(TBufRep aRep,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline void AppendL(const TAny* aPtr,TInt aLength);
inline TAny* ExtendL(TInt aLength);
};
template <class T>
class CArrayVarFlat : public CArrayVar<T>
#line 828
{
public:
inline explicit CArrayVarFlat(TInt aGranularity);
};
template <class T>
class CArrayVarSeg : public CArrayVar<T>
#line 853
{
public:
inline explicit CArrayVarSeg(TInt aGranularity);
};
class TKeyArrayPak : public TKeyArrayVar
#line 890
{
public:
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType);
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKeyArrayPak(TInt anOffset,TKeyCmpNumeric aType);
protected:
__declspec(dllexport) virtual void Set(CBufBase* aBase);
__declspec(dllexport) TAny* At(TInt anIndex) const;
private:
TInt iCacheIndex;
TInt iCacheOffset;
friend class CArrayPakBase;
};
class CArrayPakBase : public CBase
#line 916
{
public:
__declspec(dllexport) ~CArrayPakBase();
inline TInt Count() const;
__declspec(dllexport) TInt Length(TInt anIndex) const;
__declspec(dllexport) void Compress();
__declspec(dllexport) void Reset();
__declspec(dllexport) void SortL(TKeyArrayVar& aKey);
__declspec(dllexport) TAny* At(TInt anIndex) const;
__declspec(dllexport) void Delete(TInt anIndex);
__declspec(dllexport) void Delete(TInt anIndex,TInt aCount);
__declspec(dllexport) TAny* ExpandL(TInt anIndex,TInt aLength);
__declspec(dllexport) TInt Find(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
__declspec(dllexport) TInt FindIsq(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
__declspec(dllexport) void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
__declspec(dllexport) TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
__declspec(dllexport) TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
protected:
__declspec(dllexport) CArrayPakBase(TBufRep aRep,TInt aGranularity);
__declspec(dllexport) void SetKey(TKeyArrayPak& aKey) const;
__declspec(dllexport) TInt GetOffset(TInt anIndex) const;
__declspec(dllexport) void BuildVarArrayL(CArrayVarFlat<TAny> *& aVarFlat);
__declspec(dllexport) static TInt CountR(const CBase* aPtr);
__declspec(dllexport) static const TAny* AtR(const CBase* aPtr,TInt anIndex);
private:
TInt iCount;
TInt iGranularity;
TBufRep iCreateRep;
CBufBase* iBase;
TInt iCacheIndex;
TInt iCacheOffset;
};
template <class T>
class CArrayPak : public CArrayPakBase
#line 964
{
public:
inline CArrayPak(TBufRep aRep,TInt aGranularity);
inline const T& operator[](TInt anIndex) const;
inline T& operator[](TInt anIndex);
inline const T& At(TInt anIndex) const;
inline T& At(TInt anIndex);
inline void AppendL(const T& aRef,TInt aLength);
inline T& ExpandL(TInt anIndex,TInt aLength);
inline T& ExtendL(TInt aLength);
inline TInt Find(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
inline TInt FindIsq(const T& aRef,TKeyArrayPak& aKey,TInt& anIndex) const;
inline void InsertL(TInt anIndex,const T& aRef,TInt aLength);
inline TInt InsertIsqL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
inline TInt InsertIsqAllowDuplicatesL(const T& aRef,TInt aLength,TKeyArrayPak& aKey);
inline const TArray<T> Array() const;
};
template<> class CArrayPak<TAny> : public CArrayPakBase
#line 1001
{
public:
inline CArrayPak(TBufRep aRep,TInt aGranularity);
inline const TAny* At(TInt anIndex) const;
inline TAny* At(TInt anIndex);
inline void AppendL(const TAny* aPtr,TInt aLength);
inline TAny* ExtendL(TInt aLength);
};
template <class T>
class CArrayPakFlat : public CArrayPak<T>
#line 1029
{
public:
inline explicit CArrayPakFlat(TInt aGranularity);
};
class CObjectCon;
class CObject : public CBase
#line 1055
{
public:
__declspec(dllexport) CObject();
__declspec(dllexport) ~CObject();
__declspec(dllexport) virtual TInt Open();
__declspec(dllexport) virtual void Close();
__declspec(dllexport) virtual TName Name() const;
__declspec(dllexport) virtual TFullName FullName() const;
__declspec(dllexport) TInt SetName(const TDesC* aName);
__declspec(dllexport) void SetNameL(const TDesC* aName);
inline CObject* Owner() const;
inline void SetOwner(CObject* anOwner);
inline TInt AccessCount() const;
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
protected:
inline TInt UniqueID() const;
inline void Inc();
inline void Dec();
private:
TInt iAccessCount;
CObject* iOwner;
CObjectCon* iContainer;
HBufC* iName;
TAny* iSpare1;
TAny* iSpare2;
friend class CObjectCon;
friend class CObjectIx;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
struct TObjectDataStr
{
TInt16 instance;
TInt16 uniqueID;
};
struct SObjectIxRec
{
union
{
TObjectDataStr str;
TInt nextEmpty;
};
CObject* obj;
};
class CObjectIx : public CBase
#line 1129
{
public:
enum {
ENoClose=KHandleNoClose,
ELocalHandle=KHandleFlagLocal
};
public:
__declspec(dllexport) static CObjectIx* NewL();
__declspec(dllexport) ~CObjectIx();
__declspec(dllexport) TInt AddL(CObject* anObj);
__declspec(dllexport) void Remove(TInt aHandle);
__declspec(dllexport) CObject* At(TInt aHandle,TInt aUniqueID);
__declspec(dllexport) CObject* At(TInt aHandle);
__declspec(dllexport) CObject* AtL(TInt aHandle,TInt aUniqueID);
__declspec(dllexport) CObject* AtL(TInt aHandle);
__declspec(dllexport) TInt At(const CObject* anObject) const;
__declspec(dllexport) TInt Count(CObject* anObject) const;
__declspec(dllexport) CObject* operator[](TInt anIndex);
inline TInt Count() const;
inline TInt ActiveCount() const;
protected:
__declspec(dllexport) CObjectIx();
private:
void UpdateState();
private:
TInt iNumEntries;
TInt iHighWaterMark;
TInt iAllocated;
TInt iNextInstance;
SObjectIxRec *iObjects;
TInt iFree;
TInt iUpdateDisabled;
TAny* iSpare1;
TAny* iSpare2;
};
inline TBool IsLocalHandle(TInt aHandle)
{return(aHandle&CObjectIx::ELocalHandle);}
inline void SetLocalHandle(TInt &aHandle)
{aHandle|=CObjectIx::ELocalHandle;}
inline void UnSetLocalHandle(TInt &aHandle)
{aHandle&=(~CObjectIx::ELocalHandle);}
class CObjectCon : public CBase
#line 1208
{
protected:
enum {ENotOwnerID};
public:
__declspec(dllexport) static CObjectCon* NewL();
__declspec(dllexport) ~CObjectCon();
__declspec(dllexport) void Remove(CObject* anObj);
__declspec(dllexport) void AddL(CObject* anObj);
__declspec(dllexport) CObject* operator[](TInt anIndex);
__declspec(dllexport) CObject* At(TInt aFindHandle) const;
__declspec(dllexport) CObject* AtL(TInt aFindHandle) const;
__declspec(dllexport) TInt CheckUniqueFullName(const CObject* anOwner,const TDesC& aName) const;
__declspec(dllexport) TInt CheckUniqueFullName(const CObject* anObject) const;
__declspec(dllexport) TInt FindByName(TInt& aFindHandle,const TDesC& aMatch,TName& aName) const;
__declspec(dllexport) TInt FindByFullName(TInt& aFindHandle,const TDesC& aMatch,TFullName& aFullName) const;
inline TInt UniqueID() const;
inline TInt Count() const;
protected:
__declspec(dllexport) CObjectCon(TInt aUniqueID);
TBool NamesMatch(const CObject* anObject, const CObject* aCurrentObject) const;
TBool NamesMatch(const CObject* anObject, const TName& anObjectName, const CObject* aCurrentObject) const;
public:
TInt iUniqueID;
private:
TInt iCount;
TInt iAllocated;
CObject** iObjects;
TAny* iSpare1;
TAny* iSpare2;
friend class CObjectConIx;
};
class CObjectConIx : public CBase
#line 1264
{
public:
__declspec(dllexport) static CObjectConIx* NewL();
__declspec(dllexport) ~CObjectConIx();
__declspec(dllexport) CObjectCon* Lookup(TInt aFindHandle) const;
__declspec(dllexport) CObjectCon* CreateL();
__declspec(dllexport) void Remove(CObjectCon* aCon);
protected:
__declspec(dllexport) CObjectConIx();
__declspec(dllexport) void CreateContainerL(CObjectCon*& anObject);
private:
TInt iCount;
TInt iAllocated;
TInt iNextUniqueID;
CObjectCon** iContainers;
TAny* iSpare1;
TAny* iSpare2;
};
class CBitMapAllocator : public CBase
{
public:
__declspec(dllexport) static CBitMapAllocator* New(TInt aSize);
__declspec(dllexport) static CBitMapAllocator* NewL(TInt aSize);
__declspec(dllexport) ~CBitMapAllocator();
__declspec(dllexport) TInt Alloc();
__declspec(dllexport) TInt AllocFrom(TInt aPos);
__declspec(dllexport) TInt Alloc(TInt aCount, TInt& aConsecutive);
__declspec(dllexport) TInt AllocAligned(TInt anAlignment);
__declspec(dllexport) TInt AllocAlignedBlock(TInt anAlignment);
__declspec(dllexport) TInt AllocFromTop();
__declspec(dllexport) TInt AllocFromTopFrom(TInt aPos);
__declspec(dllexport) void AllocAt(TInt aPos);
__declspec(dllexport) void AllocAt(TInt aPos, TInt aCount);
__declspec(dllexport) TBool IsFree(TInt aPos);
__declspec(dllexport) TBool IsFree(TInt aPos, TInt aCount);
__declspec(dllexport) void Free(TInt aPos);
__declspec(dllexport) void Free(TInt aPos, TInt aCount);
__declspec(dllexport) TInt Avail();
__declspec(dllexport) TInt Size();
__declspec(dllexport) TInt ExtractRamPages(TInt aConsecutive,TInt& aPageNo);
protected:
__declspec(dllexport) CBitMapAllocator(TInt aSize,TInt aLength);
protected:
TInt iAvail;
TInt iSize;
TInt iLength;
TUint iMap[1];
};
class TCleanupStackItem;
#line 1334
typedef void (*TCleanupOperation)(TAny*);
class TCleanupItem
#line 1350
{
public:
inline TCleanupItem(TCleanupOperation anOperation);
inline TCleanupItem(TCleanupOperation anOperation,TAny* aPtr);
private:
TCleanupOperation iOperation;
TAny* iPtr;
friend class TCleanupStackItem;
};
class CCleanup : public CBase
#line 1373
{
public:
__declspec(dllexport) static CCleanup* New();
__declspec(dllexport) static CCleanup* NewL();
__declspec(dllexport) ~CCleanup();
__declspec(dllexport) void NextLevel();
__declspec(dllexport) void PreviousLevel();
__declspec(dllexport) void PushL(TAny* aPtr);
__declspec(dllexport) void PushL(CBase* anObject);
__declspec(dllexport) void PushL(TCleanupItem anItem);
__declspec(dllexport) void Pop();
__declspec(dllexport) void Pop(TInt aCount);
__declspec(dllexport) void PopAll();
__declspec(dllexport) void PopAndDestroy();
__declspec(dllexport) void PopAndDestroy(TInt aCount);
__declspec(dllexport) void PopAndDestroyAll();
__declspec(dllexport) void Check(TAny* aExpectedItem);
protected:
__declspec(dllexport) void DoPop(TInt aCount,TBool aDestroy);
__declspec(dllexport) void DoPopAll(TBool aDestroy);
protected:
__declspec(dllexport) CCleanup();
protected:
TCleanupStackItem* iBase;
TCleanupStackItem* iTop;
TCleanupStackItem* iNext;
};
class TCleanupTrapHandler : public TTrapHandler
#line 1427
{
public:
TCleanupTrapHandler();
virtual void Trap();
virtual void UnTrap();
virtual void Leave(TInt aValue);
inline CCleanup& Cleanup();
private:
CCleanup* iCleanup;
friend class CTrapCleanup;
};
template <class T>
class TAutoClose
#line 1454
{
public:
inline ~TAutoClose();
inline void PushL();
inline void Pop();
private:
static void Close(TAny *aObj);
public:
T iObj;
};
class CTrapCleanup : public CBase
#line 1481
{
public:
__declspec(dllexport) static CTrapCleanup* New();
__declspec(dllexport) ~CTrapCleanup();
protected:
__declspec(dllexport) CTrapCleanup();
private:
TCleanupTrapHandler iHandler;
TTrapHandler* iOldHandler;
};
class CCirBufBase : public CBase
#line 1507
{
public:
__declspec(dllexport) ~CCirBufBase();
inline TInt Count() const;
inline TInt Length() const;
__declspec(dllexport) void SetLengthL(TInt aLength);
__declspec(dllexport) void Reset();
protected:
__declspec(dllexport) CCirBufBase(TInt aSize);
__declspec(dllexport) TInt DoAdd(const TUint8* aPtr);
__declspec(dllexport) TInt DoAdd(const TUint8* aPtr,TInt aCount);
__declspec(dllexport) TInt DoRemove(TUint8* aPtr);
__declspec(dllexport) TInt DoRemove(TUint8* aPtr,TInt aCount);
protected:
TInt iCount;
TInt iSize;
TInt iLength;
TUint8* iPtr;
TUint8* iPtrE;
TUint8* iHead;
TUint8* iTail;
};
template <class T>
class CCirBuf : public CCirBufBase
{
public:
inline CCirBuf();
inline TInt Add(const T* aPtr);
inline TInt Add(const T* aPtr,TInt aCount);
inline TInt Remove(T* aPtr);
inline TInt Remove(T* aPtr,TInt aCount);
};
class CCirBuffer : public CCirBuf<TUint8>
#line 1566
{
public:
__declspec(dllexport) CCirBuffer();
__declspec(dllexport) ~CCirBuffer();
__declspec(dllexport) TInt Get();
__declspec(dllexport) TInt Put(TInt aVal);
};
class CActive : public CBase
#line 1588
{
public:
enum TPriority
{
EPriorityIdle=-100,
EPriorityLow=-20,
EPriorityStandard=0,
EPriorityUserInput=10,
EPriorityHigh=20,
};
public:
__declspec(dllexport) ~CActive();
__declspec(dllexport) void Cancel();
__declspec(dllexport) void Deque();
__declspec(dllexport) void SetPriority(TInt aPriority);
inline TBool IsActive() const;
inline TBool IsAdded() const;
inline TInt Priority() const;
protected:
__declspec(dllexport) CActive(TInt aPriority);
__declspec(dllexport) void SetActive();
#line 1653
virtual void DoCancel() =0;
#line 1687
virtual void RunL() =0;
__declspec(dllexport) virtual TInt RunError(TInt aError);
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
public:
#line 1704
TRequestStatus iStatus;
private:
TPriQueLink iLink;
TAny* iSpare;
friend class CActiveScheduler;
friend class CServer;
friend class CServer2;
};
class CIdle : public CActive
#line 1729
{
public:
__declspec(dllexport) static CIdle* New(TInt aPriority);
__declspec(dllexport) static CIdle* NewL(TInt aPriority);
__declspec(dllexport) ~CIdle();
__declspec(dllexport) void Start(TCallBack aCallBack);
protected:
__declspec(dllexport) CIdle(TInt aPriority);
__declspec(dllexport) void RunL();
__declspec(dllexport) void DoCancel();
protected:
TCallBack iCallBack;
};
class CAsyncOneShot : public CActive
#line 1782
{
public:
__declspec(dllexport) CAsyncOneShot(TInt aPriority);
__declspec(dllexport) virtual void DoCancel();
__declspec(dllexport) virtual void Call();
__declspec(dllexport) virtual ~CAsyncOneShot();
inline RThread& Thread();
private:
void Setup();
RThread iThread;
};
class CAsyncCallBack : public CAsyncOneShot
{
public:
__declspec(dllexport) CAsyncCallBack(TInt aPriority);
__declspec(dllexport) CAsyncCallBack(const TCallBack& aCallBack, TInt aPriority);
__declspec(dllexport) void Set(const TCallBack& aCallBack);
__declspec(dllexport) void CallBack();
__declspec(dllexport) virtual ~CAsyncCallBack();
protected:
virtual void RunL();
protected:
TCallBack iCallBack;
};
class TDeltaTimerEntry
#line 1838
{
friend class CDeltaTimer;
public:
inline TDeltaTimerEntry(TCallBack& aCallback);
inline TDeltaTimerEntry();
inline void Set(TCallBack& aCallback);
private:
TCallBack iCallBack;
TTickCountQueLink iLink;
};
class CDeltaTimer : public CActive
#line 1893
{
public:
__declspec(dllexport) virtual void Queue(TTimeIntervalMicroSeconds32 aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
__declspec(dllexport) virtual void Remove(TDeltaTimerEntry& aEntry);
__declspec(dllexport) TInt QueueLong(TTimeIntervalMicroSeconds aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
__declspec(dllexport) static CDeltaTimer* NewL(TInt aPriority);
__declspec(dllexport) static CDeltaTimer* NewL(TInt aPriority, TTimeIntervalMicroSeconds32 aGranularity);
~CDeltaTimer();
private:
CDeltaTimer(TInt aPriority, TInt aTickPeriod);
void DoCancel();
void RunL();
void Activate(TBool aRequeueTimer = EFalse);
private:
RTimer iTimer;
TTickCountQue iQueue;
const TInt iTickPeriod;
TBool iQueueBusy;
};
class CTimer : public CActive
#line 1974
{
public:
__declspec(dllexport) ~CTimer();
__declspec(dllexport) void At(const TTime& aTime);
__declspec(dllexport) void AtUTC(const TTime& aTimeInUTC);
__declspec(dllexport) void After(TTimeIntervalMicroSeconds32 anInterval);
__declspec(dllexport) void Lock(TTimerLockSpec aLock);
__declspec(dllexport) void Inactivity(TTimeIntervalSeconds aSeconds);
__declspec(dllexport) void HighRes(TTimeIntervalMicroSeconds32 aInterval);
protected:
__declspec(dllexport) CTimer(TInt aPriority);
__declspec(dllexport) void ConstructL();
__declspec(dllexport) void DoCancel();
private:
RTimer iTimer;
};
class CPeriodic : public CTimer
#line 2035
{
public:
__declspec(dllexport) static CPeriodic* New(TInt aPriority);
__declspec(dllexport) static CPeriodic* NewL(TInt aPriority);
__declspec(dllexport) ~CPeriodic();
__declspec(dllexport) void Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack);
protected:
__declspec(dllexport) CPeriodic(TInt aPriority);
__declspec(dllexport) void RunL();
private:
TTimeIntervalMicroSeconds32 iInterval;
TCallBack iCallBack;
};
class MBeating
#line 2067
{
public:
virtual void Beat() =0;
#line 2084
virtual void Synchronize() =0;
};
class CHeartbeat : public CTimer
#line 2131
{
public:
__declspec(dllexport) static CHeartbeat* New(TInt aPriority);
__declspec(dllexport) static CHeartbeat* NewL(TInt aPriority);
__declspec(dllexport) ~CHeartbeat();
__declspec(dllexport) void Start(TTimerLockSpec aLock,MBeating *aBeating);
protected:
__declspec(dllexport) CHeartbeat(TInt aPriority);
__declspec(dllexport) void RunL();
private:
TTimerLockSpec iLock;
MBeating *iBeating;
};
class CServer2;
#line 2170
class CSession2 : public CBase
{
friend class CServer2;
public:
__declspec(dllexport) virtual ~CSession2() =0;
private:
__declspec(dllexport) virtual void CreateL();
public:
inline const CServer2* Server() const;
__declspec(dllexport) void ResourceCountMarkStart();
__declspec(dllexport) void ResourceCountMarkEnd(const RMessage2& aMessage);
__declspec(dllexport) virtual TInt CountResources();
#line 2192
virtual void ServiceL(const RMessage2& aMessage) =0;
__declspec(dllexport) virtual void ServiceError(const RMessage2& aMessage,TInt aError);
protected:
__declspec(dllexport) CSession2();
__declspec(dllexport) virtual void Disconnect(const RMessage2& aMessage);
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
public:
enum TPanicNo {ESesCountResourcesNotImplemented=1,ESesFoundResCountHeaven};
private:
TInt iResourceCountMark;
TDblQueLink iLink;
const CServer2* iServer;
TAny* iSpare;
};
#line 2224
class CServer2 : public CActive
{
public:
enum TServerType
{
EUnsharableSessions = EIpcSession_Unsharable,
ESharableSessions = EIpcSession_Sharable,
EGlobalSharableSessions = EIpcSession_GlobalSharable,
};
public:
__declspec(dllexport) virtual ~CServer2() =0;
__declspec(dllexport) TInt Start(const TDesC& aName);
__declspec(dllexport) void StartL(const TDesC& aName);
__declspec(dllexport) void ReStart();
#line 2264
inline RServer2 Server() const { return iServer; }
protected:
inline const RMessage2& Message() const;
__declspec(dllexport) CServer2(TInt aPriority, TServerType aType=EUnsharableSessions);
__declspec(dllexport) void DoCancel();
__declspec(dllexport) void RunL();
__declspec(dllexport) TInt RunError(TInt aError);
__declspec(dllexport) virtual void DoConnect(const RMessage2& aMessage);
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
#line 2298
__declspec(dllexport) virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const =0;
void Connect(const RMessage2& aMessage);
void DoConnectL(const RMessage2& aMessage,CSession2* volatile& aSession);
public:
enum TPanic
{
EBadMessageNumber,
ESessionNotConnected,
ESessionAlreadyConnected,
EClientDoesntHaveRequiredCaps,
};
private:
TInt iSessionType;
RServer2 iServer;
RMessage2 iMessage;
TAny* iSpare;
TDblQue<CSession2> iSessionQ;
protected:
TDblQueIter<CSession2> iSessionIter;
private:
void Disconnect(const RMessage2& aMessage);
static void BadMessage(const RMessage2& aMessage);
static void NotConnected(const RMessage2& aMessage);
friend class CPolicyServer;
};
#line 2405
class CPolicyServer : public CServer2
{
public:
enum TFailureAction
{
EFailClient = 0,
EPanicClient= 1,
};
#line 2428
enum TCustomResult
{
EPass = 0,
EFail = 1,
EAsync = 2,
};
#line 2442
class TPolicyElement
{
public:
#line 2475
TStaticSecurityPolicy iPolicy;
TInt iAction;
};
enum TSpecialCase
{
ECustomCheck =255u,
ENotSupported =254u,
EAlwaysPass =253u,
ESpecialCaseLimit =252u,
ESpecialCaseHardLimit =250u
};
#line 2548
class TPolicy
{
public:
TUint8 iOnConnect;
TUint16 iRangeCount;
#line 2578
const TInt* iRanges;
#line 2616
const TUint8* iElementsIndex;
#line 2645
const TPolicyElement* iElements;
};
public:
#line 2663
__declspec(dllexport) void ProcessL(const RMessage2& aMsg);
#line 2681
__declspec(dllexport) void CheckFailedL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
#line 2696
__declspec(dllexport) void ProcessError(const RMessage2& aMsg, TInt aError);
protected:
#line 2709
__declspec(dllexport) CPolicyServer(TInt aPriority, const TPolicy& aPolicy, TServerType aType=EUnsharableSessions);
#line 2759
__declspec(dllexport) virtual TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing);
#line 2810
__declspec(dllexport) virtual TCustomResult CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
__declspec(dllexport) virtual void RunL();
__declspec(dllexport) virtual TInt RunError(TInt aError);
const CPolicyServer::TPolicyElement* FindPolicyElement(TInt aFn, TUint& aSpecialCase) const;
private:
const TPolicy& iPolicy;
};
class CActiveScheduler : public CBase
#line 2853
{
friend class CActiveSchedulerWait;
public:
struct TLoop;
typedef TLoop* TLoopOwner;
public:
__declspec(dllexport) CActiveScheduler();
__declspec(dllexport) ~CActiveScheduler();
__declspec(dllexport) static void Install(CActiveScheduler* aScheduler);
__declspec(dllexport) static CActiveScheduler* Current();
__declspec(dllexport) static void Add(CActive* aActive);
__declspec(dllexport) static void Start();
__declspec(dllexport) static void Stop();
__declspec(dllexport) static TBool RunIfReady(TInt& aError, TInt aMinimumPriority);
__declspec(dllexport) static CActiveScheduler* Replace(CActiveScheduler* aNewActiveScheduler);
__declspec(dllexport) virtual void WaitForAnyRequest();
__declspec(dllexport) virtual void Error(TInt aError) const;
__declspec(dllexport) void Halt(TInt aExitCode) const;
__declspec(dllexport) TInt StackDepth() const;
private:
static void Start(TLoopOwner* aOwner);
__declspec(dllexport) virtual void OnStarting();
__declspec(dllexport) virtual void OnStopping();
__declspec(dllexport) virtual void Reserved_1();
__declspec(dllexport) virtual void Reserved_2();
void Run(TLoopOwner* const volatile& aLoop);
void DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj);
protected:
__declspec(dllexport) virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
protected:
inline TInt Level() const;
private:
TLoop* iStack;
TPriQue<CActive> iActiveQ;
TAny* iSpare;
};
class CActiveSchedulerWait : public CBase
#line 2908
{
public:
__declspec(dllexport) CActiveSchedulerWait();
__declspec(dllexport) ~CActiveSchedulerWait();
__declspec(dllexport) void Start();
__declspec(dllexport) void AsyncStop();
__declspec(dllexport) void AsyncStop(const TCallBack& aCallMeWhenStopped);
inline TBool IsStarted() const;
__declspec(dllexport) TBool CanStopNow() const;
private:
CActiveScheduler::TLoopOwner iLoop;
};
class CleanupStack
{
public:
__declspec(dllexport) static void PushL(TAny* aPtr);
__declspec(dllexport) static void PushL(CBase* aPtr);
__declspec(dllexport) static void PushL(TCleanupItem anItem);
__declspec(dllexport) static void Pop();
__declspec(dllexport) static void Pop(TInt aCount);
__declspec(dllexport) static void PopAndDestroy();
__declspec(dllexport) static void PopAndDestroy(TInt aCount);
__declspec(dllexport) static void Check(TAny* aExpectedItem);
inline static void Pop(TAny* aExpectedItem);
inline static void Pop(TInt aCount, TAny* aLastExpectedItem);
inline static void PopAndDestroy(TAny* aExpectedItem);
inline static void PopAndDestroy(TInt aCount, TAny* aLastExpectedItem);
};
#line 2961
template <class T>
class CleanupDelete
{
public:
inline static void PushL(T* aPtr);
private:
static void Delete(TAny *aPtr);
};
#line 3009
template <class T>
inline void CleanupDeletePushL(T* aPtr);
#line 3025
template <class T>
class CleanupArrayDelete
{
public:
inline static void PushL(T* aPtr);
private:
static void ArrayDelete(TAny *aPtr);
};
#line 3075
template <class T>
inline void CleanupArrayDeletePushL(T* aPtr);
#line 3091
template <class T>
class CleanupClose
{
public:
inline static void PushL(T& aRef);
private:
static void Close(TAny *aPtr);
};
#line 3153
template <class T>
inline void CleanupClosePushL(T& aRef);
#line 3169
template <class T>
class CleanupRelease
{
public:
inline static void PushL(T& aRef);
private:
static void Release(TAny *aPtr);
};
#line 3227
template <class T>
inline void CleanupReleasePushL(T& aRef);
class CConsoleBase;
class Console
{
public:
__declspec(dllexport) static CConsoleBase* NewL(const TDesC& aTitle,TSize aSize);
};
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.inl" /* stack depth 7 */
inline TAny* CBase::operator new(TUint aSize, TAny* aBase) throw()
#line 19
{ Mem::FillZ(aBase, aSize); return aBase; }
inline TAny* CBase::operator new(TUint aSize) throw()
#line 36
{ return User::AllocZ(aSize); }
inline TAny* CBase::operator new(TUint aSize, TLeave)
#line 53
{ return User::AllocZL(aSize); }
inline TAny* CBase::operator new(TUint aSize, TUint aExtraSize) throw()
#line 74
{ return User::AllocZ(aSize + aExtraSize); }
inline TAny* CBase::operator new(TUint aSize, TLeave, TUint aExtraSize)
#line 95
{ return User::AllocZL(aSize + aExtraSize); }
inline TInt CBufBase::Size() const
#line 111
{return(iSize);}
inline TInt CBufFlat::Capacity() const
{return(iMaxSize);}
inline TInt CArrayFixBase::Count() const
{return(iCount);}
inline TInt CArrayFixBase::Length() const
{return(iLength);}
template <class T>
inline CArrayFix<T>::CArrayFix(TBufRep aRep,TInt aGranularity)
: CArrayFixBase(aRep,sizeof(T),aGranularity)
{}
template <class T>
inline const T &CArrayFix<T>::operator[](TInt anIndex) const
#line 183
{return(*((const T *)CArrayFixBase::At(anIndex)));}
template <class T>
inline T &CArrayFix<T>::operator[](TInt anIndex)
#line 207
{return(*((T *)CArrayFixBase::At(anIndex)));}
template <class T>
inline const T &CArrayFix<T>::At(TInt anIndex) const
#line 231
{return(*((const T *)CArrayFixBase::At(anIndex)));}
template <class T>
inline const T *CArrayFix<T>::End(TInt anIndex) const
#line 259
{return((const T *)CArrayFixBase::End(anIndex));}
template <class T>
inline const T *CArrayFix<T>::Back(TInt anIndex) const
#line 288
{return((const T *)CArrayFixBase::Back(anIndex));}
template <class T>
inline T &CArrayFix<T>::At(TInt anIndex)
#line 312
{return(*((T *)CArrayFixBase::At(anIndex)));}
template <class T>
inline T *CArrayFix<T>::End(TInt anIndex)
#line 338
{return(((T *)CArrayFixBase::End(anIndex)));}
template <class T>
inline T *CArrayFix<T>::Back(TInt anIndex)
#line 367
{return(((T *)CArrayFixBase::Back(anIndex)));}
template <class T>
inline void CArrayFix<T>::AppendL(const T &aRef)
#line 383
{CArrayFixBase::InsertL(Count(),&aRef);}
template <class T>
inline void CArrayFix<T>::AppendL(const T *aPtr,TInt aCount)
#line 404
{CArrayFixBase::InsertL(Count(),aPtr,aCount);}
template <class T>
inline void CArrayFix<T>::AppendL(const T &aRef,TInt aReplicas)
#line 423
{CArrayFixBase::InsertRepL(Count(),&aRef,aReplicas);}
template <class T>
inline T &CArrayFix<T>::ExpandL(TInt anIndex)
#line 461
{return(*new(CArrayFixBase::ExpandL(anIndex)) T);}
template <class T>
inline T &CArrayFix<T>::ExtendL()
#line 492
{return(*new(CArrayFixBase::ExpandL(Count())) T);}
template <class T>
inline TInt CArrayFix<T>::Find(const T &aRef,TKeyArrayFix &aKey,TInt &anIndex) const
#line 525
{return(CArrayFixBase::Find(&aRef,aKey,anIndex));}
template <class T>
inline TInt CArrayFix<T>::FindIsq(const T &aRef,TKeyArrayFix &aKey,TInt &anIndex) const
#line 562
{return(CArrayFixBase::FindIsq(&aRef,aKey,anIndex));}
template <class T>
inline void CArrayFix<T>::InsertL(TInt anIndex,const T &aRef)
#line 589
{CArrayFixBase::InsertL(anIndex,&aRef);}
template <class T>
inline void CArrayFix<T>::InsertL(TInt anIndex,const T *aPtr,TInt aCount)
#line 622
{CArrayFixBase::InsertL(anIndex,aPtr,aCount);}
template <class T>
inline void CArrayFix<T>::InsertL(TInt anIndex,const T &aRef,TInt aReplicas)
#line 655
{CArrayFixBase::InsertRepL(anIndex,&aRef,aReplicas);}
template <class T>
inline TInt CArrayFix<T>::InsertIsqL(const T &aRef,TKeyArrayFix &aKey)
#line 684
{return(CArrayFixBase::InsertIsqL(&aRef,aKey));}
template <class T>
inline TInt CArrayFix<T>::InsertIsqAllowDuplicatesL(const T &aRef,TKeyArrayFix &aKey)
#line 711
{return(CArrayFixBase::InsertIsqAllowDuplicatesL(&aRef,aKey));}
template <class T>
inline void CArrayFix<T>::ResizeL(TInt aCount)
#line 746
{TUint8 b[sizeof(T)]; new(&b[0]) T; CArrayFixBase::ResizeL(aCount,&b[0]);}
template <class T>
inline void CArrayFix<T>::ResizeL(TInt aCount,const T &aRef)
#line 783
{CArrayFixBase::ResizeL(aCount,&aRef);}
template <class T>
inline const TArray<T> CArrayFix<T>::Array() const
{return(TArray<T>(CountR,AtR,this));}
inline CArrayFix<TAny>::CArrayFix(TBufRep aRep,TInt aRecordLength,TInt aGranularity)
: CArrayFixBase(aRep,aRecordLength,aGranularity)
{}
inline const TAny *CArrayFix<TAny>::At(TInt anIndex) const
#line 825
{return(CArrayFixBase::At(anIndex));}
inline const TAny *CArrayFix<TAny>::End(TInt anIndex) const
#line 850
{return(CArrayFixBase::End(anIndex));}
inline const TAny *CArrayFix<TAny>::Back(TInt anIndex) const
#line 877
{return(CArrayFixBase::Back(anIndex));}
inline TAny *CArrayFix<TAny>::At(TInt anIndex)
#line 897
{return(CArrayFixBase::At(anIndex));}
inline TAny *CArrayFix<TAny>::End(TInt anIndex)
#line 922
{return(CArrayFixBase::End(anIndex));}
inline TAny *CArrayFix<TAny>::Back(TInt anIndex)
#line 949
{return(CArrayFixBase::Back(anIndex));}
inline void CArrayFix<TAny>::AppendL(const TAny *aPtr)
#line 964
{CArrayFixBase::InsertL(Count(),aPtr);}
inline void CArrayFix<TAny>::AppendL(const TAny *aPtr,TInt aCount)
#line 982
{CArrayFixBase::InsertL(Count(),aPtr,aCount);}
inline TAny *CArrayFix<TAny>::ExtendL()
#line 1001
{return(CArrayFixBase::ExpandL(Count()));}
template <class T>
inline CArrayFixFlat<T>::CArrayFixFlat(TInt aGranularity)
: CArrayFix<T>((TBufRep)CBufFlat::NewL,aGranularity)
#line 1024
{}
template <class T>
inline void CArrayFixFlat<T>::SetReserveL(TInt aCount)
#line 1050
{this->SetReserveFlatL(aCount);}
inline CArrayFixFlat<TAny>::CArrayFixFlat(TInt aRecordLength,TInt aGranularity)
: CArrayFix<TAny>((TBufRep)CBufFlat::NewL,aRecordLength,aGranularity)
#line 1069
{}
inline void CArrayFixFlat<TAny>::SetReserveL(TInt aCount)
#line 1094
{SetReserveFlatL(aCount);}
inline void CArrayFixFlat<TInt>::SetReserveL(TInt aCount)
#line 1119
{SetReserveFlatL(aCount);}
inline void CArrayFixFlat<TUid>::SetReserveL(TInt aCount)
#line 1144
{SetReserveFlatL(aCount);}
template <class T>
inline CArrayFixSeg<T>::CArrayFixSeg(TInt aGranularity)
: CArrayFix<T>((TBufRep)CBufSeg::NewL,aGranularity)
#line 1168
{}
inline CArrayFixSeg<TAny>::CArrayFixSeg(TInt aRecordLength,TInt aGranularity)
: CArrayFix<TAny>((TBufRep)CBufSeg::NewL,aRecordLength,aGranularity)
#line 1188
{}
template <class T>
inline CArrayPtr<T>::CArrayPtr(TBufRep aRep,TInt aGranularity)
: CArrayFix<T*>(aRep,aGranularity)
{}
template <class T>
void CArrayPtr<T>::ResetAndDestroy()
#line 1221
{
for (TInt i=0;i<this->Count();++i)
delete this->At(i);
this->Reset();
}
template <class T>
inline CArrayPtrFlat<T>::CArrayPtrFlat(TInt aGranularity)
: CArrayPtr<T>((TBufRep)CBufFlat::NewL,aGranularity)
#line 1243
{}
template <class T>
inline void CArrayPtrFlat<T>::SetReserveL(TInt aCount)
#line 1269
{this->SetReserveFlatL(aCount);}
template <class T>
inline CArrayPtrSeg<T>::CArrayPtrSeg(TInt aGranularity)
: CArrayPtr<T>((TBufRep)CBufSeg::NewL,aGranularity)
#line 1287
{}
inline TInt CArrayVarBase::Count() const
{return(iCount);}
template <class T>
inline CArrayVar<T>::CArrayVar(TBufRep aRep,TInt aGranularity)
: CArrayVarBase(aRep,aGranularity)
{}
template <class T>
inline const T &CArrayVar<T>::operator[](TInt anIndex) const
#line 1334
{return(*((const T *)CArrayVarBase::At(anIndex)));}
template <class T>
inline T &CArrayVar<T>::operator[](TInt anIndex)
#line 1358
{return(*((T *)CArrayVarBase::At(anIndex)));}
template <class T>
inline const T &CArrayVar<T>::At(TInt anIndex) const
#line 1381
{return(*((const T *)CArrayVarBase::At(anIndex)));}
template <class T>
inline T &CArrayVar<T>::At(TInt anIndex)
#line 1403
{return(*((T *)CArrayVarBase::At(anIndex)));}
template <class T>
inline void CArrayVar<T>::AppendL(const T &aRef,TInt aLength)
#line 1423
{CArrayVarBase::InsertL(Count(),&aRef,aLength);}
template <class T>
inline T &CArrayVar<T>::ExpandL(TInt anIndex,TInt aLength)
#line 1465
{return(*new(CArrayVarBase::ExpandL(anIndex,aLength)) T);}
template <class T>
inline T &CArrayVar<T>::ExtendL(TInt aLength)
#line 1499
{return(*new(CArrayVarBase::ExpandL(Count(),aLength)) T);}
template <class T>
inline TInt CArrayVar<T>::Find(const T &aRef,TKeyArrayVar &aKey,TInt &anIndex) const
#line 1529
{return(CArrayVarBase::Find(&aRef,aKey,anIndex));}