e32base.h

Go to the documentation of this file.

// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\include\e32base.h
// 
//
 
#ifndef __E32BASE_H__
#define __E32BASE_H__
#include <e32std.h>
 
#ifdef __ARMCC__
#pragma push
#pragma diag_suppress 830 
#endif
class CBase
    {
public:
    inline CBase()  {}
    IMPORT_C virtual ~CBase();
    inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
    inline TAny* operator new(TUint aSize) __NO_THROW;
    inline TAny* operator new(TUint aSize, TLeave);
    inline TAny* operator new(TUint aSize, TUint aExtraSize) __NO_THROW;
    inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize);
    IMPORT_C static void Delete(CBase* aPtr);
protected:
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
    CBase(const CBase&);
    CBase& operator=(const CBase&);
private:
    };
 
#ifdef __ARMCC__    
#pragma pop     
#endif
    
    
class CBufBase : public CBase
    {
public:
    IMPORT_C ~CBufBase();
    inline TInt Size() const;
    IMPORT_C void Reset();
    IMPORT_C void Read(TInt aPos,TDes8& aDes) const;
    IMPORT_C void Read(TInt aPos,TDes8& aDes,TInt aLength) const;
    IMPORT_C void Read(TInt aPos,TAny* aPtr,TInt aLength) const;
    IMPORT_C void Write(TInt aPos,const TDesC8& aDes);
    IMPORT_C void Write(TInt aPos,const TDesC8& aDes,TInt aLength);
    IMPORT_C void Write(TInt aPos,const TAny* aPtr,TInt aLength);
    IMPORT_C void InsertL(TInt aPos,const TDesC8& aDes);
    IMPORT_C void InsertL(TInt aPos,const TDesC8& aDes,TInt aLength);
    IMPORT_C void InsertL(TInt aPos,const TAny* aPtr,TInt aLength);
    IMPORT_C void ExpandL(TInt aPos,TInt aLength);
    IMPORT_C void ResizeL(TInt aSize);
// Pure virtual
    virtual void Compress()=0;
    virtual void Delete(TInt aPos,TInt aLength)=0;
    virtual TPtr8 Ptr(TInt aPos)=0;
    virtual TPtr8 BackPtr(TInt aPos)=0;
private:
    virtual void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength)=0;
protected:
    IMPORT_C CBufBase(TInt anExpandSize);
protected:
    TInt iSize;
    TInt iExpandSize;
    };
 
 
 
 
class CBufFlat : public CBufBase
    {
public:
    IMPORT_C ~CBufFlat();
    IMPORT_C static CBufFlat* NewL(TInt anExpandSize);
    inline TInt Capacity() const;
    IMPORT_C void SetReserveL(TInt aSize);
    IMPORT_C void Compress();
    IMPORT_C void Delete(TInt aPos,TInt aLength);
    IMPORT_C TPtr8 Ptr(TInt aPos);
    IMPORT_C TPtr8 BackPtr(TInt aPos);
protected:
    IMPORT_C CBufFlat(TInt anExpandSize);
private:
    IMPORT_C void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
    TInt iMaxSize;
    TUint8* iPtr;
    };
 
 
 
 
class TBufSegLink;
class CBufSeg : public CBufBase
    {
public:
    IMPORT_C ~CBufSeg();
    IMPORT_C static CBufSeg* NewL(TInt anExpandSize);
    IMPORT_C void Compress();
    IMPORT_C void Delete(TInt aPos,TInt aLength);
    IMPORT_C TPtr8 Ptr(TInt aPos);
    IMPORT_C TPtr8 BackPtr(TInt aPos);
protected:
    IMPORT_C 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:
    IMPORT_C void DoInsertL(TInt aPos,const TAny* aPtr,TInt aLength);
private:
    TDblQue<TBufSegLink> iQue;
    TBufSegLink* iSeg;
    TInt iBase;
    TInt iOffset;
    };
 
 
 
 
class TKeyArrayFix : public TKey
    {
public:
    IMPORT_C TKeyArrayFix(TInt anOffset,TKeyCmpText aType);
    IMPORT_C TKeyArrayFix(TInt anOffset,TKeyCmpText aType,TInt aLength);
    IMPORT_C TKeyArrayFix(TInt anOffset,TKeyCmpNumeric aType);
protected:
    IMPORT_C virtual void Set(CBufBase* aBase,TInt aRecordLength);
    IMPORT_C TAny* At(TInt anIndex) const;
protected:
    TInt iRecordLength;
    CBufBase* iBase;
    friend class CArrayFixBase;
    };
 
 
 
 
typedef CBufBase*(*TBufRep)(TInt anExpandSize);
class CArrayFixBase : public CBase
    {
public:
    IMPORT_C ~CArrayFixBase();
    inline TInt Count() const;
    inline TInt Length() const;
    IMPORT_C void Compress();
    IMPORT_C void Reset();
    IMPORT_C TInt Sort(TKeyArrayFix& aKey);
    IMPORT_C TAny* At(TInt anIndex) const;
    IMPORT_C TAny* End(TInt anIndex) const;
    IMPORT_C TAny* Back(TInt anIndex) const;
    IMPORT_C void Delete(TInt anIndex);
    IMPORT_C void Delete(TInt anIndex,TInt aCount);
    IMPORT_C TAny* ExpandL(TInt anIndex);
    IMPORT_C TInt Find(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
    IMPORT_C TInt FindIsq(const TAny* aPtr,TKeyArrayFix& aKey,TInt& anIndex) const;
    IMPORT_C void InsertL(TInt anIndex,const TAny* aPtr);
    IMPORT_C void InsertL(TInt anIndex,const TAny* aPtr,TInt aCount);
    IMPORT_C TInt InsertIsqL(const TAny* aPtr,TKeyArrayFix& aKey);
    IMPORT_C TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TKeyArrayFix& aKey);
    IMPORT_C void ResizeL(TInt aCount,const TAny* aPtr);
protected:
    IMPORT_C CArrayFixBase(TBufRep aRep,TInt aRecordLength,TInt aGranularity);
    IMPORT_C void InsertRepL(TInt anIndex,const TAny* aPtr,TInt aReplicas);
    IMPORT_C void SetKey(TKeyArrayFix& aKey) const;
    IMPORT_C void SetReserveFlatL(TInt aCount);
    IMPORT_C static TInt CountR(const CBase* aPtr);
    IMPORT_C 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
    {
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_SPECIALIZATION class CArrayFix<TAny> : public CArrayFixBase
    {
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>
    {
public:
    inline explicit CArrayFixFlat(TInt aGranularity);
    inline void SetReserveL(TInt aCount);
    };
 
 
 
 
TEMPLATE_SPECIALIZATION class CArrayFixFlat<TAny> : public CArrayFix<TAny>
    {
public:
    inline CArrayFixFlat(TInt aRecordLength,TInt aGranularity);
    inline void SetReserveL(TInt aCount);
    };
 
 
 
 
TEMPLATE_SPECIALIZATION class CArrayFixFlat<TInt> : public CArrayFix<TInt>
    {
public:
    IMPORT_C explicit CArrayFixFlat(TInt aGranularity);
    IMPORT_C ~CArrayFixFlat();
    inline void SetReserveL(TInt aCount);
    };
 
 
 
 
TEMPLATE_SPECIALIZATION class CArrayFixFlat<TUid> : public CArrayFix<TUid>
    {
public:
    IMPORT_C explicit CArrayFixFlat(TInt aGranularity);
    IMPORT_C ~CArrayFixFlat();
    inline void SetReserveL(TInt aCount);
    };
 
 
 
 
template <class T>
class CArrayFixSeg : public CArrayFix<T>
    {
public:
    inline explicit CArrayFixSeg(TInt aGranularity);
    };
 
 
 
 
TEMPLATE_SPECIALIZATION class CArrayFixSeg<TAny> : public CArrayFix<TAny>
    {
public:
    inline CArrayFixSeg(TInt aRecordLength,TInt aGranularity);
    };
 
 
 
 
template <class T>
class CArrayPtr : public CArrayFix<T*>
    {
public:
    inline CArrayPtr(TBufRep aRep,TInt aGranularity);
    void ResetAndDestroy();
    };
 
 
 
 
 
template <class T>
class CArrayPtrFlat : public CArrayPtr<T>
    {
public:
    inline explicit CArrayPtrFlat(TInt aGranularity);
    inline void SetReserveL(TInt aCount);
    };
 
 
 
 
template <class T>
class CArrayPtrSeg : public CArrayPtr<T>
    {
public:
    inline explicit CArrayPtrSeg(TInt aGranularity);
    };
 
 
 
 
class TKeyArrayVar : public TKey
    {
public:
    IMPORT_C TKeyArrayVar(TInt anOffset,TKeyCmpText aType);
    IMPORT_C TKeyArrayVar(TInt anOffset,TKeyCmpText aType,TInt aLength);
    IMPORT_C TKeyArrayVar(TInt anOffset,TKeyCmpNumeric aType);
protected:
    IMPORT_C virtual void Set(CBufBase* aBase);
    IMPORT_C TAny* At(TInt anIndex) const;
protected:
    CBufBase* iBase;
    friend class CArrayVarBase;
    };
 
 
 
 
 
class CArrayVarBase : public CBase
    {
public:
    IMPORT_C ~CArrayVarBase();
    inline TInt Count() const;
    IMPORT_C TInt Length(TInt anIndex) const;
    IMPORT_C void Compress();
    IMPORT_C void Reset();
    IMPORT_C TInt Sort(TKeyArrayVar& aKey);
    IMPORT_C TAny* At(TInt anIndex) const;
    IMPORT_C void Delete(TInt anIndex);
    IMPORT_C void Delete(TInt anIndex,TInt aCount);
    IMPORT_C TAny* ExpandL(TInt anIndex,TInt aLength);
    IMPORT_C TInt Find(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
    IMPORT_C TInt FindIsq(const TAny* aPtr,TKeyArrayVar& aKey,TInt& anIndex) const;
    IMPORT_C void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
    IMPORT_C TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
    IMPORT_C TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayVar& aKey);
protected:
    IMPORT_C CArrayVarBase(TBufRep aRep,TInt aGranularity);
    IMPORT_C void SetKey(TKeyArrayVar& aKey) const;
    IMPORT_C static TInt CountR(const CBase* aPtr);
    IMPORT_C 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
    {
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_SPECIALIZATION class CArrayVar<TAny> : public CArrayVarBase
    {
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>
    {
public:
    inline explicit CArrayVarFlat(TInt aGranularity);
    };
 
 
 
 
template <class T>
class CArrayVarSeg : public CArrayVar<T>
    {
public:
    inline explicit CArrayVarSeg(TInt aGranularity);
    };
 
 
 
 
class TKeyArrayPak : public TKeyArrayVar
    {
public:
    IMPORT_C TKeyArrayPak(TInt anOffset,TKeyCmpText aType);
    IMPORT_C TKeyArrayPak(TInt anOffset,TKeyCmpText aType,TInt aLength);
    IMPORT_C TKeyArrayPak(TInt anOffset,TKeyCmpNumeric aType);
protected:
    IMPORT_C virtual void Set(CBufBase* aBase);
    IMPORT_C TAny* At(TInt anIndex) const;
private:
    TInt iCacheIndex;
    TInt iCacheOffset;
    friend class CArrayPakBase;
    };
 
 
 
 
class CArrayPakBase : public CBase
    {
public:
    IMPORT_C ~CArrayPakBase();
    inline TInt Count() const;
    IMPORT_C TInt Length(TInt anIndex) const;
    IMPORT_C void Compress();
    IMPORT_C void Reset();
    IMPORT_C void SortL(TKeyArrayVar& aKey);
    IMPORT_C TAny* At(TInt anIndex) const;
    IMPORT_C void Delete(TInt anIndex);
    IMPORT_C void Delete(TInt anIndex,TInt aCount);
    IMPORT_C TAny* ExpandL(TInt anIndex,TInt aLength);
    IMPORT_C TInt Find(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
    IMPORT_C TInt FindIsq(const TAny* aPtr,TKeyArrayPak& aKey,TInt& anIndex) const;
    IMPORT_C void InsertL(TInt anIndex,const TAny* aPtr,TInt aLength);
    IMPORT_C TInt InsertIsqL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
    IMPORT_C TInt InsertIsqAllowDuplicatesL(const TAny* aPtr,TInt aLength,TKeyArrayPak& aKey);
protected:
    IMPORT_C CArrayPakBase(TBufRep aRep,TInt aGranularity);
    IMPORT_C void SetKey(TKeyArrayPak& aKey) const;
    IMPORT_C TInt GetOffset(TInt anIndex) const;
    IMPORT_C void BuildVarArrayL(CArrayVarFlat<TAny>*& aVarFlat);
    IMPORT_C static TInt CountR(const CBase* aPtr);
    IMPORT_C 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
    {
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_SPECIALIZATION class CArrayPak<TAny> : public CArrayPakBase
    {
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>
    {
public:
    inline explicit CArrayPakFlat(TInt aGranularity);
    };
 
 
 
 
class CObjectCon;
class CObject : public CBase
    {
public:
    IMPORT_C CObject();
    IMPORT_C ~CObject();
    IMPORT_C virtual TInt Open();
    IMPORT_C virtual void Close();
    IMPORT_C virtual TName Name() const;
    IMPORT_C virtual TFullName FullName() const;
    IMPORT_C TInt SetName(const TDesC* aName);
    IMPORT_C void SetNameL(const TDesC* aName);
    inline CObject* Owner() const;
    inline void SetOwner(CObject* anOwner);
    inline TInt AccessCount() const;
protected:
    IMPORT_C 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;
    __DECLARE_TEST;
    };
 
//Forward declaration of SObjectIxRec
struct SObjectIxRec;
    
class CObjectIx : public CBase
    {
public:
    enum {
         ENoClose=KHandleNoClose,
         
         
         ELocalHandle=KHandleFlagLocal
         };
public:
    IMPORT_C static CObjectIx* NewL();
    IMPORT_C ~CObjectIx();
    IMPORT_C TInt AddL(CObject* anObj);
    IMPORT_C void Remove(TInt aHandle);
    IMPORT_C CObject* At(TInt aHandle,TInt aUniqueID);
    IMPORT_C CObject* At(TInt aHandle);
    IMPORT_C CObject* AtL(TInt aHandle,TInt aUniqueID);
    IMPORT_C CObject* AtL(TInt aHandle);
    IMPORT_C TInt At(const CObject* anObject) const;
    IMPORT_C TInt Count(CObject* anObject) const;
    IMPORT_C CObject* operator[](TInt anIndex);
    inline TInt Count() const;
    inline TInt ActiveCount() const;
protected:
    IMPORT_C CObjectIx();
private:
    void UpdateState();
private:
    TInt iNumEntries;       // Number of actual entries in the index
    TInt iHighWaterMark;    // points to at least 1 above the highest active index
    TInt iAllocated;        // Max entries before realloc needed
    TInt iNextInstance;
    SObjectIxRec *iObjects;
    TInt iFree;             // The index of the first free slot or -1.
    TInt iUpdateDisabled;   // If >0, disables HWM update, reorder of the free list and memory shrinking.
    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
    {
public:
    IMPORT_C static CObjectCon* NewL();
    IMPORT_C ~CObjectCon();
    IMPORT_C void Remove(CObject* anObj);
    IMPORT_C void AddL(CObject* anObj);
    IMPORT_C CObject* operator[](TInt anIndex);
    IMPORT_C CObject* At(TInt aFindHandle) const;
    IMPORT_C CObject* AtL(TInt aFindHandle) const;
    IMPORT_C TInt CheckUniqueFullName(const CObject* anOwner,const TDesC& aName) const;
    IMPORT_C TInt CheckUniqueFullName(const CObject* anObject) const;
    IMPORT_C TInt FindByName(TInt& aFindHandle,const TDesC& aMatch,TName& aName) const;
    IMPORT_C TInt FindByFullName(TInt& aFindHandle,const TDesC& aMatch,TFullName& aFullName) const;
    inline TInt UniqueID() const;
    inline TInt Count() const;
protected:
    IMPORT_C 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
    {
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
protected:
    enum {ENotOwnerID};
#endif
    
public:
    IMPORT_C static CObjectConIx* NewL();
    IMPORT_C ~CObjectConIx();
    IMPORT_C CObjectCon* Lookup(TInt aFindHandle) const;
    IMPORT_C CObjectCon* CreateL();
    IMPORT_C void Remove(CObjectCon* aCon);
protected:
    IMPORT_C CObjectConIx();
    IMPORT_C void CreateContainerL(CObjectCon*& anObject);
private:
    CObjectCon* LookupByUniqueId(TInt aUniqueId) const;
private:
    TInt iCount;
    TInt iAllocated;
    TUint16 iNextUniqueID;
    TUint16 iUniqueIDHasWrapped;
    CObjectCon** iContainers;
    TAny* iSpare1;
    TAny* iSpare2;
    };
 
// Forward Declaration of TCleanupStackItem
class TCleanupStackItem;
 
 
 
 
typedef void (*TCleanupOperation)(TAny*);
 
 
 
 
class TCleanupItem
    {
public:
    inline TCleanupItem(TCleanupOperation anOperation, TAny* aPtr = 0);
private:
    TCleanupOperation iOperation;
    TAny* iPtr;
    friend class TCleanupStackItem;
    };
 
 
 
 
class CCleanup : public CBase
    {
public:
    IMPORT_C static CCleanup* New();
    IMPORT_C static CCleanup* NewL();
    IMPORT_C ~CCleanup();
    IMPORT_C void NextLevel();
    IMPORT_C void PreviousLevel();
    IMPORT_C void PushL(TAny* aPtr);
    IMPORT_C void PushL(CBase* anObject);
    IMPORT_C void PushL(TCleanupItem anItem);
    IMPORT_C void Pop();
    IMPORT_C void Pop(TInt aCount);
    IMPORT_C void PopAll();
    IMPORT_C void PopAndDestroy();
    IMPORT_C void PopAndDestroy(TInt aCount);
    IMPORT_C void PopAndDestroyAll();
    IMPORT_C void Check(TAny* aExpectedItem);
protected:
    IMPORT_C void DoPop(TInt aCount,TBool aDestroy);
    IMPORT_C void DoPopAll(TBool aDestroy);
protected:
    IMPORT_C CCleanup();
protected:
    TCleanupStackItem* iBase;
    
    
    TCleanupStackItem* iTop;
    
    
    TCleanupStackItem* iNext;
    };
 
 
 
 
NONSHARABLE_CLASS(TCleanupTrapHandler) : public TTrapHandler
    {
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
    {
public:
    inline ~TAutoClose();
    inline void PushL();
    inline void Pop();
private:
    static void Close(TAny *aObj);
public:
    T iObj;
    };
 
 
 
 
class CTrapCleanup : public CBase
    {
public:
    IMPORT_C static CTrapCleanup* New();
    IMPORT_C ~CTrapCleanup();
protected:
    IMPORT_C CTrapCleanup();
private:
    TCleanupTrapHandler iHandler;
    TTrapHandler* iOldHandler;
    };
 
 
 
 
class CCirBufBase : public CBase
    {
public:
    IMPORT_C ~CCirBufBase();
    inline TInt Count() const;
    inline TInt Length() const;
    IMPORT_C void SetLengthL(TInt aLength);
    IMPORT_C void Reset();
protected:
    IMPORT_C CCirBufBase(TInt aSize);
    IMPORT_C TInt DoAdd(const TUint8* aPtr);
    IMPORT_C TInt DoAdd(const TUint8* aPtr,TInt aCount);
    IMPORT_C TInt DoRemove(TUint8* aPtr);
    IMPORT_C 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();
#if defined(__VC32__)
    inline ~CCirBuf() {}
#endif
    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>
    {
public:
    IMPORT_C CCirBuffer();
    IMPORT_C ~CCirBuffer();
    IMPORT_C TInt Get();
    IMPORT_C TInt Put(TInt aVal);
    };
//
 
 
 
class CActive : public CBase
    {
public:
 
enum TPriority
    {
    EPriorityIdle=-100,
    
    
    EPriorityLow=-20,
    
    
    EPriorityStandard=0,
 
 
    EPriorityUserInput=10,
    
    
    EPriorityHigh=20,
    };
public:
    IMPORT_C ~CActive();
    IMPORT_C void Cancel();
    IMPORT_C void Deque();
    IMPORT_C void SetPriority(TInt aPriority);
    inline TBool IsActive() const;
    inline TBool IsAdded() const;
    inline TInt Priority() const;
protected:
    IMPORT_C CActive(TInt aPriority);
    IMPORT_C void SetActive();
 
 
    virtual void DoCancel() =0;
 
 
    virtual void RunL() =0;
    IMPORT_C virtual TInt RunError(TInt aError);
protected:
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
public:
    
    TRequestStatus iStatus;
private:
//  TBool iActive;
    TPriQueLink iLink;
    TAny* iSpare;
    friend class CActiveScheduler;
    friend class CServer;
    friend class CServer2;
    };
 
 
 
 
class CIdle : public CActive
    {
public:
    IMPORT_C static CIdle* New(TInt aPriority);
    IMPORT_C static CIdle* NewL(TInt aPriority);
    IMPORT_C ~CIdle();
    IMPORT_C void Start(TCallBack aCallBack);
protected:
    IMPORT_C CIdle(TInt aPriority);
    IMPORT_C void RunL();
    IMPORT_C void DoCancel();
protected:
    
    TCallBack iCallBack;
    };
 
 
 
 
class CAsyncOneShot : public CActive
    {
public:
    IMPORT_C CAsyncOneShot(TInt aPriority);
    IMPORT_C virtual void DoCancel();
    IMPORT_C virtual void Call();
    IMPORT_C virtual ~CAsyncOneShot();
    inline RThread& Thread();
private:
    void Setup();
    RThread iThread;
    };
 
 
 
 
class CAsyncCallBack : public CAsyncOneShot
    {
public:
    IMPORT_C CAsyncCallBack(TInt aPriority);
    IMPORT_C CAsyncCallBack(const TCallBack& aCallBack, TInt aPriority);
    IMPORT_C void Set(const TCallBack& aCallBack);
    IMPORT_C void CallBack();
    IMPORT_C virtual ~CAsyncCallBack();
protected:
    virtual void RunL();
//
protected:
    TCallBack iCallBack;
    };
 
 
 
 
class TDeltaTimerEntry
    {
    friend class CDeltaTimer;
public:
    inline TDeltaTimerEntry(const TCallBack& aCallback);
    inline TDeltaTimerEntry();
    inline void Set(TCallBack& aCallback);
private:
    TCallBack iCallBack; 
    TTickCountQueLink iLink;
    };
    
    
    
 
class CDeltaTimer : public CActive
    {
public:
    // Queue management
    IMPORT_C virtual void Queue(TTimeIntervalMicroSeconds32 aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
    IMPORT_C virtual void Remove(TDeltaTimerEntry& aEntry);
    IMPORT_C TInt QueueLong(TTimeIntervalMicroSeconds aTimeInMicroSeconds, TDeltaTimerEntry& aEntry);
 
    // Factory functions
    IMPORT_C static CDeltaTimer* NewL(TInt aPriority);
    IMPORT_C static CDeltaTimer* NewL(TInt aPriority, TTimeIntervalMicroSeconds32 aGranularity);
 
    // Destructor
    ~CDeltaTimer();
 
private:
    // Construction
    CDeltaTimer(TInt aPriority, TInt aTickPeriod);
 
    // From CActive 
    void DoCancel();
    void RunL();
 
    // Utility
    void Activate(TBool aRequeueTimer = EFalse);
 
private:    
    RTimer iTimer;
    
    TTickCountQue iQueue;
    
    const TInt iTickPeriod;
    
    TBool iQueueBusy;
    };
 
 
 
 
class CTimer : public CActive
    {
public:
    IMPORT_C ~CTimer();
    IMPORT_C void At(const TTime& aTime);
    IMPORT_C void AtUTC(const TTime& aTimeInUTC);
    IMPORT_C void After(TTimeIntervalMicroSeconds32 anInterval);
    IMPORT_C void Lock(TTimerLockSpec aLock);
    IMPORT_C void Inactivity(TTimeIntervalSeconds aSeconds);
    IMPORT_C void HighRes(TTimeIntervalMicroSeconds32 aInterval);
protected:
    IMPORT_C CTimer(TInt aPriority);
    IMPORT_C void ConstructL();
    IMPORT_C void DoCancel();
private:
    RTimer iTimer;
    };
 
 
 
 
class CPeriodic : public CTimer
    {
public:
    IMPORT_C static CPeriodic* New(TInt aPriority);
    IMPORT_C static CPeriodic* NewL(TInt aPriority);
    IMPORT_C ~CPeriodic();
    IMPORT_C void Start(TTimeIntervalMicroSeconds32 aDelay,TTimeIntervalMicroSeconds32 anInterval,TCallBack aCallBack);
protected:
    IMPORT_C CPeriodic(TInt aPriority);
    IMPORT_C void RunL();
private:
    TTimeIntervalMicroSeconds32 iInterval;
    TCallBack iCallBack;
    };
 
 
 
 
class MBeating
    {
public:
    virtual void Beat() =0;
    
    virtual void Synchronize() =0;
    };
 
 
 
 
class CHeartbeat : public CTimer
    {
public:
    IMPORT_C static CHeartbeat* New(TInt aPriority);
    IMPORT_C static CHeartbeat* NewL(TInt aPriority);
    IMPORT_C ~CHeartbeat();
    IMPORT_C void Start(TTimerLockSpec aLock,MBeating *aBeating);
protected:
    IMPORT_C CHeartbeat(TInt aPriority);
    IMPORT_C void RunL();
private:
    TTimerLockSpec iLock;
    MBeating *iBeating;
    };
//
 
class CServer2;
 
 
 
 
class CSession2 : public CBase
    {
    friend class CServer2;
public:
    IMPORT_C virtual ~CSession2() =0;
private:
    IMPORT_C virtual void CreateL(); // Default method, does nothing
public:
    inline const CServer2* Server() const;
    IMPORT_C void ResourceCountMarkStart();
    IMPORT_C void ResourceCountMarkEnd(const RMessage2& aMessage);
    IMPORT_C virtual TInt CountResources();
 
    virtual void ServiceL(const RMessage2& aMessage) =0;
    IMPORT_C virtual void ServiceError(const RMessage2& aMessage,TInt aError);
protected:
    IMPORT_C CSession2();
    IMPORT_C virtual void Disconnect(const RMessage2& aMessage);
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
public:
    IMPORT_C void SetServer(const CServer2* aServer);
    enum TPanicNo {ESesCountResourcesNotImplemented=1,ESesFoundResCountHeaven};
 
private:
    TInt iResourceCountMark;
    TDblQueLink iLink;
    const CServer2* iServer;
    TAny* iSpare;
    };
 
class CServer2 : public CActive
    {
public:
 
    enum TServerType
        {
        EUnsharableSessions                 = EIpcSession_Unsharable,
        ESharableSessions                   = EIpcSession_Sharable,
        EGlobalSharableSessions             = EIpcSession_GlobalSharable,
        };
 
public:
    IMPORT_C virtual ~CServer2() =0;
    IMPORT_C TInt Start(const TDesC& aName);
    IMPORT_C void StartL(const TDesC& aName);
    IMPORT_C void ReStart();
    IMPORT_C void SetPinClientDescriptors(TBool aPin);
    
    inline RServer2 Server() const { return iServer; }
protected:
    inline const RMessage2& Message() const;
    IMPORT_C CServer2(TInt aPriority, TServerType aType=EUnsharableSessions);
    IMPORT_C void DoCancel();
    IMPORT_C void RunL();
    IMPORT_C TInt RunError(TInt aError);
    IMPORT_C virtual void DoConnect(const RMessage2& aMessage);
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
    
    IMPORT_C 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:
    IMPORT_C void SetMaster(const CServer2* aServer);
 
    enum TPanic
        {
        EBadMessageNumber,
        ESessionNotConnected,
        ESessionAlreadyConnected,
        EClientDoesntHaveRequiredCaps,
        };
 
private:
    TUint8 iSessionType;
    TUint8 iServerRole;
    TUint16 iServerOpts;
    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;
    };
 
 
 
class CPolicyServer : public CServer2
    {
public:
    enum TFailureAction
        {
        EFailClient = 0,    
        EPanicClient= 1,    
        };
 
    enum TCustomResult
        {
        EPass = 0,  
        EFail = 1,  
        EAsync = 2, 
        };
 
    class TPolicyElement
        {
    public:
        TStaticSecurityPolicy       iPolicy;
 
        TInt                        iAction;    
        };
 
    enum TSpecialCase 
        {
        ECustomCheck            =255u,
 
        ENotSupported           =254u,
 
        EAlwaysPass             =253u, 
 
        ESpecialCaseLimit       =252u,      
        ESpecialCaseHardLimit   =250u       
        };
 
    class TPolicy
        {
    public:
        TUint8 iOnConnect;
 
        TUint16 iRangeCount;
 
        const TInt* iRanges;
 
        const TUint8* iElementsIndex;
 
        const TPolicyElement* iElements;    
        };
 
public:
    IMPORT_C void ProcessL(const RMessage2& aMsg);
 
    IMPORT_C void CheckFailedL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
 
    IMPORT_C void ProcessError(const RMessage2& aMsg, TInt aError);
 
protected:
    IMPORT_C CPolicyServer(TInt aPriority, const TPolicy& aPolicy, TServerType aType=EUnsharableSessions);
 
    IMPORT_C virtual TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing);
 
    IMPORT_C virtual TCustomResult CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);
 
protected:
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
private:
    IMPORT_C virtual void RunL();
    IMPORT_C virtual TInt RunError(TInt aError);
    const CPolicyServer::TPolicyElement* FindPolicyElement(TInt aFn, TUint& aSpecialCase) const;
private:
    const TPolicy& iPolicy;
 
    };
 
 
 
class CActiveScheduler : public CBase
    {
    friend class CActiveSchedulerWait;
public:
    struct TLoop;
    typedef TLoop* TLoopOwner;
public:
    IMPORT_C CActiveScheduler();
    IMPORT_C ~CActiveScheduler();
    IMPORT_C static void Install(CActiveScheduler* aScheduler);
    IMPORT_C static CActiveScheduler* Current();
    IMPORT_C static void Add(CActive* aActive);
    IMPORT_C static void Start();
    IMPORT_C static void Stop();
    IMPORT_C static TBool RunIfReady(TInt& aError, TInt aMinimumPriority);
    IMPORT_C static CActiveScheduler* Replace(CActiveScheduler* aNewActiveScheduler);
    IMPORT_C virtual void WaitForAnyRequest();
    IMPORT_C virtual void Error(TInt aError) const;
    IMPORT_C void Halt(TInt aExitCode) const;
    IMPORT_C TInt StackDepth() const;
private:
    class TCleanupBundle
    {
        public:
        CCleanup* iCleanupPtr;
        TInt iDummyInt;
    };
private:
    static void Start(TLoopOwner* aOwner);
    IMPORT_C virtual void OnStarting();
    IMPORT_C virtual void OnStopping();
    IMPORT_C virtual void Reserved_1();
    IMPORT_C virtual void Reserved_2();
    void Run(TLoopOwner* const volatile& aLoop);
    void DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj, TCleanupBundle* aCleanupBundle);
protected:
    IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
protected:
    inline TInt Level() const;  // deprecated
private:
    TLoop* iStack;
    TPriQue<CActive> iActiveQ;
    TAny* iSpare;
    };
 
 
 
 
class CActiveSchedulerWait : public CBase
    {
public:
    IMPORT_C CActiveSchedulerWait();
    IMPORT_C ~CActiveSchedulerWait();
    IMPORT_C void Start();
    IMPORT_C void AsyncStop();
    IMPORT_C void AsyncStop(const TCallBack& aCallMeWhenStopped);
    inline TBool IsStarted() const;
    IMPORT_C TBool CanStopNow() const;
private:
    CActiveScheduler::TLoopOwner iLoop;
    };
 
 
 
 
class CleanupStack
    {
public:
    IMPORT_C static void PushL(TAny* aPtr);
    IMPORT_C static void PushL(CBase* aPtr);
    IMPORT_C static void PushL(TCleanupItem anItem);
    IMPORT_C static void Pop();
    IMPORT_C static void Pop(TInt aCount);
    IMPORT_C static void PopAndDestroy();
    IMPORT_C static void PopAndDestroy(TInt aCount);
    IMPORT_C 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);
    };
 
 
 
 
template <class T>
class CleanupDelete
    {
public:
    inline static void PushL(T* aPtr);
private:
    static void Delete(TAny *aPtr);
    };
    
    
 
    
template <class T>
inline void CleanupDeletePushL(T* aPtr);
 
 
 
 
template <class T>
class CleanupArrayDelete
    {
public:
    inline static void PushL(T* aPtr);
private:
    static void ArrayDelete(TAny *aPtr);
    };
 
 
 
 
template <class T>
inline void CleanupArrayDeletePushL(T* aPtr);
 
 
 
 
template <class T>
class CleanupClose
    {
public:
    inline static void PushL(T& aRef);
private:
    static void Close(TAny *aPtr);
    };
    
    
 
    
template <class T>
inline void CleanupClosePushL(T& aRef);
 
 
 
 
template <class T>
class CleanupRelease
    {
public:
    inline static void PushL(T& aRef);
private:
    static void Release(TAny *aPtr);
    };
    
    
 
    
template <class T>
inline void CleanupReleasePushL(T& aRef);
 
 
 
 
class CConsoleBase;
 
class Console
    {
public:
    IMPORT_C static CConsoleBase* NewL(const TDesC& aTitle,TSize aSize);
    };
 
#include <e32base.inl>
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <e32base_private.h>
#endif
 
#endif //__E32BASE_H__