Symbian

开发平台：

C/C++

S60UIExampleHighScoreContainer.inc：源码内容

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 4 */
#line 10 "C:\Symbian\9.1\S60_3rd\epoc32\include\babitflags.h" /* stack depth 3 */
template <class T>
class TBitFlagsT
{
public:
inline TBitFlagsT();
inline TBitFlagsT(T aFlags);
inline TBitFlagsT(const TBitFlagsT& aFlags);
public:
inline void SetAll();
inline void ClearAll();
inline void Set(TInt aFlagIndex);
inline void Clear(TInt aFlagIndex);
inline void Assign(TInt aFlagIndex, TBool aValue);
inline void Toggle(TInt aFlagIndex);
public:
inline TBool operator[](TInt aFlagIndex) const;
inline TBitFlagsT& operator=(const TBitFlagsT& aFlags);
inline TBool operator==(const TBitFlagsT& aFlags);
public:
inline TBool IsSet(TInt aFlagIndex) const;
inline TBool IsClear(TInt aFlagIndex) const;
inline T Value() const { return iFlags; }
inline void SetValue(T aFlags) { iFlags = aFlags; }
private:
inline T FlagMask(TInt aFlagIndex) const;
public:
T iFlags;
};
typedef TBitFlagsT<TUint8> TBitFlags8;
typedef TBitFlagsT<TUint16> TBitFlags16;
typedef TBitFlagsT<TUint32> TBitFlags32;
typedef TBitFlags32 TBitFlags;
template <class T>
inline TBitFlagsT<T>::TBitFlagsT() : iFlags(0)
{}
template <class T>
inline TBitFlagsT<T>::TBitFlagsT(T aFlags) : iFlags(aFlags)
{}
template <class T>
inline TBitFlagsT<T>::TBitFlagsT(const TBitFlagsT<T>& aFlags) : iFlags(aFlags.iFlags)
{}
template <class T>
inline T TBitFlagsT<T>::FlagMask(TInt aFlagIndex) const
{ return T(T(1)<<aFlagIndex); }
template <class T>
inline TBool TBitFlagsT<T>::IsSet(TInt aFlagIndex) const
{ return iFlags & FlagMask(aFlagIndex); }
template <class T>
inline TBool TBitFlagsT<T>::IsClear(TInt aFlagIndex) const
{ return !IsSet(aFlagIndex); }
template <class T>
inline void TBitFlagsT<T>::Set(TInt aFlagIndex)
{ iFlags |= FlagMask(aFlagIndex); }
template <class T>
inline void TBitFlagsT<T>::Clear(TInt aFlagIndex)
{ iFlags &= ~(FlagMask(aFlagIndex)); }
template <class T>
inline void TBitFlagsT<T>::Assign(TInt aFlagIndex, TBool aVal)
{ if (aVal) Set(aFlagIndex); else Clear(aFlagIndex); }
template <class T>
inline void TBitFlagsT<T>::Toggle(TInt aFlagIndex)
{ iFlags ^= FlagMask(aFlagIndex); }
template <class T>
inline TBool TBitFlagsT<T>::operator[](TInt aFlagIndex) const
{ return IsSet(aFlagIndex); }
template <class T>
inline TBitFlagsT<T>& TBitFlagsT<T>::operator=(const TBitFlagsT<T>& aFlags)
{ iFlags = aFlags.iFlags; return *this; }
template <class T>
inline TBool TBitFlagsT<T>::operator==(const TBitFlagsT<T>& aFlags)
{ return iFlags == aFlags.Value(); }
template <class T>
inline void TBitFlagsT<T>::SetAll()
{ iFlags = ~(T(0)); }
template <class T>
inline void TBitFlagsT<T>::ClearAll()
{ iFlags = T(0); }
#line 29 "C:\Symbian\9.1\S60_3rd\epoc32\include\aknview.h" /* stack depth 2 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\coecntrl.h" /* stack depth 3 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 4 */
#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 5 */
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));}
template <class T>
inline TInt CArrayVar<T>::FindIsq(const T &aRef,TKeyArrayVar &aKey,TInt &anIndex) const
#line 1565
{return(CArrayVarBase::FindIsq(&aRef,aKey,anIndex));}
template <class T>
inline void CArrayVar<T>::InsertL(TInt anIndex,const T &aRef,TInt aLength)
#line 1595
{CArrayVarBase::InsertL(anIndex,&aRef,aLength);}
template <class T>
inline TInt CArrayVar<T>::InsertIsqL(const T &aRef,TInt aLength,TKeyArrayVar &aKey)
#line 1628
{return(CArrayVarBase::InsertIsqL(&aRef,aLength,aKey));}
template <class T>
inline TInt CArrayVar<T>::InsertIsqAllowDuplicatesL(const T &aRef,TInt aLength,TKeyArrayVar &aKey)
#line 1658
{return(CArrayVarBase::InsertIsqAllowDuplicatesL(&aRef,aLength,aKey));}
template <class T>
inline const TArray<T> CArrayVar<T>::Array() const
{return(TArray<T>(CountR,AtR,this));}
inline const TAny *CArrayVar<TAny>::At(TInt anIndex) const
#line 1692
{return(CArrayVarBase::At(anIndex));}
inline CArrayVar<TAny>::CArrayVar(TBufRep aRep,TInt aGranularity)
: CArrayVarBase(aRep,aGranularity)
#line 1714
{}
inline TAny *CArrayVar<TAny>::At(TInt anIndex)
#line 1736
{return(CArrayVarBase::At(anIndex));}
inline void CArrayVar<TAny>::AppendL(const TAny *aPtr,TInt aLength)
{CArrayVarBase::InsertL(Count(),aPtr,aLength);}
inline TAny *CArrayVar<TAny>::ExtendL(TInt aLength)
#line 1773
{return(CArrayVarBase::ExpandL(Count(),aLength));}
template <class T>
inline CArrayVarFlat<T>::CArrayVarFlat(TInt aGranularity)
: CArrayVar<T>((TBufRep)CBufFlat::NewL,aGranularity)
#line 1791
{}
template <class T>
inline CArrayVarSeg<T>::CArrayVarSeg(TInt aGranularity)
: CArrayVar<T>((TBufRep)CBufSeg::NewL,aGranularity)
#line 1809
{}
inline TInt CArrayPakBase::Count() const
{return(iCount);}
template <class T>
inline CArrayPak<T>::CArrayPak(TBufRep aRep,TInt aGranularity)
: CArrayPakBase(aRep,aGranularity)
{}
template <class T>
inline const T &CArrayPak<T>::operator[](TInt anIndex) const
#line 1857
{return(*((const T *)CArrayPakBase::At(anIndex)));}
template <class T>
inline T &CArrayPak<T>::operator[](TInt anIndex)
#line 1881
{return(*((T *)CArrayPakBase::At(anIndex)));}
template <class T>
inline const T &CArrayPak<T>::At(TInt anIndex) const
#line 1905
{return(*((const T *)CArrayPakBase::At(anIndex)));}
template <class T>
inline T &CArrayPak<T>::At(TInt anIndex)
#line 1929
{return(*((T *)CArrayPakBase::At(anIndex)));}
template <class T>
inline void CArrayPak<T>::AppendL(const T &aRef,TInt aLength)
#line 1948
{CArrayPakBase::InsertL(Count(),&aRef,aLength);}
template <class T>
inline T &CArrayPak<T>::ExpandL(TInt anIndex,TInt aLength)
#line 1988
{return(*new(CArrayPakBase::ExpandL(anIndex,aLength)) T);}
template <class T>
inline T &CArrayPak<T>::ExtendL(TInt aLength)
#line 2021
{return(*new(CArrayPakBase::ExpandL(Count(),aLength)) T);}
template <class T>
inline TInt CArrayPak<T>::Find(const T &aRef,TKeyArrayPak &aKey,TInt &anIndex) const
#line 2051
{return(CArrayPakBase::Find(&aRef,aKey,anIndex));}
template <class T>
inline TInt CArrayPak<T>::FindIsq(const T &aRef,TKeyArrayPak &aKey,TInt &anIndex) const
#line 2088
{return(CArrayPakBase::FindIsq(&aRef,aKey,anIndex));}
template <class T>
inline void CArrayPak<T>::InsertL(TInt anIndex,const T &aRef,TInt aLength)
#line 2114
{CArrayPakBase::InsertL(anIndex,&aRef,aLength);}
template <class T>
inline TInt CArrayPak<T>::InsertIsqL(const T &aRef,TInt aLength,TKeyArrayPak &aKey)
#line 2146
{return(CArrayPakBase::InsertIsqL(&aRef,aLength,aKey));}
template <class T>
inline TInt CArrayPak<T>::InsertIsqAllowDuplicatesL(const T &aRef,TInt aLength,TKeyArrayPak &aKey)
#line 2175
{return(CArrayPakBase::InsertIsqAllowDuplicatesL(&aRef,aLength,aKey));}
template <class T>
inline const TArray<T> CArrayPak<T>::Array() const
{return(TArray<T>(CountR,AtR,this));}
inline CArrayPak<TAny>::CArrayPak(TBufRep aRep,TInt aGranularity)
: CArrayPakBase(aRep,aGranularity)
#line 2209
{}
inline const TAny *CArrayPak<TAny>::At(TInt anIndex) const
#line 2231
{return(CArrayPakBase::At(anIndex));}
inline TAny *CArrayPak<TAny>::At(TInt anIndex)
#line 2253
{return(CArrayPakBase::At(anIndex));}
inline void CArrayPak<TAny>::AppendL(const TAny *aPtr,TInt aLength)
#line 2269
{CArrayPakBase::InsertL(Count(),aPtr,aLength);}
inline TAny *CArrayPak<TAny>::ExtendL(TInt aLength)
#line 2290
{return(CArrayPakBase::ExpandL(Count(),aLength));}
template <class T>
inline CArrayPakFlat<T>::CArrayPakFlat(TInt aGranularity)
: CArrayPak<T>((TBufRep)CBufFlat::NewL,aGranularity)
#line 2308
{}
inline TInt CObject::UniqueID() const
#line 2326
{return(iContainer->UniqueID());}
inline TInt CObject::AccessCount() const
{return(iAccessCount);}
inline void CObject::Inc()
#line 2351
{iAccessCount++;}
inline void CObject::Dec()
#line 2365
{iAccessCount--;}
inline CObject * CObject::Owner() const
{return(iOwner);}
inline void CObject::SetOwner(CObject *anOwner)
#line 2393
{iOwner=anOwner;}
inline TInt CObjectIx::Count() const
#line 2409
{return iHighWaterMark;}
inline TInt CObjectIx::ActiveCount() const
{return iNumEntries;}
inline TInt CObjectCon::UniqueID() const
{return iUniqueID;}
inline TInt CObjectCon::Count() const
{return iCount;}
inline TInt CCirBufBase::Count() const
{return(iCount);}
inline TInt CCirBufBase::Length() const
#line 2474
{return(iLength);}
template <class T>
inline CCirBuf<T>::CCirBuf()
: CCirBufBase(sizeof(T))
#line 2491
{}
template <class T>
inline TInt CCirBuf<T>::Add(const T *aPtr)
#line 2514
{return(DoAdd((const TUint8 *)aPtr));}
template <class T>
inline TInt CCirBuf<T>::Add(const T *aPtr,TInt aCount)
#line 2541
{return(DoAdd((const TUint8 *)aPtr,aCount));}
template <class T>
inline TInt CCirBuf<T>::Remove(T *aPtr)
#line 2560
{return(DoRemove((TUint8 *)aPtr));}
template <class T>
inline TInt CCirBuf<T>::Remove(T *aPtr,TInt aCount)
#line 2585
{return(DoRemove((TUint8 *)aPtr,aCount));}
inline TBool CActive::IsActive() const
#line 2605
{return(iStatus.iFlags&TRequestStatus::EActive);}
inline TBool CActive::IsAdded() const
#line 2628
{return(iLink.iNext!=0 );}
inline TInt CActive::Priority() const
{return iLink.iPriority;}
inline TDeltaTimerEntry::TDeltaTimerEntry(TCallBack& aCallback)
{iCallBack=aCallback;}
inline TDeltaTimerEntry::TDeltaTimerEntry()
{}
inline void TDeltaTimerEntry::Set(TCallBack& aCallback)
{iCallBack=aCallback;}
#line 2681
inline const RMessage2 &CServer2::Message() const
{return iMessage;}
#line 2695
inline const CServer2 *CSession2::Server() const
{return iServer;}
inline RThread& CAsyncOneShot::Thread()
{ return iThread; }
inline TInt CActiveScheduler::Level() const
#line 2724
{return StackDepth();}
inline TBool CActiveSchedulerWait::IsStarted() const
#line 2743
{return iLoop != 0 ;}
inline void CleanupStack::Pop(TAny* aExpectedItem)
#line 2768
{ CleanupStack::Check(aExpectedItem); CleanupStack::Pop(); }
inline void CleanupStack::Pop(TInt aCount, TAny* aLastExpectedItem)
#line 2795
{
if (--aCount)
CleanupStack::Pop(aCount);
CleanupStack::Check(aLastExpectedItem);
CleanupStack::Pop();
}
inline void CleanupStack::PopAndDestroy(TAny* aExpectedItem)
#line 2823
{ CleanupStack::Check(aExpectedItem); CleanupStack::PopAndDestroy(); }
inline void CleanupStack::PopAndDestroy(TInt aCount, TAny* aLastExpectedItem)
#line 2851
{
if (--aCount)
CleanupStack::PopAndDestroy(aCount);
CleanupStack::Check(aLastExpectedItem);
CleanupStack::PopAndDestroy();
}
#line 2961
inline TCleanupItem::TCleanupItem(TCleanupOperation anOperation)
: iOperation(anOperation)
{}
inline TCleanupItem::TCleanupItem(TCleanupOperation anOperation,TAny *aPtr)
: iOperation(anOperation), iPtr(aPtr)
#line 2988
{}
inline CCleanup &TCleanupTrapHandler::Cleanup()
{return(*iCleanup);}
template <class T>
inline TAutoClose<T>::~TAutoClose()
{if (!std::uncaught_exception()) iObj.Close();}
template <class T>
inline void TAutoClose<T>::PushL()
{CleanupStack::PushL(TCleanupItem(Close, (TAny *)&iObj));}
template <class T>
inline void TAutoClose<T>::Pop()
{CleanupStack::Pop();}
template <class T>
void TAutoClose<T>::Close(TAny *aObj)
{((T *)aObj)->Close();}
template <class T>
inline void CleanupDelete<T>::PushL(T* aPtr)
#line 3053
{CleanupStack::PushL(TCleanupItem(&Delete,aPtr));}
template <class T>
void CleanupDelete<T>::Delete(TAny *aPtr)
{delete (static_cast<T*>(aPtr)) ;}
template <class T>
inline void CleanupDeletePushL(T* aPtr)
{CleanupDelete<T>::PushL(aPtr);}
template <class T>
inline void CleanupArrayDelete<T>::PushL(T* aPtr)
#line 3091
{CleanupStack::PushL(TCleanupItem(&ArrayDelete,aPtr));}
template <class T>
void CleanupArrayDelete<T>::ArrayDelete(TAny *aPtr)
{delete [] (static_cast<T*>(aPtr)) ;}
template <class T>
inline void CleanupArrayDeletePushL(T* aPtr)
{CleanupArrayDelete<T>::PushL(aPtr);}
template <class T>
inline void CleanupClose<T>::PushL(T& aRef)
{CleanupStack::PushL(TCleanupItem(&Close,&aRef));}
template <class T>
void CleanupClose<T>::Close(TAny *aPtr)
{((static_cast<T*>(aPtr)) )->Close();}
template <class T>
inline void CleanupClosePushL(T& aRef)
{CleanupClose<T>::PushL(aRef);}
template <class T>
inline void CleanupRelease<T>::PushL(T& aRef)
{CleanupStack::PushL(TCleanupItem(&Release,&aRef));}
template <class T>
void CleanupRelease<T>::Release(TAny *aPtr)
{((static_cast<T*>(aPtr)) )->Release();}
template <class T>
inline void CleanupReleasePushL(T& aRef)
{CleanupRelease<T>::PushL(aRef);}
#line 3245 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 4 */
#line 14 "C:\Symbian\9.1\S60_3rd\epoc32\include\coecntrl.h" /* stack depth 3 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\w32std.h" /* stack depth 4 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\fntstore.h" /* stack depth 5 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\f32file.h" /* stack depth 6 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 7 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32hal.h" /* stack depth 8 */
#line 14
const TInt KMaxRomDevices=8;
#line 33
enum TDigitizerCalibrationType
{
EFactory,
ESaved
};
#line 61
class TDigitizerCalibration
{
public:
TPoint iTl;
TPoint iBl;
TPoint iTr;
TPoint iBr;
};
#line 83
enum TKeyboard
{
EKeyboard_Keypad=1,
EKeyboard_Full=2,
};
#line 115
class TKeyboardInfoV01
{
public:
TInt iDeviceKeys;
#line 135
TInt iAppsKeys;
#line 148
TKeyboard iKeyboardType;
};
#line 162
typedef TPckgBuf<TKeyboardInfoV01> TKeyboardInfoV01Buf;
#line 182
class TDigitiserInfoV01
{
public:
TPoint iOffsetToDisplay;
TSize iDigitiserSize;
};
#line 196
class TDigitiserInfoV02 : public TDigitiserInfoV01
{
TInt iZRange;
TUint8 iThetaSupported;
TUint8 iPhiSupported;
TUint8 iAlphaSupported;
TUint8 iPressureSupported;
};
#line 214
typedef TPckgBuf<TDigitiserInfoV01> TDigitiserInfoV01Buf;
#line 224
typedef TPckgBuf<TDigitiserInfoV02> TDigitiserInfoV02Buf;
#line 241
class TMouseInfoV01
{
public:
TInt iMouseButtons;
TPoint iOffsetToDisplay;
TSize iMouseAreaSize;
};
#line 260
typedef TPckgBuf<TMouseInfoV01> TMouseInfoV01Buf;
#line 279
class TVariantInfoV01
{
public:
TVersion iRomVersion;
SInt64 iMachineUniqueId;
TUint iLedCapabilities;
TInt iProcessorClockInKHz;
TInt iSpeedFactor;
};
#line 321
typedef TPckgBuf<TVariantInfoV01> TVariantInfoV01Buf;
#line 334
enum TMachineStartupType
{
EStartupCold,EStartupColdReset,EStartupNewOs,
EStartupPowerFail,EStartupWarmReset,EStartupKernelFault,
EStartupSafeReset
};
#line 350
enum TXYInputType
{
EXYInputNone,
EXYInputPointer,
EXYInputMouse,
EXYInputDeltaMouse
};
#line 367
class TMachineInfoV1
{
public:
TVersion iRomVersion;
TXYInputType iXYInputType;
TBool iKeyboardPresent;
TBool iBacklightPresent;
TSize iDisplaySizeInPixels;
TSize iXYInputSizeInPixels;
TSize iPhysicalScreenSize;
TPoint iOffsetToDisplayInPixels;
TInt iKeyboardId;
TInt iDisplayId;
SInt64 iMachineUniqueId;
TUint iLedCapabilities;
TInt iProcessorClockInKHz;
TInt iSpeedFactor;
TInt iMaximumDisplayColors;
};
typedef TPckgBuf<TMachineInfoV1> TMachineInfoV1Buf;
#line 401
class TMachineInfoV2 : public TMachineInfoV1
{
public:
TInt iLanguageIndex;
TInt iKeyboardIndex;
};
typedef TPckgBuf<TMachineInfoV2> TMachineInfoV2Buf;
#line 422
class TMemoryInfoV1
{
public:
TInt iTotalRamInBytes;
TInt iTotalRomInBytes;
TInt iMaxFreeRamInBytes;
TInt iFreeRamInBytes;
TInt iInternalDiskRamInBytes;
TBool iRomIsReprogrammable;
};
typedef TPckgBuf<TMemoryInfoV1> TMemoryInfoV1Buf;
#line 447
class TRomInfoEntryV1
{
public:
enum TRomTypeV1
{
ERomTypeRom=0,
ERomTypeFlash=1
};
TInt iSize;
TInt iWidth;
TInt iSpeed;
TRomTypeV1 iType;
};
#line 470
class TRomInfoV1
{
public:
TRomInfoEntryV1 iEntry[KMaxRomDevices];
};
typedef TPckgBuf<TRomInfoV1> TRomInfoV1Buf;
const TUint KRuggedFileSystem=0x01;
class TDriveInfoV1
{
public:
TInt iTotalSupportedDrives;
TInfoName iDriveName[KMaxLocalDrives];
TInt iTotalSockets;
TInfoName iSocketName[KMaxPBusSockets];
TInt iRuggedFileSystem;
TUint iRegisteredDriveBitmask;
};
typedef TPckgBuf<TDriveInfoV1> TDriveInfoV1Buf;
class TDriveInfoV18
{
public:
TInt iTotalSupportedDrives;
TBuf8<KMaxInfoName> iDriveName[KMaxLocalDrives];
TInt iTotalSockets;
TBuf8<KMaxInfoName> iSocketName[KMaxPBusSockets];
TInt iRuggedFileSystem;
TUint iRegisteredDriveBitmask;
};
typedef TPckgBuf<TDriveInfoV18> TDriveInfoV1Buf8;
#line 536
class TExcInfo
{
public:
TAny *iCodeAddress;
TAny *iDataAddress;
TInt iExtraData;
};
#line 575
class UserHal
{
public:
__declspec(dllexport) static TInt MemoryInfo(TDes8& anInfo);
__declspec(dllexport) static TInt RomInfo(TDes8& anInfo);
__declspec(dllexport) static TInt StartupReason(TMachineStartupType& aReason);
__declspec(dllexport) static TInt FaultReason(TInt &aReason);
__declspec(dllexport) static TInt ExceptionId(TInt &anId);
__declspec(dllexport) static TInt ExceptionInfo(TExcInfo &aInfo);
__declspec(dllexport) static TInt PageSizeInBytes(TInt& aSize);
__declspec(dllexport) static TInt MachineInfo(TDes8& anInfo);
__declspec(dllexport) static TInt TickPeriod(TTimeIntervalMicroSeconds32& aPeriod);
__declspec(dllexport) static TInt DriveInfo(TDes8& anInfo);
__declspec(dllexport) static TInt SwitchOff();
__declspec(dllexport) static TInt SetXYInputCalibration(const TDigitizerCalibration& aCalibration);
__declspec(dllexport) static TInt CalibrationPoints(TDigitizerCalibration& aCalibration);
__declspec(dllexport) static TInt SaveXYInputCalibration();
__declspec(dllexport) static TInt RestoreXYInputCalibration(TDigitizerCalibrationType aType);
};
#line 8 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 7 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.h" /* stack depth 8 */
#line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\partitions.h" /* stack depth 9 */
#line 15
const TUint KPartitionTypeEmpty=0x00;
const TUint KPartitionTypeFAT12=0x01;
const TUint KPartitionTypeXENIXroot=0x02;
const TUint KPartitionTypeXENIXusr=0x03;
const TUint KPartitionTypeFAT16small=0x04;
const TUint KPartitionTypeExtended=0x05;
const TUint KPartitionTypeFAT16=0x06;
const TUint KPartitionTypeNTFS=0x07;
const TUint KPartitionTypeAIX=0x08;
const TUint KPartitionTypeAIXboot=0x09;
const TUint KPartitionTypeOS2BootManager=0x0a;
const TUint KPartitionTypeWin95FAT32=0x0b;
const TUint KPartitionTypeWin95FAT32LBA=0x0c;
const TUint KPartitionTypeWin95FAT16LBA=0x0e;
const TUint KPartitionTypeWin95ExtdLBA=0x0f;
const TUint KPartitionTypeOPUS=0x10;
const TUint KPartitionTypeHiddenFAT12=0x11;
const TUint KPartitionTypeCompaqDiag=0x12;
const TUint KPartitionTypeHiddenFAT16small=0x14;
const TUint KPartitionTypeHiddenFAT16=0x16;
const TUint KPartitionTypeHiddenNTFS=0x17;
const TUint KPartitionTypeASTSmartSleep=0x18;
const TUint KPartitionTypeHiddenWin95FAT32=0x1b;
const TUint KPartitionTypeHiddenWin95FAT32LBA=0x1c;
const TUint KPartitionTypeHiddenWin95FAT16LBA=0x1e;
const TUint KPartitionTypeNECDOS=0x24;
const TUint KPartitionTypePlan9=0x39;
const TUint KPartitionTypePartitionMagic=0x3c;
const TUint KPartitionTypeVenix80286=0x40;
const TUint KPartitionTypePPCPRePBoot=0x41;
const TUint KPartitionTypeSFS=0x42;
const TUint KPartitionTypeQNX4x=0x4d;
const TUint KPartitionTypeQNX4x_2=0x4e;
const TUint KPartitionTypeQNX4x_3=0x4f;
const TUint KPartitionTypeOnTrackDM=0x50;
const TUint KPartitionTypeOnTrackDM6Aux=0x51;
const TUint KPartitionTypeCPM=0x52;
const TUint KPartitionTypeOnTrackDM6Aux_2=0x53;
const TUint KPartitionTypeOnTrackDM6=0x54;
const TUint KPartitionTypeEZDrive=0x55;
const TUint KPartitionTypeGoldenBow=0x56;
const TUint KPartitionTypePriamEdisk=0x5c;
const TUint KPartitionTypeSpeedStor=0x61;
const TUint KPartitionTypeGNU_HURD=0x63;
const TUint KPartitionTypeNovellNetware=0x64;
const TUint KPartitionTypeNovellNetware_2=0x65;
const TUint KPartitionTypeDiskSecure=0x70;
const TUint KPartitionTypePCIX=0x75;
const TUint KPartitionTypeOldMinix=0x80;
const TUint KPartitionTypeMinixOldLinux=0x81;
const TUint KPartitionTypeLinuxSwap=0x82;
const TUint KPartitionTypeLinux=0x83;
const TUint KPartitionTypeOS2Hidden=0x84;
const TUint KPartitionTypeLinuxExtended=0x85;
const TUint KPartitionTypeNTFSvolset=0x86;
const TUint KPartitionTypeNTFSvolset_2=0x87;
const TUint KPartitionTypeLinuxLVM=0x8e;
const TUint KPartitionTypeAmoeba=0x93;
const TUint KPartitionTypeAmoebaBBT=0x94;
const TUint KPartitionTypeBSD_OS=0x9f;
const TUint KPartitionTypeIBMThinkpad=0xa0;
const TUint KPartitionTypeFreeBSD=0xa5;
const TUint KPartitionTypeOpenBSD=0xa6;
const TUint KPartitionTypeNeXTSTEP=0xa7;
const TUint KPartitionTypeNetBSD=0xa9;
const TUint KPartitionTypeBSDIfs=0xb7;
const TUint KPartitionTypeBSDIswap=0xb8;
const TUint KPartitionTypeBootWizardHidden=0xbb;
const TUint KPartitionTypeDRDOS=0xc1;
const TUint KPartitionTypeDRDOS_2=0xc4;
const TUint KPartitionTypeDRDOS_3=0xc6;
const TUint KPartitionTypeSyrinx=0xc7;
const TUint KPartitionTypeNonFSData=0xda;
const TUint KPartitionTypeCPM_CTOS=0xdb;
const TUint KPartitionTypeDellUtility=0xde;
const TUint KPartitionTypeBootIt=0xdf;
const TUint KPartitionTypeDOSaccess=0xe1;
const TUint KPartitionTypeDOS_RO=0xe3;
const TUint KPartitionTypeSymbianCrashLog=0xf0;
const TUint KPartitionTypeSpeedStor_2=0xf1;
const TUint KPartitionTypeDOSsecondary=0xf2;
const TUint KPartitionTypeSpeedStor_3=0xf4;
const TUint KPartitionTypeRofs=0xfa;
const TUint KPartitionTypeIso9660=0xfb;
const TUint KPartitionTypeEneaLFFS=0xfc;
const TUint KPartitionTypeLinuxRaidAuto=0xfd;
const TUint KPartitionTypeLANStep=0xfe;
const TUint KPartitionTypeBBT=0xff;
inline TBool PartitionIsFAT(TUint a)
{
return (
a==KPartitionTypeFAT12 ||
a==KPartitionTypeFAT16small ||
a==KPartitionTypeFAT16 ||
a==KPartitionTypeFAT16 ||
a==KPartitionTypeWin95FAT16LBA ||
a==KPartitionTypeHiddenFAT12 ||
a==KPartitionTypeHiddenFAT16small ||
a==KPartitionTypeHiddenFAT16 ||
a==KPartitionTypeHiddenWin95FAT16LBA
);
}
inline TBool PartitionIsFAT32(TUint a)
{
return (
a==KPartitionTypeWin95FAT32 ||
a==KPartitionTypeWin95FAT32LBA ||
a==KPartitionTypeHiddenWin95FAT32 ||
a==KPartitionTypeHiddenWin95FAT32LBA
);
}
inline TBool PartitionIsNTFS(TUint a)
{
return (
a==KPartitionTypeNTFS ||
a==KPartitionTypeHiddenNTFS
);
}
const TUint KBootIndicatorBootable=0x80;
class TMBRPartitionEntry
{
public:
TBool IsValidPartition()
{ return (iNumSectors>0 && iPartitionType!=KPartitionTypeEmpty); }
TBool IsValidDosPartition()
{ return (iNumSectors>0 && PartitionIsFAT(iPartitionType)); }
TBool IsDefaultBootPartition()
{ return(iX86BootIndicator==KBootIndicatorBootable && (IsValidDosPartition() || IsValidFAT32Partition())); }
TBool IsValidFAT32Partition()
{ return (iNumSectors>0 && PartitionIsFAT32(iPartitionType)); }
public:
TUint8 iX86BootIndicator;
TUint8 iStartHead;
TUint8 iStartSector;
TUint8 iStartCylinder;
TUint8 iPartitionType;
TUint8 iEndHead;
TUint8 iEndSector;
TUint8 iEndCylinder;
TUint32 iFirstSector;
TUint32 iNumSectors;
};
const TUint KMBRFirstPartitionOffset=0x1BE;
const TUint KMBRSignatureOffset=0x1FE;
const TUint KMBRSignature=0xAA55;
const TInt KMBRMaxPrimaryPartitions=4;
class TMasterBootRecord
{
public:
TUint8 iBootCode[KMBRFirstPartitionOffset];
TMBRPartitionEntry iPartitionEntry[KMBRMaxPrimaryPartitions];
TUint16 iSignature;
};
#line 9 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.h" /* stack depth 8 */
#line 21
enum TMediaDevice { EFixedMedia0, EFixedMedia1, EFixedMedia2, EFixedMedia3,
EFixedMedia4, EFixedMedia5, EFixedMedia6, EFixedMedia7,
ERemovableMedia0, ERemovableMedia1, ERemovableMedia2, ERemovableMedia3,
EInvalidMedia
};
#line 36
typedef signed int TSocket;
class TLDriveAssignInfo
{
public:
TMediaDevice iDevice;
TInt iPriority;
};
class TMediaDeviceAssignInfo
{
public:
TInt iFirstMedia;
TInt iLastMedia;
};
class TLocalDriveCaps
{
public:
__declspec(dllexport) TLocalDriveCaps();
public:
TInt64 iSize;
TMediaType iType;
TBatteryState iBattery;
TUint iDriveAtt;
TUint iMediaAtt;
TUint8* iBaseAddress;
TUint16 iFileSystemId;
TUint16 iPartitionType;
};
typedef TPckgBuf<TLocalDriveCaps> TLocalDriveCapsBuf;
class TLocalDriveCapsV2 : public TLocalDriveCaps
{
public:
TUint iHiddenSectors;
TUint iEraseBlockSize;
};
typedef TPckgBuf<TLocalDriveCapsV2> TLocalDriveCapsV2Buf;
class TLDFormatInfo
{
public:
TInt64 iCapacity;
TUint16 iSectorsPerCluster;
TUint16 iSectorsPerTrack;
TUint16 iNumberOfSides;
enum TFATBits {EFBDontCare, EFB12 = 12, EFB16 = 16, EFB32 = 32};
TFATBits iFATBits;
TUint32 iPad;
};
typedef TPckgBuf<TLDFormatInfo> TSpecialFormatInfoBuf;
class TLocalDriveCapsV3 : public TLocalDriveCapsV2
{
public:
TLDFormatInfo iFormatInfo;
TBool iExtraInfo;
TInt iMaxBytesPerFormat;
};
void __compile_time_assert(int __check[((((TInt)&(((TLocalDriveCaps *)0x1000)->iSize))-0x1000)%8 == 0)?1:-1]) ;
void __compile_time_assert(int __check[((((TInt)&(((TLocalDriveCapsV3 *)0x1000)->iFormatInfo.iCapacity))-0x1000) % 8 == 0)?1:-1]) ;
typedef TPckgBuf<TLocalDriveCapsV3> TLocalDriveCapsV3Buf;
class TLocalDriveCapsV4 : public TLocalDriveCapsV3
{
public:
TInt iNumOfBlocks;
TInt iNumPagesPerBlock;
TInt iNumBytesMain;
TInt iNumBytesSpare;
TInt iEffectiveBlks;
TInt iStartPage;
};
typedef TPckgBuf<TLocalDriveCapsV4> TLocalDriveCapsV4Buf;
typedef TBuf8<64 > TMediaSerialNumber;
class TLocalDriveCapsV5 : public TLocalDriveCapsV4
{
public:
TUint iSerialNumLength;
TUint8 iSerialNum[64 ];
};
typedef TPckgBuf<TLocalDriveCapsV5> TLocalDriveCapsV5Buf;
class TFormatInfo
{
public:
__declspec(dllexport) TFormatInfo();
public:
TBool iFormatIsCurrent;
TInt i512ByteSectorsFormatted;
TInt iMaxBytesPerFormat;
};
class TErrorInfo
{
public:
enum TReasonCode
{
ENoError=0,
EBadSector=1,
};
public:
TReasonCode iReasonCode;
union
{
TInt64 iErrorPos;
TInt iOtherInfo;
};
};
typedef TPckgBuf<TErrorInfo> TErrorInfoBuf;
class TLocalDriveMessageData
{
public:
inline TLocalDriveMessageData()
{}
inline TLocalDriveMessageData(TInt64 aPos, TInt aLength, const TAny* aPtr, TInt aHandle, TInt anOffset, TInt aFlags)
: iPos(aPos), iLength(aLength), iPtr(aPtr), iHandle(aHandle), iOffset(anOffset), iFlags(aFlags)
{}
public:
TInt64 iPos;
TInt iLength;
const TAny* iPtr;
TInt iHandle;
TInt iOffset;
TInt iFlags;
};
class TLocalDriveControlIOData
{
public:
inline TLocalDriveControlIOData()
{}
inline TLocalDriveControlIOData(TInt aCommand, TAny* aParam1, TAny* aParam2, TInt aHandle)
: iCommand(aCommand), iParam1(aParam1), iParam2(aParam2), iHandle(aHandle)
{}
public:
TInt iCommand;
TAny* iParam1;
TAny* iParam2;
TInt iHandle;
};
class TLocalDrivePasswordData
{
public:
TLocalDrivePasswordData(const TDesC8& aOldPasswd, const TDesC8& aNewPasswd, TBool aStorePasswd)
: iOldPasswd(&aOldPasswd), iNewPasswd(&aNewPasswd), iStorePasswd(aStorePasswd)
{}
TLocalDrivePasswordData()
: iOldPasswd(&KNullDesC8), iNewPasswd(&KNullDesC8), iStorePasswd(EFalse)
{}
public:
const TDesC8 *iOldPasswd;
const TDesC8 *iNewPasswd;
TBool iStorePasswd;
};
typedef TPckgBuf<TLocalDrivePasswordData> TLocalDrivePasswordDataPckg;
class TPasswordStore
{
public:
virtual TInt Init()=0;
virtual TInt ReadPasswordData(TDes8 &aBuf)=0;
virtual TInt WritePasswordData(TDesC8 &aBuf)=0;
virtual TInt PasswordStoreLengthInBytes()=0;
enum {EMaxPasswordLength=256};
};
class TMountInfoData
{
public:
TDesC8* iInfo;
TAny* iThread;
};
const TInt KLocalDriveMajorVersion=1;
const TInt KLocalDriveMinorVersion=0;
const TInt KLocalDriveBuildVersion=160;
const static TLitC<sizeof(L"LocDrv")/2> KLitLocalDriveLddName={sizeof(L"LocDrv")/2-1,L"LocDrv"} ;
const TInt KLocalMessageHandle=-1;
class RLocalDrive : public RBusLogicalChannel
{
public:
enum TControl
{
EControlRead=0,
EControlWrite=1,
EControlCaps=2,
EControlFormat=3,
EControlEnlarge=4,
EControlReduce=5,
EControlForceMediaChange=6,
EControlMediaDevice=7,
EControlPasswordLock=8,
EControlPasswordUnlock=9,
EControlPasswordClear=10,
EControlNotifyChange=11,