Symbian

开发平台：

C/C++

S60UIExampleInitialView.inc：源码内容

TLinAddr iLimit;
TLinAddr iExpandLimit;
};
#line 6214
class XLeaveException
{
public:
inline XLeaveException() {}
inline XLeaveException(TInt aReason) {iR = aReason;}
inline TInt Reason() const {return iR;}
__declspec(dllexport) TInt GetReason() const;
private:
#line 6230
private:
TAny* iVtable;
TInt iR;
};
namespace std {
bool uncaught_exception(void);
void terminate(void);
void unexpected(void);
typedef void (*terminate_handler)();
terminate_handler set_terminate(terminate_handler h) throw();
typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler h) throw();
}
class __UnknownWindowsType1;
class __UnknownWindowsType2;
class TWin32SEHTrap;
typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
class TWin32SEHTrap
{
private:
TWin32SEHTrap(TWin32SEHTrap const &);
TWin32SEHTrap& operator=(TWin32SEHTrap const &);
#line 6297
public:
__declspec(dllexport) TWin32SEHTrap();
public:
__declspec(dllexport) void Trap();
__declspec(dllexport) void UnTrap();
private:
static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext);
TWin32SEHTrap* iPrevExceptionRegistrationRecord;
TWin32SEHExceptionHandler* iExceptionHandler;
private:
TUint32 iPadding[254];
};
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.inl" /* stack depth 6 */
#line 9
inline TAny* operator new(TUint , TAny* aBase) throw()
{return aBase;}
inline void operator delete(TAny* , TAny* ) throw()
{}
inline TAny* operator new[](TUint , TAny* aBase) throw()
{return aBase;}
inline void operator delete[](TAny* , TAny* ) throw()
{}
inline RAllocator::RAllocator()
{
iAccessCount=1;
iHandleCount=0;
iHandles=0;
iFlags=0;
iCellCount=0;
iTotalAllocSize=0;
}
inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)
{__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}
inline RHeap::RHeap()
{}
inline TInt RHeap::MaxLength() const
{return iMaxLength;}
inline void RHeap::operator delete(TAny*, TAny*)
{}
inline TUint8* RHeap::Base() const
#line 73
{return iBase;}
inline TInt RHeap::Size() const
#line 89
{return iTop-iBase;}
inline TInt RHeap::Align(TInt a) const
{return (((a)+( iAlign)-1)&~(( iAlign)-1)) ;}
inline const TAny* RHeap::Align(const TAny* a) const
{return (const TAny*)((((TLinAddr)a)+( iAlign)-1)&~(( iAlign)-1)) ;}
inline TBool RHeap::IsLastCell(const SCell* aCell) const
{return (((TUint8*)aCell) + aCell->len) == iTop;}
inline void RHeap::Lock() const
{((RFastLock&)iLock).Wait();}
inline void RHeap::Unlock() const
{((RFastLock&)iLock).Signal();}
template <class T>
inline TRefByValue<T>::TRefByValue(T &aRef)
: iRef(aRef)
{}
template <class T>
inline TRefByValue<T>::operator T &()
{return(iRef);}
#line 201
inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)
{ return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }
inline TChar::TChar()
{}
inline TChar::TChar(TUint aChar)
: iChar(aChar)
{}
inline TChar& TChar::operator-=(TUint aChar)
#line 241
{iChar-=aChar;return(*this);}
inline TChar& TChar::operator+=(TUint aChar)
#line 256
{iChar+=aChar;return(*this);}
inline TChar TChar::operator-(TUint aChar)
#line 273
{return(iChar-aChar);}
inline TChar TChar::operator+(TUint aChar)
#line 288
{return(iChar+aChar);}
inline TChar::operator TUint() const
{return(iChar);}
inline TBool TDesC8::operator<(const TDesC8 &aDes) const
#line 320
{return(Compare(aDes)<0);}
inline TBool TDesC8::operator<=(const TDesC8 &aDes) const
#line 339
{return(Compare(aDes)<=0);}
inline TBool TDesC8::operator>(const TDesC8 &aDes) const
#line 358
{return(Compare(aDes)>0);}
inline TBool TDesC8::operator>=(const TDesC8 &aDes) const
#line 377
{return(Compare(aDes)>=0);}
inline TBool TDesC8::operator==(const TDesC8 &aDes) const
#line 396
{return(Compare(aDes)==0);}
inline TBool TDesC8::operator!=(const TDesC8 &aDes) const
#line 415
{return(Compare(aDes)!=0);}
inline const TUint8 &TDesC8::operator[](TInt anIndex) const
#line 433
{return(AtC(anIndex));}
inline TInt TDesC8::Length() const
{return(iLength&KMaskDesLength8);}
inline TInt TDesC8::Size() const
{return(Length());}
inline void TDesC8::DoSetLength(TInt aLength)
{iLength=(iLength&(~KMaskDesLength8))|aLength;}
inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)
#line 483
{new(this) TPtrC8(aBuf,aLength);}
inline void TPtrC8::Set(const TDesC8 &aDes)
{new(this) TPtrC8(aDes);}
inline void TPtrC8::Set(const TPtrC8& aPtr)
#line 510
{new(this) TPtrC8(aPtr);}
inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)
{return TPtr8(*this,aMaxLength);}
template <TInt S>
inline TBufC8<S>::TBufC8()
: TBufCBase8()
#line 540
{}
template <TInt S>
inline TBufC8<S>::TBufC8(const TUint8 *aString)
: TBufCBase8(aString,S)
#line 564
{}
template <TInt S>
inline TBufC8<S>::TBufC8(const TDesC8 &aDes)
: TBufCBase8(aDes,S)
#line 588
{}
template <TInt S>
inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)
#line 607
{Copy(aString,S);return(*this);}
template <TInt S>
inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)
#line 626
{Copy(aDes,S);return(*this);}
template <TInt S>
inline TPtr8 TBufC8<S>::Des()
#line 656
{return DoDes(S);}
inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)
#line 681
{return *this=static_cast<const TDesC8&>(aLcb);}
#line 710
inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)
{
Assign(HBufC8::NewL(aStream,aMaxLength));
}
inline TDes8 &TDes8::operator=(const TUint8 *aString)
#line 733
{Copy(aString);return(*this);}
inline TDes8 &TDes8::operator=(const TDesC8 &aDes)
#line 751
{Copy(aDes);return(*this);}
inline TDes8 &TDes8::operator=(const TDes8 &aDes)
#line 769
{Copy(aDes);return(*this);}
inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)
#line 788
{Append(aDes);return(*this);}
inline const TUint8 &TDes8::operator[](TInt anIndex) const
#line 806
{return(AtC(anIndex));}
inline TUint8 &TDes8::operator[](TInt anIndex)
#line 825
{return((TUint8 &)AtC(anIndex));}
inline TInt TDes8::MaxLength() const
#line 839
{return(iMaxLength);}
inline TInt TDes8::MaxSize() const
#line 853
{return(iMaxLength);}
inline TUint8 * TDes8::WPtr() const
{return((TUint8 *)Ptr());}
inline TPtr8 &TPtr8::operator=(const TUint8 *aString)
#line 879
{Copy(aString);return(*this);}
inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)
#line 899
{Copy(aDes);return(*this);}
inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)
#line 919
{Copy(aDes);return(*this);}
inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)
#line 940
{new(this) TPtr8(aBuf,aLength,aMaxLength);}
inline void TPtr8::Set(const TPtr8 &aPtr)
#line 955
{new(this) TPtr8(aPtr);}
template <TInt S>
inline TBuf8<S>::TBuf8()
: TBufBase8(S)
#line 972
{}
template <TInt S>
inline TBuf8<S>::TBuf8(TInt aLength)
: TBufBase8(aLength,S)
#line 994
{}
template <TInt S>
inline TBuf8<S>::TBuf8(const TUint8 *aString)
: TBufBase8(aString,S)
#line 1018
{}
template <TInt S>
inline TBuf8<S>::TBuf8(const TDesC8 &aDes)
: TBufBase8(aDes,S)
#line 1042
{}
template <TInt S>
inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)
#line 1062
{Copy(aString);return(*this);}
template <TInt S>
inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)
#line 1082
{Copy(aDes);return(*this);}
template <TInt S>
inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)
#line 1100
{Copy(aBuf);return *this;}
template <TInt S>
inline TAlignedBuf8<S>::TAlignedBuf8()
: TBufBase8(S)
#line 1117
{}
template <TInt S>
inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)
: TBufBase8(aLength,S)
#line 1139
{}
template <TInt S>
inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)
: TBufBase8(aString,S)
#line 1163
{}
template <TInt S>
inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)
: TBufBase8(aDes,S)
#line 1187
{}
template <TInt S>
inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)
#line 1207
{Copy(aString);return(*this);}
template <TInt S>
inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)
#line 1227
{Copy(aDes);return(*this);}
template <TInt S>
inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)
#line 1245
{Copy(aBuf);return *this;}
template <TInt S>
inline const TDesC8* TLitC8<S>::operator&() const
{return (reinterpret_cast<const TDesC8*>(this)) ;}
template <TInt S>
inline const TDesC8& TLitC8<S>::operator()() const
{return *operator&();}
template <TInt S>
inline TLitC8<S>::operator const TDesC8&() const
{return *operator&();}
template <TInt S>
inline TLitC8<S>::operator const __TRefDesC8() const
{return *operator&();}
inline TBool TDesC16::operator<(const TDesC16 &aDes) const
#line 1314
{return(Compare(aDes)<0);}
inline TBool TDesC16::operator<=(const TDesC16 &aDes) const
#line 1333
{return(Compare(aDes)<=0);}
inline TBool TDesC16::operator>(const TDesC16 &aDes) const
#line 1352
{return(Compare(aDes)>0);}
inline TBool TDesC16::operator>=(const TDesC16 &aDes) const
#line 1371
{return(Compare(aDes)>=0);}
inline TBool TDesC16::operator==(const TDesC16 &aDes) const
#line 1390
{return(Compare(aDes)==0);}
inline TBool TDesC16::operator!=(const TDesC16 &aDes) const
#line 1409
{return(Compare(aDes)!=0);}
inline const TUint16 &TDesC16::operator[](TInt anIndex) const
#line 1427
{return(AtC(anIndex));}
inline TInt TDesC16::Length() const
{return(iLength&KMaskDesLength16);}
inline TInt TDesC16::Size() const
#line 1454
{return(Length()<<1);}
inline void TDesC16::DoSetLength(TInt aLength)
{iLength=(iLength&(~KMaskDesLength16))|aLength;}
inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)
#line 1478
{new(this) TPtrC16(aBuf,aLength);}
inline void TPtrC16::Set(const TDesC16 &aDes)
{new(this) TPtrC16(aDes);}
inline void TPtrC16::Set(const TPtrC16& aPtr)
{new(this) TPtrC16(aPtr);}
inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)
{return TPtr16(*this,aMaxLength);}
template <TInt S>
inline TBufC16<S>::TBufC16()
: TBufCBase16()
#line 1526
{}
template <TInt S>
inline TBufC16<S>::TBufC16(const TUint16 *aString)
: TBufCBase16(aString,S)
#line 1550
{}
template <TInt S>
inline TBufC16<S>::TBufC16(const TDesC16 &aDes)
: TBufCBase16(aDes,S)
#line 1574
{}
template <TInt S>
inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)
#line 1593
{Copy(aString,S);return(*this);}
template <TInt S>
inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)
#line 1612
{Copy(aDes,S);return(*this);}
template <TInt S>
inline TPtr16 TBufC16<S>::Des()
#line 1642
{return(DoDes(S));}
inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)
#line 1667
{return *this=static_cast<const TDesC16&>(aLcb);}
inline TDes16 &TDes16::operator=(const TUint16 *aString)
#line 1687
{Copy(aString);return(*this);}
inline TDes16 &TDes16::operator=(const TDesC16 &aDes)
#line 1705
{Copy(aDes);return(*this);}
inline TDes16 &TDes16::operator=(const TDes16 &aDes)
#line 1723
{Copy(aDes);return(*this);}
inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)
#line 1742
{Append(aDes);return(*this);}
inline const TUint16 &TDes16::operator[](TInt anIndex) const
#line 1759
{return(AtC(anIndex));}
inline TUint16 &TDes16::operator[](TInt anIndex)
#line 1778
{return((TUint16 &)AtC(anIndex));}
inline TInt TDes16::MaxLength() const
#line 1792
{return(iMaxLength);}
inline TInt TDes16::MaxSize() const
#line 1806
{return(iMaxLength<<1);}
inline TUint16 * TDes16::WPtr() const
{return((TUint16 *)Ptr());}
inline TPtr16 &TPtr16::operator=(const TUint16 *aString)
#line 1832
{Copy(aString);return(*this);}
inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)
#line 1852
{Copy(aDes);return(*this);}
inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)
#line 1872
{Copy(aDes);return(*this);}
inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)
#line 1893
{new(this) TPtr16(aBuf,aLength,aMaxLength);}
inline void TPtr16::Set(const TPtr16 &aPtr)
#line 1908
{new(this) TPtr16(aPtr);}
template <TInt S>
inline TBuf16<S>::TBuf16()
: TBufBase16(S)
#line 1925
{}
template <TInt S>
inline TBuf16<S>::TBuf16(TInt aLength)
: TBufBase16(aLength,S)
#line 1947
{}
template <TInt S>
inline TBuf16<S>::TBuf16(const TUint16 *aString)
: TBufBase16(aString,S)
#line 1971
{}
template <TInt S>
inline TBuf16<S>::TBuf16(const TDesC16 &aDes)
: TBufBase16(aDes,S)
#line 1995
{}
template <TInt S>
inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)
#line 2015
{Copy(aString);return(*this);}
template <TInt S>
inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)
#line 2035
{Copy(aDes);return(*this);}
template <TInt S>
inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)
#line 2056
{Copy(aBuf);return *this;}
#line 2083
inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)
{
Assign(HBufC16::NewL(aStream,aMaxLength));
}
template <TInt S>
inline const TDesC16* TLitC16<S>::operator&() const
{return (reinterpret_cast<const TDesC16*>(this)) ;}
template <TInt S>
inline const TDesC16& TLitC16<S>::operator()() const
{return *operator&();}
template <TInt S>
inline TLitC16<S>::operator const TDesC16&() const
{return *operator&();}
template <TInt S>
inline TLitC16<S>::operator const __TRefDesC16() const
{return *operator&();}
template <TInt S>
inline TBufC<S>::TBufC()
: TBufCBase16()
#line 2157
{}
template <TInt S>
inline TBufC<S>::TBufC(const TText *aString)
: TBufCBase16(aString,S)
#line 2186
{}
template <TInt S>
inline TBufC<S>::TBufC(const TDesC &aDes)
: TBufCBase16(aDes,S)
#line 2219
{}
#line 2234
template <TInt S>
inline TBufC<S> &TBufC<S>::operator=(const TText *aString)
#line 2253
{Copy(aString,S);return(*this);}
template <TInt S>
inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)
#line 2277
{Copy(aDes,S);return(*this);}
template <TInt S>
inline TPtr TBufC<S>::Des()
#line 2308
{return(DoDes(S));}
template <TInt S>
inline TBuf<S>::TBuf()
: TBufBase16(S)
{}
template <TInt S>
inline TBuf<S>::TBuf(TInt aLength)
: TBufBase16(aLength,S)
#line 2350
{}
template <TInt S>
inline TBuf<S>::TBuf(const TText *aString)
: TBufBase16(aString,S)
#line 2378
{}
template <TInt S>
inline TBuf<S>::TBuf(const TDesC &aDes)
: TBufBase16(aDes,S)
#line 2407
{}
#line 2426
template <TInt S>
inline TBuf<S> &TBuf<S>::operator=(const TText *aString)
{Copy(aString);return(*this);}
template <TInt S>
inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)
{Copy(aDes);return(*this);}
template <TInt S>
inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)
{Copy(aBuf);return(*this);}
template <TInt S>
inline const TDesC* TLitC<S>::operator&() const
{return (reinterpret_cast<const TDesC*>(this)) ;}
template <TInt S>
inline const TDesC& TLitC<S>::operator()() const
{return *operator&();}
template <TInt S>
inline TLitC<S>::operator const TDesC&() const
{return *operator&();}
template <TInt S>
inline TLitC<S>::operator const __TRefDesC() const
{return *operator&();}
template <class T>
inline TPckgC<T>::TPckgC(const T &aRef)
: TPtrC8((const TUint8 *)&aRef,sizeof(T))
{}
template <class T>
inline const T &TPckgC<T>::operator()() const
{return(*((const T *)iPtr));}
template <class T>
inline TPckg<T>::TPckg(const T &aRef)
: TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T))
{}
template <class T>
inline T &TPckg<T>::operator()()
{return(*((T *)iPtr));}
template <class T>
inline TPckgBuf<T>::TPckgBuf()
: TAlignedBuf8<sizeof(T)>(sizeof(T))
{new(&this->iBuf[0]) T;}
template <class T>
inline TPckgBuf<T>::TPckgBuf(const T &aRef)
: TAlignedBuf8<sizeof(T)>(sizeof(T))
#line 2576
{new(&this->iBuf[0]) T(aRef);}
template <class T>
inline TPckgBuf<T> &TPckgBuf<T>::operator=(const TPckgBuf<T> &aRef)
{this->Copy(aRef);return(*this);}
template <class T>
inline T &TPckgBuf<T>::operator=(const T &aRef)
#line 2605
{this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));}
template <class T>
inline T &TPckgBuf<T>::operator()()
{return(*((T *)&this->iBuf[0]));}
template <class T>
inline const T &TPckgBuf<T>::operator()() const
{return(*((T *)&this->iBuf[0]));}
inline TRequestStatus::TRequestStatus()
: iFlags(0)
{}
inline TRequestStatus::TRequestStatus(TInt aVal)
: iStatus(aVal),
iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0)
{}
inline TInt TRequestStatus::operator=(TInt aVal)
{
if(aVal==KRequestPending)
iFlags|=TRequestStatus::ERequestPending;
else
iFlags&=~TRequestStatus::ERequestPending;
return (iStatus=aVal);
}
inline TBool TRequestStatus::operator==(TInt aVal) const
#line 2691
{return(iStatus==aVal);}
inline TBool TRequestStatus::operator!=(TInt aVal) const
#line 2705
{return(iStatus!=aVal);}
inline TBool TRequestStatus::operator>=(TInt aVal) const
#line 2720
{return(iStatus>=aVal);}
inline TBool TRequestStatus::operator<=(TInt aVal) const
#line 2735
{return(iStatus<=aVal);}
inline TBool TRequestStatus::operator>(TInt aVal) const
#line 2750
{return(iStatus>aVal);}
inline TBool TRequestStatus::operator<(TInt aVal) const
#line 2765
{return(iStatus<aVal);}
inline TInt TRequestStatus::Int() const
{return(iStatus);}
inline TPoint::TPoint()
: iX(0),iY(0)
{}
inline TPoint::TPoint(TInt aX,TInt aY)
: iX(aX),iY(aY)
{}
inline TSize::TSize()
: iWidth(0),iHeight(0)
{}
inline TSize::TSize(TInt aWidth,TInt aHeight)
: iWidth(aWidth),iHeight(aHeight)
{}
inline RHandleBase::RHandleBase()
: iHandle(0)
{}
inline RHandleBase::RHandleBase(TInt aHandle)
: iHandle(aHandle)
#line 2853
{}
inline void RHandleBase::SetHandle(TInt aHandle)
{ iHandle=aHandle; }
inline TInt RHandleBase::Handle() const
{return(iHandle);}
inline TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError)
#line 2899
{
if(aHandleOrError>=0)
{
iHandle = aHandleOrError;
return KErrNone;
}
iHandle = 0;
return aHandleOrError;
}
inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType)
#line 2935
{return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));}
#line 2947
inline RFastLock::RFastLock()
: iCount(0)
{}
#line 2960
inline RMessagePtr2::RMessagePtr2()
: iHandle(0)
{}
#line 2972
inline TBool RMessagePtr2::IsNull() const
{return iHandle==0;}
#line 2983
inline TInt RMessagePtr2::Handle() const
{return iHandle;}
inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight)
{return aLeft.Handle()==aRight.Handle();}
inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight)
{return aLeft.Handle()!=aRight.Handle();}
#line 3000
inline RMessage2::RMessage2()
{}
#line 3011
inline TInt RMessage2::Function() const
{return(iFunction);}
#line 3022
inline TInt RMessage2::Int0() const
{return(iArgs[0]);}
#line 3033
inline TInt RMessage2::Int1() const
{return(iArgs[1]);}
#line 3044
inline TInt RMessage2::Int2() const
{return(iArgs[2]);}
#line 3054
inline TInt RMessage2::Int3() const
{return(iArgs[3]);}
#line 3064
inline const TAny *RMessage2::Ptr0() const
{return((const TAny *)iArgs[0]);}
#line 3075
inline const TAny *RMessage2::Ptr1() const
{return((const TAny *)iArgs[1]);}
#line 3086
inline const TAny *RMessage2::Ptr2() const
{return((const TAny *)iArgs[2]);}
#line 3097
inline const TAny *RMessage2::Ptr3() const
{return((const TAny *)iArgs[3]);}
#line 3107
inline CSession2* RMessage2::Session() const
{return (CSession2*)iSessionPtr; }
inline TUid TUid::Uid(TInt aUid)
#line 3123
{TUid uid={aUid};return uid;}
inline TUid TUid::Null()
{TUid uid={KNullUidValue};return uid;}
template <class T>
inline TArray<T>::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr)
: iPtr(aPtr),iCount(aCount),iAt(anAt)
#line 3195
{}
template <class T>
inline TInt TArray<T>::Count() const
{return((*iCount)(iPtr));}
template <class T>
inline const T &TArray<T>::operator[](TInt anIndex) const
#line 3232
{return(*((const T *)(*iAt)(iPtr,anIndex)));}
template <class T>
inline TIdentityRelation<T>::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) )
#line 3254
{ iIdentity=(TGeneralIdentityRelation)anIdentity; }
template <class T>
inline TIdentityRelation<T>::operator TGeneralIdentityRelation() const
{ return iIdentity; }
template <class T>
inline TLinearOrder<T>::TLinearOrder( TInt(*anOrder)(const T&, const T&) )
#line 3288
{ iOrder=(TGeneralLinearOrder)anOrder; }
template <class T>
inline TLinearOrder<T>::operator TGeneralLinearOrder() const
{ return iOrder; }
#line 3312
template <class T>
inline RPointerArray<T>::RPointerArray()
: RPointerArrayBase()
{}
#line 3331
template <class T>
inline RPointerArray<T>::RPointerArray(TInt aGranularity)
: RPointerArrayBase(aGranularity)
{}
#line 3354
template <class T>
inline RPointerArray<T>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
: RPointerArrayBase(aMinGrowBy, aFactor)
{}
template <class T>
inline void RPointerArray<T>::Close()
#line 3372
{RPointerArrayBase::Close();}
template <class T>
inline TInt RPointerArray<T>::Count() const
{ return RPointerArrayBase::Count(); }
template <class T>
inline T* const& RPointerArray<T>::operator[](TInt anIndex) const
#line 3408
{return (T* const&)At(anIndex);}
template <class T>
inline T*& RPointerArray<T>::operator[](TInt anIndex)
#line 3432
{return (T*&)At(anIndex);}
template <class T>
inline TInt RPointerArray<T>::Append(const T* anEntry)
#line 3447
{ return RPointerArrayBase::Append(anEntry); }
template <class T>
inline TInt RPointerArray<T>::Insert(const T* anEntry, TInt aPos)
#line 3468
{ return RPointerArrayBase::Insert(anEntry,aPos); }
template <class T>
inline void RPointerArray<T>::Remove(TInt anIndex)
#line 3488
{RPointerArrayBase::Remove(anIndex);}
template <class T>
inline void RPointerArray<T>::Compress()
#line 3503
{RPointerArrayBase::Compress();}
template <class T>
inline void RPointerArray<T>::Reset()
#line 3522
{RPointerArrayBase::Reset();}
template <class T>
inline TInt RPointerArray<T>::Find(const T* anEntry) const
#line 3542
{ return RPointerArrayBase::Find(anEntry); }
template <class T>
inline TInt RPointerArray<T>::Find(const T* anEntry, TIdentityRelation<T> anIdentity) const
#line 3566
{ return RPointerArrayBase::Find(anEntry,anIdentity); }
template <class T>
inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry) const
#line 3584
{ return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
template <class T>
inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const
#line 3606
{ return RPointerArrayBase::FindIsq(anEntry,anOrder); }
template <class T>
inline TInt RPointerArray<T>::FindInAddressOrder(const T* anEntry, TInt& anIndex) const
#line 3631
{ return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
template <class T>
inline TInt RPointerArray<T>::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
#line 3660
{ return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); }
template <class T>
inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const
#line 3691
{ return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
template <class T>
inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const
#line 3726
{ return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); }
template <class T>
inline TInt RPointerArray<T>::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const
#line 3766
{ return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
template <class T>
inline TInt RPointerArray<T>::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
#line 3810
{ return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); }
template <class T>
inline TInt RPointerArray<T>::InsertInAddressOrder(const T* anEntry)
#line 3833
{ return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
template <class T>
inline TInt RPointerArray<T>::InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder)
#line 3862
{ return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); }
template <class T>
inline TInt RPointerArray<T>::InsertInAddressOrderAllowRepeats(const T* anEntry)
#line 3885
{ return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
template <class T>
inline TInt RPointerArray<T>::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder)
#line 3911
{ return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); }
template <class T>
inline RPointerArray<T>::RPointerArray(T** aEntries, TInt aCount)
: RPointerArrayBase((TAny **)aEntries, aCount)
#line 3935
{}
template <class T>
inline void RPointerArray<T>::GranularCompress()
#line 3950
{RPointerArrayBase::GranularCompress();}
template <class T>
inline TInt RPointerArray<T>::Reserve(TInt aCount)
#line 3969
{ return RPointerArrayBase::DoReserve(aCount); }
template <class T>
inline void RPointerArray<T>::SortIntoAddressOrder()
{ HeapSortUnsigned(); }
template <class T>
inline void RPointerArray<T>::Sort(TLinearOrder<T> anOrder)
#line 3996
{ HeapSort(anOrder); }
template <class T>
inline TArray<T*> RPointerArray<T>::Array() const
{ return TArray<T*>(GetCount,GetElementPtr,(const CBase*)this); }
template <class T>
void RPointerArray<T>::ResetAndDestroy()
#line 4026
{
TInt c=Count();
T** pE=(T**)Entries();
ZeroCount();
TInt i;
for (i=0; i<c; i++)
{
delete *pE;
pE++;
}
Reset();
}
#line 4049
inline RPointerArray<TAny>::RPointerArray()
: RPointerArrayBase()
{}
#line 4067
inline RPointerArray<TAny>::RPointerArray(TInt aGranularity)
: RPointerArrayBase(aGranularity)
{}
#line 4089
inline RPointerArray<TAny>::RPointerArray(TInt aMinGrowBy, TInt aFactor)
: RPointerArrayBase(aMinGrowBy, aFactor)
{}
inline void RPointerArray<TAny>::Close()
#line 4105
{RPointerArrayBase::Close();}
inline TInt RPointerArray<TAny>::Count() const
{ return RPointerArrayBase::Count(); }
inline TAny* const& RPointerArray<TAny>::operator[](TInt anIndex) const
#line 4139
{return At(anIndex);}
inline TAny*& RPointerArray<TAny>::operator[](TInt anIndex)
#line 4162
{return At(anIndex);}
inline TInt RPointerArray<TAny>::Append(const TAny* anEntry)
#line 4176
{ return RPointerArrayBase::Append(anEntry); }
inline TInt RPointerArray<TAny>::Insert(const TAny* anEntry, TInt aPos)
#line 4196
{ return RPointerArrayBase::Insert(anEntry,aPos); }
inline void RPointerArray<TAny>::Remove(TInt anIndex)
#line 4215
{RPointerArrayBase::Remove(anIndex);}
inline void RPointerArray<TAny>::Compress()
#line 4229
{RPointerArrayBase::Compress();}
inline void RPointerArray<TAny>::Reset()
#line 4247
{RPointerArrayBase::Reset();}
inline TInt RPointerArray<TAny>::Find(const TAny* anEntry) const
#line 4266
{ return RPointerArrayBase::Find(anEntry); }
inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry) const
#line 4283
{ return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); }
inline TInt RPointerArray<TAny>::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const
#line 4307
{ return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); }
inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const
#line 4337
{ return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); }
inline TInt RPointerArray<TAny>::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const
#line 4376
{ return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); }
inline TInt RPointerArray<TAny>::InsertInAddressOrder(const TAny* anEntry)
#line 4398
{ return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); }
inline TInt RPointerArray<TAny>::InsertInAddressOrderAllowRepeats(const TAny* anEntry)
#line 4420
{ return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); }
inline RPointerArray<TAny>::RPointerArray(TAny** aEntries, TInt aCount)
: RPointerArrayBase((TAny **)aEntries, aCount)
#line 4443
{}
inline void RPointerArray<TAny>::GranularCompress()
#line 4457
{RPointerArrayBase::GranularCompress();}
inline void RPointerArray<TAny>::SortIntoAddressOrder()
{ HeapSortUnsigned(); }
inline TArray<TAny*> RPointerArray<TAny>::Array() const
{ return TArray<TAny*>(GetCount,GetElementPtr,(const CBase*)this); }
template <class T>
inline RArray<T>::RArray()
: RArrayBase(sizeof(T))
#line 4497
{}
template <class T>
inline RArray<T>::RArray(TInt aGranularity)
: RArrayBase(sizeof(T),aGranularity)
#line 4519
{}
template <class T>
inline RArray<T>::RArray(TInt aGranularity, TInt aKeyOffset)
: RArrayBase(sizeof(T),aGranularity,aKeyOffset)
#line 4543
{}
#line 4567
template <class T>
inline RArray<T>::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor)
: RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor)
{}
template <class T>
inline void RArray<T>::Close()
{RArrayBase::Close();}
template <class T>
inline TInt RArray<T>::Count() const
{return RArrayBase::Count();}
template <class T>
inline const T& RArray<T>::operator[](TInt anIndex) const
#line 4616
{return *(const T*)At(anIndex); }
template <class T>
inline T& RArray<T>::operator[](TInt anIndex)
#line 4638
{return *(T*)At(anIndex); }
template <class T>
inline TInt RArray<T>::Append(const T& anEntry)
#line 4653
{return RArrayBase::Append(&anEntry);}
template <class T>
inline TInt RArray<T>::Insert(const T& anEntry, TInt aPos)
#line 4675
{return RArrayBase::Insert(&anEntry,aPos);}
template <class T>
inline void RArray<T>::Remove(TInt anIndex)
#line 4692
{RArrayBase::Remove(anIndex);}
template <class T>
inline void RArray<T>::Compress()
{RArrayBase::Compress();}
template <class T>
inline void RArray<T>::Reset()
#line 4721
{RArrayBase::Reset();}
template <class T>
inline TInt RArray<T>::Find(const T& anEntry) const
#line 4743
{return RArrayBase::Find(&anEntry);}
template <class T>
inline TInt RArray<T>::Find(const T& anEntry, TIdentityRelation<T> anIdentity) const
#line 4768
{return RArrayBase::Find(&anEntry,anIdentity);}
template <class T>
inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry) const
#line 4787
{return RArrayBase::FindIsqSigned(&anEntry);}
template <class T>
inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry) const
#line 4806
{return RArrayBase::FindIsqUnsigned(&anEntry);}
template <class T>
inline TInt RArray<T>::FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const
#line 4828
{return RArrayBase::FindIsq(&anEntry,anOrder);}
template <class T>
inline TInt RArray<T>::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const
#line 4851
{return RArrayBase::BinarySearchSigned(&anEntry,anIndex);}
template <class T>
inline TInt RArray<T>::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const
#line 4875
{return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);}
template <class T>
inline TInt RArray<T>::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const
#line 4902
{return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);}
template <class T>
inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const
#line 4936
{return RArrayBase::FindIsqSigned(&anEntry,aMode);}
template <class T>
inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const
#line 4970
{return RArrayBase::FindIsqUnsigned(&anEntry,aMode);}
template <class T>
inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const
#line 5003
{return RArrayBase::FindIsq(&anEntry,anOrder,aMode);}
template <class T>
inline TInt RArray<T>::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
#line 5042
{return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);}
template <class T>
inline TInt RArray<T>::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const
#line 5081
{return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);}
template <class T>
inline TInt RArray<T>::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const
#line 5123
{return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);}
template <class T>
inline TInt RArray<T>::InsertInSignedKeyOrder(const T& anEntry)
#line 5146
{return RArrayBase::InsertIsqSigned(&anEntry,EFalse);}
template <class T>
inline TInt RArray<T>::InsertInUnsignedKeyOrder(const T& anEntry)
#line 5169
{return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);}
template <class T>
inline TInt RArray<T>::InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder)
#line 5197
{return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);}
template <class T>
inline TInt RArray<T>::InsertInSignedKeyOrderAllowRepeats(const T& anEntry)
#line 5221
{return RArrayBase::InsertIsqSigned(&anEntry,ETrue);}
template <class T>
inline TInt RArray<T>::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry)
#line 5245
{return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);}
template <class T>
inline TInt RArray<T>::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder)
#line 5272
{return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);}
template <class T>
inline RArray<T>::RArray(TInt aEntrySize,T* aEntries, TInt aCount)
: RArrayBase(aEntrySize,aEntries,aCount)
#line 5303
{}
template <class T>
inline void RArray<T>::GranularCompress()
#line 5318
{RArrayBase::GranularCompress();}
template <class T>
inline TInt RArray<T>::Reserve(TInt aCount)
#line 5337
{ return RArrayBase::DoReserve(aCount); }
template <class T>
inline void RArray<T>::SortSigned()
{HeapSortSigned();}
template <class T>
inline void RArray<T>::SortUnsigned()
{HeapSortUnsigned();}
template <class T>
inline void RArray<T>::Sort(TLinearOrder<T> anOrder)
#line 5375
{HeapSort(anOrder);}
template <class T>
inline TArray<T> RArray<T>::Array() const
{ return TArray<T>(GetCount,GetElementPtr,(const CBase*)this); }
inline RArray<TInt>::RArray()
: RPointerArrayBase()
{}
inline RArray<TInt>::RArray(TInt aGranularity)
: RPointerArrayBase(aGranularity)
#line 5417
{}
#line 5437
inline RArray<TInt>::RArray(TInt aMinGrowBy, TInt aFactor)
: RPointerArrayBase(aMinGrowBy, aFactor)
{}
inline void RArray<TInt>::Close()
{RPointerArrayBase::Close();}
inline TInt RArray<TInt>::Count() const
{ return RPointerArrayBase::Count(); }
inline const TInt& RArray<TInt>::operator[](TInt anIndex) const
#line 5484
{return (const TInt&)At(anIndex);}
inline TInt& RArray<TInt>::operator[](TInt anIndex)
#line 5507
{return (TInt&)At(anIndex);}
inline TInt RArray<TInt>::Append(TInt anEntry)
#line 5521
{ return RPointerArrayBase::Append((const TAny*)anEntry); }
inline TInt RArray<TInt>::Insert(TInt anEntry, TInt aPos)
#line 5541
{ return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
inline void RArray<TInt>::Remove(TInt anIndex)
#line 5558
{RPointerArrayBase::Remove(anIndex);}
inline void RArray<TInt>::Compress()
{RPointerArrayBase::Compress();}
inline void RArray<TInt>::Reset()
#line 5586
{RPointerArrayBase::Reset();}
inline TInt RArray<TInt>::Find(TInt anEntry) const
#line 5604
{ return RPointerArrayBase::Find((const TAny*)anEntry); }
inline TInt RArray<TInt>::FindInOrder(TInt anEntry) const
#line 5621
{ return RPointerArrayBase::FindIsqSigned(anEntry); }
inline TInt RArray<TInt>::FindInOrder(TInt anEntry, TInt& anIndex) const
#line 5644
{ return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); }
inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt aMode) const
#line 5675
{ return RPointerArrayBase::FindIsqSigned(anEntry,aMode); }
inline TInt RArray<TInt>::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const
#line 5713
{ return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); }
inline TInt RArray<TInt>::InsertInOrder(TInt anEntry)
#line 5735
{ return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); }
inline TInt RArray<TInt>::InsertInOrderAllowRepeats(TInt anEntry)
#line 5758
{ return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); }
inline RArray<TInt>::RArray(TInt* aEntries, TInt aCount)
: RPointerArrayBase((TAny**)aEntries, aCount)
#line 5781
{}
inline void RArray<TInt>::GranularCompress()
#line 5792
{RPointerArrayBase::GranularCompress();}
inline TInt RArray<TInt>::Reserve(TInt aCount)
#line 5810
{ return RPointerArrayBase::DoReserve(aCount); }
inline void RArray<TInt>::Sort()
{ HeapSortSigned(); }
inline TArray<TInt> RArray<TInt>::Array() const
{ return TArray<TInt>(GetCount,GetElementPtr,(const CBase*)this); }
inline RArray<TUint>::RArray()
: RPointerArrayBase()
#line 5847
{}
inline RArray<TUint>::RArray(TInt aGranularity)
: RPointerArrayBase(aGranularity)
#line 5863
{}
#line 5883
inline RArray<TUint>::RArray(TInt aMinGrowBy, TInt aFactor)
: RPointerArrayBase(aMinGrowBy, aFactor)
{}
inline void RArray<TUint>::Close()
{RPointerArrayBase::Close();}
inline TInt RArray<TUint>::Count() const
{return RPointerArrayBase::Count(); }
inline const TUint& RArray<TUint>::operator[](TInt anIndex) const
#line 5930
{return (const TUint&)At(anIndex);}
inline TUint& RArray<TUint>::operator[](TInt anIndex)
#line 5953
{return (TUint&)At(anIndex);}
inline TInt RArray<TUint>::Append(TUint anEntry)
{ return RPointerArrayBase::Append((const TAny*)anEntry); }
inline TInt RArray<TUint>::Insert(TUint anEntry, TInt aPos)
#line 5987
{ return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); }
inline void RArray<TUint>::Remove(TInt anIndex)
#line 6005
{RPointerArrayBase::Remove(anIndex);}
inline void RArray<TUint>::Compress()
{RPointerArrayBase::Compress();}
inline void RArray<TUint>::Reset()
#line 6033
{RPointerArrayBase::Reset();}
inline TInt RArray<TUint>::Find(TUint anEntry) const
#line 6051
{ return RPointerArrayBase::Find((const TAny*)anEntry); }
inline TInt RArray<TUint>::FindInOrder(TUint anEntry) const
#line 6070
{ return RPointerArrayBase::FindIsqUnsigned(anEntry); }
inline TInt RArray<TUint>::FindInOrder(TUint anEntry, TInt& anIndex) const
#line 6098
{ return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); }
inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt aMode) const
#line 6128
{ return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); }
inline TInt RArray<TUint>::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const
#line 6163
{ return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); }
inline TInt RArray<TUint>::InsertInOrder(TUint anEntry)
#line 6185
{ return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); }
inline TInt RArray<TUint>::InsertInOrderAllowRepeats(TUint anEntry)
#line 6208
{ return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); }
inline RArray<TUint>::RArray(TUint* aEntries, TInt aCount)
: RPointerArrayBase((TAny**)aEntries, aCount)
#line 6231
{}
inline void RArray<TUint>::GranularCompress()
#line 6244
{RPointerArrayBase::GranularCompress();}
inline TInt RArray<TUint>::Reserve(TInt aCount)
#line 6262
{ return RPointerArrayBase::DoReserve(aCount); }
inline void RArray<TUint>::Sort()
{ HeapSortUnsigned(); }
inline TArray<TUint> RArray<TUint>::Array() const
{ return TArray<TUint>(GetCount,GetElementPtr,(const CBase*)this); }
#line 6293
inline void TIpcArgs::Set(TInt,TNothing)
{}
#line 6307
inline void TIpcArgs::Set(TInt aIndex,TInt aValue)
{
iArgs[aIndex] = aValue;
iFlags |= EUnspecified<<(aIndex*KBitsPerType);
}
#line 6324
inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue)
{
iArgs[aIndex] = (TInt)aValue;
iFlags |= EUnspecified<<(aIndex*KBitsPerType);
}
#line 6341
inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue)
{
iArgs[aIndex] = (TInt)aValue.Handle();
iFlags |= EHandle<<(aIndex*KBitsPerType);
}
#line 6358
inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue)
{
iArgs[aIndex] = (TInt)aValue;
iFlags |= EDesC8<<(aIndex*KBitsPerType);
}
#line 6377
inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue)
{
iArgs[aIndex] = (TInt)aValue;
iFlags |= EDesC16<<(aIndex*KBitsPerType);
}
#line 6396
inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue)
{
iArgs[aIndex] = (TInt)aValue;
iFlags |= EDes8<<(aIndex*KBitsPerType);
}
#line 6415
inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue)
{
iArgs[aIndex] = (TInt)aValue;
iFlags |= EDes16<<(aIndex*KBitsPerType);
}
inline TIpcArgs::TArgType TIpcArgs::Type(TNothing)
{ return EUnspecified; }
inline TIpcArgs::TArgType TIpcArgs::Type(TInt)
{ return EUnspecified; }
inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*)
{ return EUnspecified; }
inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase)
{ return EHandle; }
inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*)
{ return EDesC8; }
inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*)
{ return EDesC16; }
inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*)
{ return EDes8; }
inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*)
{ return EDes16; }
inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing)
{}
inline void TIpcArgs::Assign(TInt& aArg,TInt aValue)
{ aArg = aValue; }
inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue)
{ aArg = (TInt)aValue; }
inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue)
{ aArg = (TInt)aValue.Handle(); }
inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue)
{ aArg = (TInt)aValue; }
inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue)
{ aArg = (TInt)aValue; }
inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue)
{ aArg = (TInt)aValue; }
inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue)
{ aArg = (TInt)aValue; }
inline SInt64::SInt64()
{}
inline SInt64::SInt64(Int64 a)
{
iData[0] = (TUint32)((Uint64)a);
iData[1] = (TUint32)(((Uint64)a)>>32);
}
inline SInt64& SInt64::operator=(Int64 a)
{
iData[0] = (TUint32)((Uint64)a);
iData[1] = (TUint32)(((Uint64)a)>>32);
return *this;
}
inline SInt64::operator Int64() const
{
Int64 x;
TUint32* px = (TUint32*)&x;
px[0] = iData[0];
px[1] = iData[1];
return x;
}
inline SUint64::SUint64()
{}
inline SUint64::SUint64(Uint64 a)
{
iData[0] = (TUint32)a;
iData[1] = (TUint32)(a>>32);
}
inline SUint64& SUint64::operator=(Uint64 a)
{
iData[0] = (TUint32)a;
iData[1] = (TUint32)(a>>32);
return *this;
}
inline SUint64::operator Uint64() const
{
Uint64 x;
TUint32* px = (TUint32*)&x;
px[0] = iData[0];
px[1] = iData[1];
return x;
}
inline SDouble::SDouble()
{}
inline SDouble::SDouble(TReal a)
{
const TUint32* pa = (const TUint32*)&a;
iData[0] = pa[0];
iData[1] = pa[1];
}
inline SDouble& SDouble::operator=(TReal a)
{
new (this) SDouble(a);
return *this;
}
inline SDouble::operator TReal() const
{
TReal x;
TUint32* px = (TUint32*)&x;
px[0] = iData[0];
px[1] = iData[1];
return x;
}
inline TSecureId::TSecureId()
{}
inline TSecureId::TSecureId(TUint32 aId)
: iId(aId) {}
inline TSecureId::operator TUint32() const
{ return iId; }
inline TSecureId::TSecureId(TUid aId)
: iId(aId.iUid) {}
inline TSecureId::operator TUid() const
{ return (TUid&)iId; }
inline const TSecureId* SSecureId::operator&() const
{ return (const TSecureId*)this; }
inline SSecureId::operator const TSecureId&() const
{ return (const TSecureId&)iId; }
inline SSecureId::operator TUint32() const
{ return iId; }
inline SSecureId::operator TUid() const
{ return (TUid&)iId; }
inline TVendorId::TVendorId()
{}
inline TVendorId::TVendorId(TUint32 aId)
: iId(aId) {}
inline TVendorId::operator TUint32() const
{ return iId; }
inline TVendorId::TVendorId(TUid aId)
: iId(aId.iUid) {}
inline TVendorId::operator TUid() const
{ return (TUid&)iId; }
inline const TVendorId* SVendorId::operator&() const
{ return (const TVendorId*)this; }
inline SVendorId::operator const TVendorId&() const
{ return (const TVendorId&)iId; }
inline SVendorId::operator TUint32() const
{ return iId; }
inline SVendorId::operator TUid() const
{ return (TUid&)iId; }
inline TCapabilitySet::TCapabilitySet()
{}
inline TCapabilitySet::TCapabilitySet(TCapability aCapability)
{ new (this) TCapabilitySet(aCapability, aCapability); }
inline void TCapabilitySet::Set(TCapability aCapability)
{ new (this) TCapabilitySet(aCapability, aCapability); }
inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2)
{ new (this) TCapabilitySet(aCapability1, aCapability2); }
inline TSecurityInfo::TSecurityInfo()
{}
inline TSecurityPolicy::TSecurityPolicy()
{ new (this) TSecurityPolicy(EAlwaysFail); }
inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const
{ return (const TSecurityPolicy*)this; }
inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const
{ return *(const TSecurityPolicy*)this; }
inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const
{ return *(const TSecurityPolicy*)this; }
#line 6341 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32cmn.h" /* stack depth 5 */
#line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32std.h" /* stack depth 4 */
class TFunctor
{
public:
__declspec(dllexport) virtual void operator()() =0;
};
#line 53
class TCallBack
{
public:
inline TCallBack();
inline TCallBack(TInt (*aFunction)(TAny* aPtr));
inline TCallBack(TInt (*aFunction)(TAny* aPtr),TAny* aPtr);
inline TInt CallBack() const;
public:
TInt (*iFunction)(TAny* aPtr);
TAny* iPtr;
};
#line 89
class TSglQueLink
{
public:
inline TSglQueLink() : iNext(0 )
{}
private:
__declspec(dllexport) void Enque(TSglQueLink* aLink);
public:
TSglQueLink* iNext;
friend class TSglQueBase;
};
#line 130
class TDblQueLinkBase
{
public:
inline TDblQueLinkBase() : iNext(0 )
{}
__declspec(dllexport) void Enque(TDblQueLinkBase* aLink);
__declspec(dllexport) void AddBefore(TDblQueLinkBase* aLink);
public:
TDblQueLinkBase* iNext;
TDblQueLinkBase* iPrev;
};
#line 166
class TDblQueLink : public TDblQueLinkBase
{
public:
__declspec(dllexport) void Deque();
};
#line 184
class TPriQueLink : public TDblQueLink
{
public:
TInt iPriority;
};
#line 205
class TDeltaQueLink : public TDblQueLinkBase
{
public:
TInt iDelta;
};
#line 224
class TTickCountQueLink : public TDblQueLink
{
public:
TUint iTickCount;
};
#line 248
class TSglQueBase
{
public:
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) void SetOffset(TInt aOffset);
__declspec(dllexport) void Reset();
protected:
__declspec(dllexport) TSglQueBase();
__declspec(dllexport) TSglQueBase(TInt aOffset);
__declspec(dllexport) void DoAddFirst(TAny* aPtr);
__declspec(dllexport) void DoAddLast(TAny* aPtr);
__declspec(dllexport) void DoRemove(TAny* aPtr);
protected:
TSglQueLink* iHead;
TSglQueLink* iLast;
TInt iOffset;
private:
TSglQueBase(const TSglQueBase& aQue);
TSglQueBase &operator=(const TSglQueBase& aQue);
friend class TSglQueIterBase;
};
#line 296
class TDblQueBase
{
public:
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) void SetOffset(TInt aOffset);
__declspec(dllexport) void Reset();
protected:
__declspec(dllexport) TDblQueBase();
__declspec(dllexport) TDblQueBase(TInt aOffset);
__declspec(dllexport) void DoAddFirst(TAny* aPtr);
__declspec(dllexport) void DoAddLast(TAny* aPtr);
__declspec(dllexport) void DoAddPriority(TAny* aPtr);
__declspec(dllexport) void __DbgTestEmpty() const;
protected:
TDblQueLink iHead;
TInt iOffset;
private:
TDblQueBase(const TDblQueBase& aQue);
TDblQueBase& operator=(const TDblQueBase& aQue);
friend class TDblQueIterBase;
};
#line 338
class TDeltaQueBase : public TDblQueBase
{
public:
__declspec(dllexport) TBool CountDown();
__declspec(dllexport) TBool CountDown(TInt aValue);
__declspec(dllexport) TBool FirstDelta(TInt& aValue);
__declspec(dllexport) void Reset();
protected:
__declspec(dllexport) TDeltaQueBase();
__declspec(dllexport) TDeltaQueBase(TInt aOffset);
__declspec(dllexport) void DoAddDelta(TAny* aPtr,TInt aDelta);
__declspec(dllexport) void DoRemove(TAny* aPtr);
__declspec(dllexport) TAny* DoRemoveFirst();
protected:
TInt* iFirstDelta;
};
#line 375
template <class T>
class TSglQue : public TSglQueBase
{
public:
inline TSglQue();
inline explicit TSglQue(TInt aOffset);
inline void AddFirst(T& aRef);
inline void AddLast(T& aRef);
inline TBool IsFirst(const T* aPtr) const;
inline TBool IsLast(const T* aPtr) const;
inline T* First() const;
inline T* Last() const;
inline void Remove(T& aRef);
};
#line 407
template <class T>
class TDblQue : public TDblQueBase
{
public:
inline TDblQue();
inline explicit TDblQue(TInt aOffset);
inline void AddFirst(T& aRef);
inline void AddLast(T& aRef);
inline TBool IsHead(const T* aPtr) const;
inline TBool IsFirst(const T* aPtr) const;
inline TBool IsLast(const T* aPtr) const;
inline T* First() const;
inline T* Last() const;
};
#line 441
template <class T>
class TPriQue : public TDblQueBase
{
public:
inline TPriQue();
inline explicit TPriQue(TInt aOffset);
inline void Add(T& aRef);
inline TBool IsHead(const T* aPtr) const;
inline TBool IsFirst(const T* aPtr) const;
inline TBool IsLast(const T* aPtr) const;
inline T* First() const;
inline T* Last() const;
};
#line 487
template <class T>
class TDeltaQue : public TDeltaQueBase
{
public:
inline TDeltaQue();
inline explicit TDeltaQue(TInt aOffset);
inline void Add(T& aRef,TInt aDelta);
inline void Remove(T& aRef);
inline T* RemoveFirst();
};
class TTickCountQueLink;
#line 520
class TTickCountQue : public TDblQueBase
{
public:
TTickCountQue();
void Add(TTickCountQueLink& aRef);
TTickCountQueLink* First() const;
TTickCountQueLink* RemoveFirst();
TTickCountQueLink* RemoveFirst(TUint aTickCount);
};
#line 543
class TSglQueIterBase
{
public:
__declspec(dllexport) void SetToFirst();
protected:
__declspec(dllexport) TSglQueIterBase(TSglQueBase& aQue);
__declspec(dllexport) TAny* DoPostInc();
__declspec(dllexport) TAny* DoCurrent();
__declspec(dllexport) void DoSet(TAny* aLink);
protected:
TInt iOffset;
TSglQueLink* iHead;
TSglQueLink* iNext;
};
#line 571
template <class T>
class TSglQueIter : public TSglQueIterBase
{
public:
inline TSglQueIter(TSglQueBase& aQue);
inline void Set(T& aLink);
inline operator T*();
inline T* operator++(TInt);
};
#line 594
class TDblQueIterBase
{
public:
__declspec(dllexport) void SetToFirst();
__declspec(dllexport) void SetToLast();
protected:
__declspec(dllexport) TDblQueIterBase(TDblQueBase& aQue);
__declspec(dllexport) TAny* DoPostInc();
__declspec(dllexport) TAny* DoPostDec();
__declspec(dllexport) TAny* DoCurrent();
__declspec(dllexport) void DoSet(TAny* aLink);
protected:
TInt iOffset;
TDblQueLinkBase* iHead;
TDblQueLinkBase* iNext;
};
#line 635
template <class T>
class TDblQueIter : public TDblQueIterBase
{
public:
inline TDblQueIter(TDblQueBase& aQue);
inline void Set(T& aLink);
inline operator T*();
inline T* operator++(TInt);
inline T* operator--(TInt);
};
#line 660
enum TKeyCmpText
{
ECmpNormal,
#line 682
ECmpNormal8,
#line 696
ECmpNormal16,
#line 706
ECmpFolded,
#line 717
ECmpFolded8,
#line 728
ECmpFolded16,
#line 738
ECmpCollated,
#line 749
ECmpCollated8,
#line 761
ECmpCollated16
};
#line 777
enum TKeyCmpNumeric
{
ECmpTInt8=((ECmpCollated16+1)<<1),
ECmpTInt16,
ECmpTInt32,
ECmpTInt,
ECmpTUint8,
ECmpTUint16,
ECmpTUint32,
ECmpTUint,
ECmpTInt64
};
#line 856
class TKey
{
public:
inline void SetPtr(const TAny* aPtr);
__declspec(dllexport) virtual TInt Compare(TInt aLeft,TInt aRight) const;
__declspec(dllexport) virtual TAny* At(TInt anIndex) const;
protected:
__declspec(dllexport) TKey();
__declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType);
__declspec(dllexport) TKey(TInt aOffset,TKeyCmpText aType,TInt aLength);
__declspec(dllexport) TKey(TInt aOffset,TKeyCmpNumeric aType);
protected:
TInt iKeyOffset;
TInt iKeyLength;
TInt iCmpType;
const TAny* iPtr;
};
#line 890
class TSwap
{
public:
__declspec(dllexport) TSwap();
__declspec(dllexport) virtual void Swap(TInt aLeft,TInt aRight) const;
};
#line 918
class TCharF : public TChar
{
public:
inline TCharF(TUint aChar);
inline TCharF(const TChar& aChar);
inline TCharF& operator=(TUint aChar);
inline TCharF& operator=(const TChar& aChar);
};
#line 937
class TCharLC : public TChar
{
public:
inline TCharLC(TUint aChar);
inline TCharLC(const TChar& aChar);
inline TCharLC& operator=(TUint aChar);
inline TCharLC& operator=(const TChar& aChar);
};
#line 956
class TCharUC : public TChar
{
public:
inline TCharUC(TUint aChar);
inline TCharUC(const TChar& aChar);
inline TCharUC& operator=(TUint aChar);
inline TCharUC& operator=(const TChar& aChar);
};
#line 982
class TRealFormat
{
public:
__declspec(dllexport) TRealFormat();
__declspec(dllexport) TRealFormat(TInt aWidth);
__declspec(dllexport) TRealFormat(TInt aWidth,TInt aDecimalPlaces);
public:
#line 1007
TInt iType;
TInt iWidth;
#line 1025
TInt iPlaces;
#line 1038
TChar iPoint;
#line 1051
TChar iTriad;
#line 1071
TInt iTriLen;
};
#line 1089
class TLexMark8
{
public:
inline TLexMark8();
private:
inline TLexMark8(const TUint8* aString);
const TUint8* iPtr;
friend class TLex8;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
class TRealX;
#line 1123
class TLex8
{
public:
__declspec(dllexport) TLex8();
inline TLex8(const TUint8* aString);
inline TLex8(const TDesC8& aDes);
inline TLex8& operator=(const TUint8* aString);
inline TLex8& operator=(const TDesC8& aDes);
inline TBool Eos() const;
inline void Mark(TLexMark8& aMark) const;
inline void Mark();
__declspec(dllexport) void Inc();
__declspec(dllexport) void Inc(TInt aNumber);
__declspec(dllexport) TChar Get();
__declspec(dllexport) TChar Peek() const;
__declspec(dllexport) void UnGet();
inline void UnGetToMark();
__declspec(dllexport) void UnGetToMark(const TLexMark8 aMark);
__declspec(dllexport) void SkipSpace();
inline void SkipAndMark(TInt aNumber);
__declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark8& aMark);
inline void SkipSpaceAndMark();
__declspec(dllexport) void SkipSpaceAndMark(TLexMark8& aMark);
__declspec(dllexport) void SkipCharacters();
inline TInt TokenLength() const;
__declspec(dllexport) TInt TokenLength(const TLexMark8 aMark) const;
__declspec(dllexport) TPtrC8 MarkedToken() const;
__declspec(dllexport) TPtrC8 MarkedToken(const TLexMark8 aMark) const;
__declspec(dllexport) TPtrC8 NextToken();
__declspec(dllexport) TPtrC8 Remainder() const;
__declspec(dllexport) TPtrC8 RemainderFromMark() const;
__declspec(dllexport) TPtrC8 RemainderFromMark(const TLexMark8 aMark) const;
__declspec(dllexport) TInt Offset() const;
inline TInt MarkedOffset() const;
__declspec(dllexport) TInt MarkedOffset(const TLexMark8 aMark) const;
__declspec(dllexport) TInt Val(TInt8& aVal);
__declspec(dllexport) TInt Val(TInt16& aVal);
__declspec(dllexport) TInt Val(TInt32& aVal);
__declspec(dllexport) TInt Val(TInt64& aVal);
inline TInt Val(TInt& aVal);
__declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
__declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
__declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
__declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
__declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
__declspec(dllexport) TInt Val(TReal32& aVal);
__declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
__declspec(dllexport) TInt Val(TReal64& aVal);
__declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
inline void Assign(const TLex8& aLex);
__declspec(dllexport) void Assign(const TUint8* aString);
__declspec(dllexport) void Assign(const TDesC8& aDes);
TInt Val(TRealX& aVal);
TInt Val(TRealX& aVal, TChar aPoint);
inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
private:
void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
void ScndigAfterPoint(TInt& aSig,TInt64& aDl);
void ValidateMark(const TLexMark8 aMark) const;
private:
const TUint8* iNext;
const TUint8* iBuf;
const TUint8* iEnd;
TLexMark8 iMark;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
#line 1220
class TLexMark16
{
public:
inline TLexMark16();
private:
inline TLexMark16(const TUint16* aString);
const TUint16* iPtr;
friend class TLex16;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
#line 1253
class TLex16
{
public:
__declspec(dllexport) TLex16();
inline TLex16(const TUint16* aString);
inline TLex16(const TDesC16& aDes);
inline TLex16& operator=(const TUint16* aString);
inline TLex16& operator=(const TDesC16& aDes);
inline TBool Eos() const;
inline void Mark();
inline void Mark(TLexMark16& aMark) const;
__declspec(dllexport) void Inc();
__declspec(dllexport) void Inc(TInt aNumber);
__declspec(dllexport) TChar Get();
__declspec(dllexport) TChar Peek() const;
__declspec(dllexport) void UnGet();
inline void UnGetToMark();
__declspec(dllexport) void UnGetToMark(const TLexMark16 aMark);
__declspec(dllexport) void SkipSpace();
inline void SkipAndMark(TInt aNumber);
__declspec(dllexport) void SkipAndMark(TInt aNumber, TLexMark16& aMark);
__declspec(dllexport) void SkipSpaceAndMark(TLexMark16& aMark);
inline void SkipSpaceAndMark();
__declspec(dllexport) void SkipCharacters();
inline TInt TokenLength() const;
__declspec(dllexport) TInt TokenLength(const TLexMark16 aMark) const;
__declspec(dllexport) TPtrC16 MarkedToken() const;
__declspec(dllexport) TPtrC16 MarkedToken(const TLexMark16 aMark) const;
__declspec(dllexport) TPtrC16 NextToken();
__declspec(dllexport) TPtrC16 Remainder() const;
__declspec(dllexport) TPtrC16 RemainderFromMark() const;
__declspec(dllexport) TPtrC16 RemainderFromMark(const TLexMark16 aMark) const;
__declspec(dllexport) TInt Offset() const;
inline TInt MarkedOffset() const;
__declspec(dllexport) TInt MarkedOffset(const TLexMark16 aMark) const;
__declspec(dllexport) TInt Val(TInt8& aVal);
__declspec(dllexport) TInt Val(TInt16& aVal);
__declspec(dllexport) TInt Val(TInt32& aVal);
__declspec(dllexport) TInt Val(TInt64& aVal);
inline TInt Val(TInt& aVal);
__declspec(dllexport) TInt Val(TUint8& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TUint16& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TUint32& aVal,TRadix aRadix);
__declspec(dllexport) TInt Val(TInt64& aVal, TRadix aRadix);
inline TInt Val(TUint& aVal,TRadix aRadix=EDecimal);
__declspec(dllexport) TInt BoundedVal(TInt32& aVal,TInt aLimit);
__declspec(dllexport) TInt BoundedVal(TInt64& aVal, const TInt64& aLimit);
__declspec(dllexport) TInt BoundedVal(TUint32& aVal,TRadix aRadix,TUint aLimit);
__declspec(dllexport) TInt BoundedVal(TInt64& aVal, TRadix aRadix, const TInt64& aLimit);
__declspec(dllexport) TInt Val(TReal32& aVal);
__declspec(dllexport) TInt Val(TReal32& aVal,TChar aPoint);
__declspec(dllexport) TInt Val(TReal64& aVal);
__declspec(dllexport) TInt Val(TReal64& aVal,TChar aPoint);
inline void Assign(const TLex16& aLex);
__declspec(dllexport) void Assign(const TUint16* aString);
__declspec(dllexport) void Assign(const TDesC16& aDes);
TInt Val(TRealX& aVal);
TInt Val(TRealX& aVal, TChar aPoint);
inline TInt Val(TInt32& aVal,TInt aLimit) { return BoundedVal(aVal,aLimit); };
inline TInt Val(TInt64& aVal,const TInt64& aLimit) { return BoundedVal(aVal,aLimit); };
inline TInt Val(TUint32& aVal,TRadix aRadix,TUint aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
inline TInt Val(TInt64& aVal,TRadix aRadix,const TInt64& aLimit) { return BoundedVal(aVal,aRadix,aLimit); };
private:
void Scndig(TInt& aSig,TInt& aExp,TInt64& aDl);
void ValidateMark(const TLexMark16 aMark) const;
private:
const TUint16* iNext;
const TUint16* iBuf;
const TUint16* iEnd;
TLexMark16 iMark;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
#line 1355
typedef TLex16 TLex;
#line 1373
typedef TLexMark16 TLexMark;
#line 1430
class TCheckedUid
{
public:
__declspec(dllexport) TCheckedUid();
__declspec(dllexport) TCheckedUid(const TUidType& aUidType);
__declspec(dllexport) TCheckedUid(const TDesC8& aPtr);
__declspec(dllexport) void Set(const TUidType& aUidType);
__declspec(dllexport) void Set(const TDesC8& aPtr);
__declspec(dllexport) TPtrC8 Des() const;
inline const TUidType& UidType() const;
protected:
__declspec(dllexport) TUint Check() const;
private:
TUidType iType;
TUint iCheck;
};
#line 1469
class TDateTime
{
public:
inline TDateTime();
__declspec(dllexport) TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
__declspec(dllexport) TInt Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute, TInt aSecond,TInt aMicroSecond);
__declspec(dllexport) TInt SetYear(TInt aYear);
__declspec(dllexport) TInt SetYearLeapCheck(TInt aYear);
__declspec(dllexport) TInt SetMonth(TMonth aMonth);
__declspec(dllexport) TInt SetDay(TInt aDay);
__declspec(dllexport) TInt SetHour(TInt aHour);
__declspec(dllexport) TInt SetMinute(TInt aMinute);
__declspec(dllexport) TInt SetSecond(TInt aSecond);
__declspec(dllexport) TInt SetMicroSecond(TInt aMicroSecond);
inline TInt Year() const;
inline TMonth Month() const;
inline TInt Day() const;
inline TInt Hour() const;
inline TInt Minute() const;
inline TInt Second() const;
inline TInt MicroSecond() const;
private:
TInt iYear;
TMonth iMonth;
TInt iDay;
TInt iHour;
TInt iMinute;
TInt iSecond;
TInt iMicroSecond;
};
#line 1516
class TTimeIntervalMicroSeconds
{
public:
inline TTimeIntervalMicroSeconds();
inline TTimeIntervalMicroSeconds(const TInt64& aInterval);
inline TTimeIntervalMicroSeconds& operator=(const TInt64& aInterval);
inline TBool operator==(const TTimeIntervalMicroSeconds& aInterval) const;
inline TBool operator!=(const TTimeIntervalMicroSeconds& aInterval) const;
inline TBool operator>=(const TTimeIntervalMicroSeconds& aInterval) const;
inline TBool operator<=(const TTimeIntervalMicroSeconds& aInterval) const;
inline TBool operator>(const TTimeIntervalMicroSeconds& aInterval) const;
inline TBool operator<(const TTimeIntervalMicroSeconds& aInterval) const;
inline const TInt64& Int64() const;
private:
TInt64 iInterval;
};
#line 1554
class TTimeIntervalBase
{
public:
inline TBool operator==(TTimeIntervalBase aInterval) const;
inline TBool operator!=(TTimeIntervalBase aInterval) const;
inline TBool operator>=(TTimeIntervalBase aInterval) const;
inline TBool operator<=(TTimeIntervalBase aInterval) const;
inline TBool operator>(TTimeIntervalBase aInterval) const;
inline TBool operator<(TTimeIntervalBase aInterval) const;
inline TInt Int() const;
protected:
inline TTimeIntervalBase();
inline TTimeIntervalBase(TInt aInterval);
protected:
TInt iInterval;
};
#line 1583
class TTimeIntervalMicroSeconds32 : public TTimeIntervalBase
{
public:
inline TTimeIntervalMicroSeconds32();
inline TTimeIntervalMicroSeconds32(TInt aInterval);
inline TTimeIntervalMicroSeconds32& operator=(TInt aInterval);
};
#line 1606
class TTimeIntervalSeconds : public TTimeIntervalBase
{
public:
inline TTimeIntervalSeconds();
inline TTimeIntervalSeconds(TInt aInterval);
inline TTimeIntervalSeconds& operator=(TInt aInterval);
};
#line 1626
class TTimeIntervalMinutes : public TTimeIntervalBase
{
public:
inline TTimeIntervalMinutes();
inline TTimeIntervalMinutes(TInt aInterval);
inline TTimeIntervalMinutes& operator=(TInt aInterval);
};
#line 1646
class TTimeIntervalHours : public TTimeIntervalBase
{
public:
inline TTimeIntervalHours();
inline TTimeIntervalHours(TInt aInterval);
inline TTimeIntervalHours& operator=(TInt aInterval);
};
#line 1666
class TTimeIntervalDays : public TTimeIntervalBase
{
public:
inline TTimeIntervalDays();
inline TTimeIntervalDays(TInt aInterval);
inline TTimeIntervalDays& operator=(TInt aInterval);
};
#line 1686
class TTimeIntervalMonths : public TTimeIntervalBase
{
public:
inline TTimeIntervalMonths();
inline TTimeIntervalMonths(TInt aInterval);
inline TTimeIntervalMonths& operator=(TInt aInterval);
};
#line 1706
class TTimeIntervalYears : public TTimeIntervalBase
{
public:
inline TTimeIntervalYears();
inline TTimeIntervalYears(TInt aInterval);
inline TTimeIntervalYears& operator=(TInt aInterval);
};
#line 1725
enum {
EParseTimePresent=0x1,
EParseDatePresent=0x2
};
#line 1770
class TTime
{
public:
inline TTime();
inline TTime(const TInt64& aTime);
__declspec(dllexport) TTime(const TDesC& aString);
__declspec(dllexport) TTime(const TDateTime& aDateTime);
inline TTime& operator=(const TInt64& aTime);
__declspec(dllexport) TTime& operator=(const TDateTime& aDateTime);
__declspec(dllexport) void HomeTime();
__declspec(dllexport) void UniversalTime();
__declspec(dllexport) TInt Set(const TDesC& aString);
__declspec(dllexport) TDateTime DateTime() const;
__declspec(dllexport) TTimeIntervalMicroSeconds MicroSecondsFrom(TTime aTime) const;
__declspec(dllexport) TInt SecondsFrom(TTime aTime,TTimeIntervalSeconds& aInterval) const;
__declspec(dllexport) TInt MinutesFrom(TTime aTime,TTimeIntervalMinutes& aInterval) const;
__declspec(dllexport) TInt HoursFrom(TTime aTime,TTimeIntervalHours& aInterval) const;
__declspec(dllexport) TTimeIntervalDays DaysFrom(TTime aTime) const;
__declspec(dllexport) TTimeIntervalMonths MonthsFrom(TTime aTime) const;
__declspec(dllexport) TTimeIntervalYears YearsFrom(TTime aTime) const;
__declspec(dllexport) TInt DaysInMonth() const;
__declspec(dllexport) TDay DayNoInWeek() const;
__declspec(dllexport) TInt DayNoInMonth() const;
__declspec(dllexport) TInt DayNoInYear() const;
__declspec(dllexport) TInt DayNoInYear(TTime aStartDate) const;
__declspec(dllexport) TInt WeekNoInYear() const;
__declspec(dllexport) TInt WeekNoInYear(TTime aStartDate) const;
__declspec(dllexport) TInt WeekNoInYear(TFirstWeekRule aRule) const;
__declspec(dllexport) TInt WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const;
__declspec(dllexport) void FormatL(TDes& aDes,const TDesC& aFormat) const;
__declspec(dllexport) void RoundUpToNextMinute();
__declspec(dllexport) TInt Parse(const TDesC& aDes,TInt aCenturyOffset=0);
__declspec(dllexport) TTime operator+(TTimeIntervalYears aYear) const;
__declspec(dllexport) TTime operator+(TTimeIntervalMonths aMonth) const;
__declspec(dllexport) TTime operator+(TTimeIntervalDays aDay) const;
__declspec(dllexport) TTime operator+(TTimeIntervalHours aHour) const;
__declspec(dllexport) TTime operator+(TTimeIntervalMinutes aMinute) const;
__declspec(dllexport) TTime operator+(TTimeIntervalSeconds aSecond) const;
__declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds aMicroSecond) const;
__declspec(dllexport) TTime operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const;
__declspec(dllexport) TTime operator-(TTimeIntervalYears aYear) const;
__declspec(dllexport) TTime operator-(TTimeIntervalMonths aMonth) const;
__declspec(dllexport) TTime operator-(TTimeIntervalDays aDay) const;
__declspec(dllexport) TTime operator-(TTimeIntervalHours aHour) const;
__declspec(dllexport) TTime operator-(TTimeIntervalMinutes aMinute) const;
__declspec(dllexport) TTime operator-(TTimeIntervalSeconds aSecond) const;
__declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds aMicroSecond) const;
__declspec(dllexport) TTime operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const;
__declspec(dllexport) TTime& operator+=(TTimeIntervalYears aYear);
__declspec(dllexport) TTime& operator+=(TTimeIntervalMonths aMonth);
__declspec(dllexport) TTime& operator+=(TTimeIntervalDays aDay);
__declspec(dllexport) TTime& operator+=(TTimeIntervalHours aHour);
__declspec(dllexport) TTime& operator+=(TTimeIntervalMinutes aMinute);
__declspec(dllexport) TTime& operator+=(TTimeIntervalSeconds aSecond);
__declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds aMicroSecond);
__declspec(dllexport) TTime& operator+=(TTimeIntervalMicroSeconds32 aMicroSecond);
__declspec(dllexport) TTime& operator-=(TTimeIntervalYears aYear);
__declspec(dllexport) TTime& operator-=(TTimeIntervalMonths aMonth);
__declspec(dllexport) TTime& operator-=(TTimeIntervalDays aDay);
__declspec(dllexport) TTime& operator-=(TTimeIntervalHours aHour);
__declspec(dllexport) TTime& operator-=(TTimeIntervalMinutes aMinute);
__declspec(dllexport) TTime& operator-=(TTimeIntervalSeconds aSecond);
__declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds aMicroSecond);
__declspec(dllexport) TTime& operator-=(TTimeIntervalMicroSeconds32 aMicroSecond);
inline TBool operator==(TTime aTime) const;
inline TBool operator!=(TTime aTime) const;
inline TBool operator>=(TTime aTime) const;
inline TBool operator<=(TTime aTime) const;
inline TBool operator>(TTime aTime) const;
inline TBool operator<(TTime aTime) const;
inline const TInt64& Int64() const;
private:
static TTime Convert(const TDateTime& aDateTime);
private:
TInt64 iTime;
public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const ;
};
#line 1861
class Time
{
public:
__declspec(dllexport) static TTime NullTTime();
__declspec(dllexport) static TTime MaxTTime();
__declspec(dllexport) static TTime MinTTime();
__declspec(dllexport) static TInt DaysInMonth(TInt aYear, TMonth aMonth);
__declspec(dllexport) static TBool IsLeapYear(TInt aYear);
__declspec(dllexport) static TInt LeapYearsUpTo(TInt aYear);
};
#line 1887
class TDayName : public TBuf<KMaxDayName>
{
public:
__declspec(dllexport) TDayName();
__declspec(dllexport) TDayName(TDay aDay);
__declspec(dllexport) void Set(TDay aDay);
};
#line 1915
class TDayNameAbb : public TBuf<KMaxDayNameAbb>
{
public:
__declspec(dllexport) TDayNameAbb();
__declspec(dllexport) TDayNameAbb(TDay aDay);
__declspec(dllexport) void Set(TDay aDay);
};
#line 1938
class TMonthName : public TBuf<KMaxMonthName>
{
public:
__declspec(dllexport) TMonthName();
__declspec(dllexport) TMonthName(TMonth aMonth);
__declspec(dllexport) void Set(TMonth aMonth);
};
#line 1961
class TMonthNameAbb : public TBuf<KMaxMonthNameAbb>
{
public:
__declspec(dllexport) TMonthNameAbb();
__declspec(dllexport) TMonthNameAbb(TMonth aMonth);
__declspec(dllexport) void Set(TMonth aMonth);
};
#line 1986
class TDateSuffix : public TBuf<KMaxSuffix>
{
public:
__declspec(dllexport) TDateSuffix();
__declspec(dllexport) TDateSuffix(TInt aDateSuffix);
__declspec(dllexport) void Set(TInt aDateSuffix);
};
#line 2010
class TAmPmName : public TBuf<KMaxAmPmName>
{
public:
__declspec(dllexport) TAmPmName();
__declspec(dllexport) TAmPmName(TAmPm aSelector);
__declspec(dllexport) void Set(TAmPm aSelector);
};
#line 2031
class TCurrencySymbol : public TBuf<KMaxCurrencySymbol>
{
public:
__declspec(dllexport) TCurrencySymbol();
__declspec(dllexport) void Set();
};
#line 2067
class TShortDateFormatSpec : public TBuf<KMaxShortDateFormatSpec>
{
public:
__declspec(dllexport) TShortDateFormatSpec();
__declspec(dllexport) void Set();
};
#line 2103
class TLongDateFormatSpec : public TBuf<KMaxLongDateFormatSpec>
{
public:
__declspec(dllexport) TLongDateFormatSpec();
__declspec(dllexport) void Set();
};
#line 2136
class TTimeFormatSpec : public TBuf<KMaxTimeFormatSpec>
{
public:
__declspec(dllexport) TTimeFormatSpec();
__declspec(dllexport) void Set();
};
#line 2156
class TLocale
{
public:
enum TNegativeCurrencyFormat
{
ELeadingMinusSign,
EInBrackets,
ETrailingMinusSign,
EInterveningMinusSign
};
enum
{
EFlagNegativeLoseSpace = 0x00000001,
EFlagNegativeCurrencySymbolOpposite=0x00000002
};
enum TDeviceTimeState
{
EDeviceUserTime,
ENITZNetworkTimeSync
};
public:
__declspec(dllexport) TLocale();
inline TLocale(TInt);
__declspec(dllexport) void Refresh();
__declspec(dllexport) TInt Set() const;
__declspec(dllexport) void FormatCurrency(TDes& aText, TInt aAmount);
__declspec(dllexport) void FormatCurrency(TDes& aText, TInt64 aAmount);
__declspec(dllexport) void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount);
__declspec(dllexport) void FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount);
inline TInt CountryCode() const;
inline void SetCountryCode(TInt aCode);
inline TTimeIntervalSeconds UniversalTimeOffset() const;
inline TDateFormat DateFormat() const;
inline void SetDateFormat(TDateFormat aFormat);
inline TTimeFormat TimeFormat() const;
inline void SetTimeFormat(TTimeFormat aFormat);
inline TLocalePos CurrencySymbolPosition() const;
inline void SetCurrencySymbolPosition(TLocalePos aPos);
inline TBool CurrencySpaceBetween() const;
inline void SetCurrencySpaceBetween(TBool aSpace);
inline TInt CurrencyDecimalPlaces() const;
inline void SetCurrencyDecimalPlaces(TInt aPlaces);
inline TBool CurrencyNegativeInBrackets() const;
inline void SetCurrencyNegativeInBrackets(TBool aBool);
inline TBool CurrencyTriadsAllowed() const;
inline void SetCurrencyTriadsAllowed(TBool aBool);
inline TChar ThousandsSeparator() const;
inline void SetThousandsSeparator(const TChar& aChar);
inline TChar DecimalSeparator() const;
inline void SetDecimalSeparator(const TChar& aChar);
inline TChar DateSeparator(TInt aIndex) const;
inline void SetDateSeparator(const TChar& aChar,TInt aIndex);
inline TChar TimeSeparator(TInt aIndex) const;
inline void SetTimeSeparator(const TChar& aChar,TInt aIndex);
inline TBool AmPmSpaceBetween() const;
inline void SetAmPmSpaceBetween(TBool aSpace);
inline TLocalePos AmPmSymbolPosition() const;
inline void SetAmPmSymbolPosition(TLocalePos aPos);
inline TUint DaylightSaving() const;
inline TBool QueryHomeHasDaylightSavingOn() const;
inline TDaylightSavingZone HomeDaylightSavingZone() const;
inline TUint WorkDays() const;
inline void SetWorkDays(TUint aMask);
inline TDay StartOfWeek() const;
inline void SetStartOfWeek(TDay aDay);
inline TClockFormat ClockFormat() const;
inline void SetClockFormat(TClockFormat aFormat);
inline TUnitsFormat UnitsGeneral() const;
inline void SetUnitsGeneral(TUnitsFormat aFormat);
inline TUnitsFormat UnitsDistanceShort() const;
inline void SetUnitsDistanceShort(TUnitsFormat aFormat);
inline TUnitsFormat UnitsDistanceLong() const;
inline void SetUnitsDistanceLong(TUnitsFormat aFormat);
inline TNegativeCurrencyFormat NegativeCurrencyFormat() const;
inline void SetNegativeCurrencyFormat(TNegativeCurrencyFormat aNegativeCurrencyFormat);
inline TBool NegativeLoseSpace() const;
inline void SetNegativeLoseSpace(TBool aBool);
inline TBool NegativeCurrencySymbolOpposite() const;
inline void SetNegativeCurrencySymbolOpposite(TBool aBool);
inline TLanguage LanguageDowngrade(TInt aIndex) const;
inline void SetLanguageDowngrade(TInt aIndex, TLanguage aLanguage);
inline TDigitType DigitType() const;
inline void SetDigitType(TDigitType aDigitType);
inline TDeviceTimeState DeviceTime() const;
inline void SetDeviceTime(TDeviceTimeState aState);
void SetDefaults();
private:
friend class TExtendedLocale;
private:
TInt iCountryCode;
TTimeIntervalSeconds iUniversalTimeOffset;
TDateFormat iDateFormat;
TTimeFormat iTimeFormat;
TLocalePos iCurrencySymbolPosition;
TBool iCurrencySpaceBetween;
TInt iCurrencyDecimalPlaces;
TNegativeCurrencyFormat iNegativeCurrencyFormat;
TBool iCurrencyTriadsAllowed;
TChar iThousandsSeparator;
TChar iDecimalSeparator;
TChar iDateSeparator[KMaxDateSeparators];
TChar iTimeSeparator[KMaxTimeSeparators];
TLocalePos iAmPmSymbolPosition;
TBool iAmPmSpaceBetween;
TUint iDaylightSaving;
TDaylightSavingZone iHomeDaylightSavingZone;
TUint iWorkDays;
TDay iStartOfWeek;
TClockFormat iClockFormat;
TUnitsFormat iUnitsGeneral;
TUnitsFormat iUnitsDistanceShort;
TUnitsFormat iUnitsDistanceLong;
TUint iExtraNegativeCurrencyFormatFlags;
TUint16 iLanguageDowngrade[3];
TUint16 iSpare16;
TDigitType iDigitType;
TDeviceTimeState iDeviceTimeState;
TInt iSpare[0x1E];
};
const TUint KLocaleLanguageKey = 0x10208903;
const TUint KLocaleDataKey = 0x10208904;
const TUint KLocaleDataExtraKey = 0x10208905;
const TUint KLocaleTimeDateFormatKey = 0x10208907;
const TUint KLocaleDefaultCharSetKey = 0x10208908;
const TUint KLocalePreferredCharSetKey = 0x10208909;
enum TLocaleFunctions
{
FnDummy,
FnAmPmTable,
FnCharSet,
FnCollTable,
FnCurrencySymbol,
FnDateSuffixTable,
FnDayAbbTable,
FnDayTable,
FnFoldTable,
FnLanguage,
FnLocaleData,
FnLowerTable,
FnMonthAbbTable,
FnMonthTable,
FnMsgTable,
FnTypeTable,
FnUniCode,
FnUpperTable,
FnShortDateFormatSpec,
FnLongDateFormatSpec,
FnTimeFormatSpec,
FnFatUtilityFunctions
};
#line 2407
enum TLocaleAspect
{
ELocaleLanguageSettings = 0x01,
ELocaleCollateSetting = 0x02,
ELocaleLocaleSettings = 0x04,
ELocaleTimeDateSettings = 0x08,
};
struct SLocaleLanguage
{
TLanguage iLanguage;
const TText* iDateSuffixTable;
const TText* iDayTable;
const TText* iDayAbbTable;
const TText* iMonthTable;
const TText* iMonthAbbTable;
const TText* iAmPmTable;
const TText16* const* iMsgTable;
};
struct SLocaleLocaleSettings
{
TText iCurrencySymbol[KMaxCurrencySymbol+1];
TAny* iLocaleExtraSettingsDllPtr;
};
struct SLocaleTimeDateFormat
{
TText iShortDateFormatSpec[KMaxShortDateFormatSpec+1];
TText iLongDateFormatSpec[KMaxLongDateFormatSpec+1];
TText iTimeFormatSpec[KMaxTimeFormatSpec+1];
TAny* iLocaleTimeDateFormatDllPtr;
};
struct LCharSet;
#line 2462
class TExtendedLocale
{
public:
__declspec(dllexport) TExtendedLocale();
__declspec(dllexport) void LoadSystemSettings();
__declspec(dllexport) TInt SaveSystemSettings();
__declspec(dllexport) TInt LoadLocale(const TDesC& aLocaleDllName);
#line 2488
__declspec(dllexport) TInt LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName);
__declspec(dllexport) TInt SetCurrencySymbol(const TDesC &aSymbol);
__declspec(dllexport) TInt GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName);
__declspec(dllexport) TCollationMethod GetPreferredCollationMethod(TInt index = 0) ;
inline TLocale* GetLocale();
private:
TInt DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
void DoUpdateLanguageSettings(TLibraryFunction* aExportList);
void DoUpdateLocaleSettings(TLibraryFunction* aExportList);
void DoUpdateTimeDateFormat(TLibraryFunction* aExportList);
private:
TLocale iLocale;
SLocaleLanguage iLanguageSettings;
SLocaleLocaleSettings iLocaleExtraSettings;
SLocaleTimeDateFormat iLocaleTimeDateFormat;
const LCharSet* iDefaultCharSet;
const LCharSet* iPreferredCharSet;
};
#line 2544
class TRect
{
public:
enum TUninitialized { EUninitialized };
TRect(TUninitialized) {}
__declspec(dllexport) TRect();
__declspec(dllexport) TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
__declspec(dllexport) TRect(const TPoint& aPointA,const TPoint& aPointB);
__declspec(dllexport) TRect(const TPoint& aPoint,const TSize& aSize);
__declspec(dllexport) TRect(const TSize& aSize);
__declspec(dllexport) TBool operator==(const TRect& aRect) const;
__declspec(dllexport) TBool operator!=(const TRect& aRect) const;
__declspec(dllexport) void SetRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy);
__declspec(dllexport) void SetRect(const TPoint& aPointTL,const TPoint& aPointBR);
__declspec(dllexport) void SetRect(const TPoint& aPoint,const TSize& aSize);
__declspec(dllexport) void Move(TInt aDx,TInt aDy);
__declspec(dllexport) void Move(const TPoint& aOffset);
__declspec(dllexport) void Resize(TInt aDx,TInt aDy);
__declspec(dllexport) void Resize(const TSize& aSize);
__declspec(dllexport) void Shrink(TInt aDx,TInt aDy);
__declspec(dllexport) void Shrink(const TSize& aSize);
__declspec(dllexport) void Grow(TInt aDx,TInt aDy);
__declspec(dllexport) void Grow(const TSize& aSize);
__declspec(dllexport) void BoundingRect(const TRect& aRect);
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) TBool Intersects(const TRect& aRect) const;
__declspec(dllexport) void Intersection(const TRect& aRect);
__declspec(dllexport) void Normalize();
__declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
__declspec(dllexport) TSize Size() const;
__declspec(dllexport) TInt Width() const;
__declspec(dllexport) TInt Height() const;
__declspec(dllexport) TBool IsNormalized() const;
__declspec(dllexport) TPoint Center() const;
__declspec(dllexport) void SetSize(const TSize& aSize);
__declspec(dllexport) void SetWidth(TInt aWidth);
__declspec(dllexport) void SetHeight(TInt aHeight);
private:
void Adjust(TInt aDx,TInt aDy);
public:
TPoint iTl;
TPoint iBr;
};
#line 2646
class TRegion
{
public:
inline TInt Count() const;
inline const TRect* RectangleList() const;
inline TBool CheckError() const;
__declspec(dllexport) TBool IsEmpty() const;
__declspec(dllexport) TRect BoundingRect() const;
__declspec(dllexport) const TRect& operator[](TInt aIndex) const;
__declspec(dllexport) void Copy(const TRegion& aRegion);
__declspec(dllexport) void AddRect(const TRect& aRect);
__declspec(dllexport) void SubRect(const TRect& aRect,TRegion* aSubtractedRegion=0 );
__declspec(dllexport) void Offset(TInt aXoffset,TInt aYoffset);
__declspec(dllexport) void Offset(const TPoint& aOffset);
__declspec(dllexport) void Union(const TRegion& aRegion);
__declspec(dllexport) void Intersection(const TRegion& aRegion,const TRegion& aRegion2);
__declspec(dllexport) void Intersect(const TRegion& aRegion);
__declspec(dllexport) void SubRegion(const TRegion& aRegion,TRegion* aSubtractedRegion=0 );
__declspec(dllexport) void ClipRect(const TRect& aRect);
__declspec(dllexport) void Clear();
__declspec(dllexport) void Tidy();
__declspec(dllexport) TInt Sort();
__declspec(dllexport) TInt Sort(const TPoint& aOffset);
__declspec(dllexport) void ForceError();
__declspec(dllexport) TBool IsContainedBy(const TRect& aRect) const;
__declspec(dllexport) TBool Contains(const TPoint& aPoint) const;
protected:
__declspec(dllexport) TRect* RectangleListW();
__declspec(dllexport) TRegion(TInt aAllocedRects);
inline TRegion();
TBool SetListSize(TInt aCount);
void AppendRect(const TRect& aRect);
void DeleteRect(TRect* aRect);
void AppendRegion(TRegion& aRegion);
protected:
TInt iCount;
TBool iError;
TInt iAllocedRects;
protected:
enum {ERRegionBuf=0x40000000};
};
#line 2703
class RRegion : public TRegion
{
private:
enum {EDefaultGranularity=5};
protected:
__declspec(dllexport) RRegion(TInt aBuf,TInt aGran);
public:
__declspec(dllexport) RRegion();
__declspec(dllexport) RRegion(TInt aGran);
__declspec(dllexport) RRegion(const RRegion& aRegion);
__declspec(dllexport) RRegion(const TRect& aRect,TInt aGran=EDefaultGranularity);
__declspec(dllexport) RRegion(TInt aCount,TRect* aRectangleList,TInt aGran=EDefaultGranularity);
__declspec(dllexport) void Close();
__declspec(dllexport) void Destroy();
inline TInt CheckSpare() const;
private:
TInt iGranularity;
TRect* iRectangleList;
friend class TRegion;
};
#line 2744
template <TInt S>
class RRegionBuf : public RRegion
{
public:
inline RRegionBuf();
inline RRegionBuf(const RRegion& aRegion);
inline RRegionBuf(const RRegionBuf<S>& aRegion);
inline RRegionBuf(const TRect& aRect);
private:
TInt8 iRectangleBuf[S*sizeof(TRect)];
};
#line 2774
template <TInt S>
class TRegionFix : public TRegion
{
public:
inline TRegionFix();
inline TRegionFix(const TRect& aRect);
inline TRegionFix(const TRegionFix<S>& aRegion);
private:
TInt8 iRectangleBuf[S*sizeof(TRect)];
};
#line 2806
class TFindHandleBase
{
public:
__declspec(dllexport) TFindHandleBase();
__declspec(dllexport) TFindHandleBase(const TDesC& aMatch);
__declspec(dllexport) void Find(const TDesC& aMatch);
inline TInt Handle() const;
protected:
TInt NextObject(TFullName& aResult,TInt aObjectType);
private:
TInt iFindHandle;
TInt iSpare1;
TInt iSpare2;
TInt iSpare3;
TFullName iMatch;
};
#line 2859
class TFindSemaphore : public TFindHandleBase
{
public:
inline TFindSemaphore();
inline TFindSemaphore(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2895
class TFindMutex : public TFindHandleBase
{
public:
inline TFindMutex();
inline TFindMutex(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2922
class TFindChunk : public TFindHandleBase
{
public:
inline TFindChunk();
inline TFindChunk(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2952
class TFindThread : public TFindHandleBase
{
public:
inline TFindThread();
inline TFindThread(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 2981
class TFindProcess : public TFindHandleBase
{
public:
inline TFindProcess();
inline TFindProcess(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3010
class TFindLogicalDevice : public TFindHandleBase
{
public:
inline TFindLogicalDevice();
inline TFindLogicalDevice(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3037
class TFindPhysicalDevice : public TFindHandleBase
{
public:
inline TFindPhysicalDevice();
inline TFindPhysicalDevice(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3065
class TFindServer : public TFindHandleBase
{
public:
inline TFindServer();
inline TFindServer(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3089
class TFindLibrary : public TFindHandleBase
{
public:
inline TFindLibrary();
inline TFindLibrary(const TDesC& aMatch);
__declspec(dllexport) TInt Next(TFullName& aResult);
};
#line 3114
class RDevice : public RHandleBase
{
public:
inline TInt Open(const TFindLogicalDevice& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void GetCaps(TDes8& aDes) const;
__declspec(dllexport) TBool QueryVersionSupported(const TVersion& aVer) const;
__declspec(dllexport) TBool IsAvailable(TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo) const;
};
#line 3154
class RTimer : public RHandleBase
{
public:
__declspec(dllexport) TInt CreateLocal();
__declspec(dllexport) void Cancel();
__declspec(dllexport) void After(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
__declspec(dllexport) void AfterTicks(TRequestStatus &aStatus, TInt aTicks);
__declspec(dllexport) void At(TRequestStatus& aStatus,const TTime& aTime);
__declspec(dllexport) void AtUTC(TRequestStatus& aStatus,const TTime& aUTCTime);
__declspec(dllexport) void Lock(TRequestStatus& aStatus,TTimerLockSpec aLock);
__declspec(dllexport) void Inactivity(TRequestStatus& aStatus, TTimeIntervalSeconds aSeconds);
__declspec(dllexport) void HighRes(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 anInterval);
};
#line 3179
class RLibrary : public RHandleBase
{
public:
__declspec(dllexport) void Close();
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TUidType& aType);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath=KNullDesC);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType);
__declspec(dllexport) TInt Load(const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
__declspec(dllexport) TInt LoadRomLibrary(const TDesC& aFileName, const TDesC& aPath);
__declspec(dllexport) TLibraryFunction Lookup(TInt anOrdinal) const;
__declspec(dllexport) TUidType Type() const;
__declspec(dllexport) TFileName FileName() const;
__declspec(dllexport) TInt GetRamSizes(TInt& aCodeSize, TInt& aConstDataSize);
__declspec(dllexport) TInt Init();
public:
struct TInfo
{
TUint32 iModuleVersion;
TUidType iUids;
TSecurityInfo iSecurityInfo;
};
struct TInfoV2 : public TInfo
{
TUint8 iHardwareFloatingPoint;
TUint8 iSpare[7];
};
typedef TPckgBuf<TInfo> TInfoBuf;
typedef TPckgBuf<TInfoV2> TInfoBufV2;
enum TRequiredImageHeaderSize
{
KRequiredImageHeaderSize = KMaxTInt
};
__declspec(dllexport) static TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
struct SInfo
{
TUint32 iModuleVersion;
TUidType iUids;
SSecurityInfo iS;
};
typedef TPckgBuf<SInfo> SInfoBuf;
__declspec(dllexport) static TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
private:
TInt InitL();
};
#line 3292
class RCriticalSection : private RSemaphore
{
public:
__declspec(dllexport) RCriticalSection();
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Close();
__declspec(dllexport) void Wait();
__declspec(dllexport) void Signal();
inline TBool IsBlocked() const;
private:
TInt iBlocked;
};
#line 3320
class RMutex : public RHandleBase
{
public:
inline TInt Open(const TFindMutex& aFind,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) void Wait();
__declspec(dllexport) void Signal();
__declspec(dllexport) TBool IsHeld();
};
#line 3349
class RCondVar : public RHandleBase
{
public:
__declspec(dllexport) TInt CreateLocal(TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt CreateGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt OpenGlobal(const TDesC& aName, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess);
__declspec(dllexport) TInt Wait(RMutex& aMutex);
__declspec(dllexport) TInt TimedWait(RMutex& aMutex, TInt aTimeout);
__declspec(dllexport) void Signal();
__declspec(dllexport) void Broadcast();
};
class UserHeap;