Symaptic: os/persistentdata/persistentstorage/store/INC/S32CONT.INL@260cb5ec6c19

     1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 // Class TPagedSetToken

    17 inline TPagedSetToken::TPagedSetToken(TEmpty)

    18 	{Clear();}

    19 inline TInt TPagedSetToken::Count() const

    20 	{return iCount;}

    22 // Class TPagedSetBase

    23 inline TBool TPagedSetBase::IsDirty() const

    24 	{return iTree.IsDirty();}

    25 inline void TPagedSetBase::MarkCurrent()

    26 	{iTree.MarkCurrent();}

    27 inline void TPagedSetBase::MarkDirty()

    28 	{iTree.MarkDirty();}

    29 inline TBool TPagedSetBase::IsBroken() const

    30 	{return iTree.IsBroken();}

    31 inline TBool TPagedSetBase::IsIntact() const

    32 	{return iTree.IsIntact();}

    33 inline void TPagedSetBase::MarkBroken()

    34 	{iTree.MarkBroken();}

    35 inline TInt TPagedSetBase::Count() const

    36 	{return iCount;}

    37 inline TBool TPagedSetBase::IsEmpty() const

    38 	{return iTree.IsEmpty();}

    40 // Class TPagedMultisetBase

    41 inline void TPagedMultisetBase::InsertL(const TAny* aPtr)

    42 	{TPagedSetBase::InsertAllowDuplicatesL(aPtr);}

    43 inline TPagedMultisetBase::TPagedMultisetBase(TInt anEntrySize)

    44 	: TPagedSetBase(anEntrySize)

    45 	{}

    46 inline TPagedMultisetBase::TPagedMultisetBase(const TPagedSetToken& aToken,TInt anEntrySize)

    47 	: TPagedSetBase(aToken,anEntrySize)

    48 	{}

    50 // Template class TPagedSet

    51 template <class T>

    52 inline TPagedSet<T>::TPagedSet()

    53 	: TPagedSetBase(sizeof(T))

    54 	{}

    55 template <class T>

    56 inline TPagedSet<T>::TPagedSet(const TPagedSetToken& aToken)

    57 	: TPagedSetBase(aToken,sizeof(T))

    58 	{}

    59 template <class T>

    60 inline TBool TPagedSet<T>::ContainsL(const T& anObject) const

    61 	{return TPagedSetBase::ContainsL(&anObject);}

    62 template <class T>

    63 inline void TPagedSet<T>::InsertL(const T& anObject)

    64 	{TPagedSetBase::InsertL(&anObject);}

    65 template <class T>

    66 inline void TPagedSet<T>::DeleteL(const T& anObject)

    67 	{TPagedSetBase::DeleteL(&anObject);}

    68 inline TPagedSet<TAny>::TPagedSet(TInt anEntrySize)

    69 	: TPagedSetBase(anEntrySize)

    70 	{}

    71 inline TPagedSet<TAny>::TPagedSet(const TPagedSetToken& aToken,TInt anEntrySize)

    72 	: TPagedSetBase(aToken,anEntrySize)

    73 	{}

    75 // Template class TPagedMultiset

    76 template <class T>

    77 inline TPagedMultiset<T>::TPagedMultiset()

    78 	: TPagedMultisetBase(sizeof(T))

    79 	{}

    80 template <class T>

    81 inline TPagedMultiset<T>::TPagedMultiset(const TPagedSetToken& aToken)

    82 	: TPagedMultisetBase(aToken,sizeof(T))

    83 	{}

    84 template <class T>

    85 inline TBool TPagedMultiset<T>::ContainsL(const T& anObject) const

    86 	{return TPagedMultisetBase::ContainsL(&anObject);}

    87 template <class T>

    88 inline void TPagedMultiset<T>::InsertL(const T& anObject)

    89 	{TPagedMultisetBase::InsertL(&anObject);}

    90 template <class T>

    91 inline void TPagedMultiset<T>::DeleteL(const T& anObject)

    92 	{TPagedMultisetBase::DeleteL(&anObject);}

    93 inline TPagedMultiset<TAny>::TPagedMultiset(TInt anEntrySize)

    94 	: TPagedMultisetBase(anEntrySize)

    95 	{}

    96 inline TPagedMultiset<TAny>::TPagedMultiset(const TPagedSetToken& aToken,TInt anEntrySize)

    97 	: TPagedMultisetBase(aToken,anEntrySize)

    98 	{}

   100 // Class TPagedSetIterBase

   101 inline TPagedSetIterBase::TPagedSetIterBase(const TPagedSetBase& aSet)

   102 	: iTree(&aSet.iTree)

   103 	{}

   105 // Class TPagedSetIter

   106 template <class T>

   107 inline TPagedSetIter<T>::TPagedSetIter(const TPagedSet<T>& aSet)

   108 	: TPagedSetIterBase(aSet)

   109 	{}

   110 template <class T>

   111 inline TPagedSetIter<T>::TPagedSetIter(const TPagedMultiset<T>& aSet)

   112 	: TPagedSetIterBase(aSet)

   113 	{}

   114 template <class T>

   115 inline T TPagedSetIter<T>::AtL() const

   116 	{T t;TPagedSetIterBase::ExtractAtL(&t);return t;}

   117 template <class T>

   118 inline void TPagedSetIter<T>::ExtractAtL(T& anObject) const

   119 	{TPagedSetIterBase::ExtractAtL(&anObject);}

   120 inline TPagedSetIter<TAny>::TPagedSetIter(const TPagedSetBase& aSet)

   121 	: TPagedSetIterBase(aSet)

   122 	{}

   124 // Class TPagedSetBiIterBase

   125 inline TPagedSetBiIterBase::TPagedSetBiIterBase(const TPagedSetBase& aSet)

   126 	: iTree(&aSet.iTree)

   127 	{}

   129 // Class TPagedSetBiIter

   130 template <class T>

   131 inline TPagedSetBiIter<T>::TPagedSetBiIter(const TPagedSet<T>& aSet)

   132 	: TPagedSetBiIterBase(aSet)

   133 	{}

   134 template <class T>

   135 inline TPagedSetBiIter<T>::TPagedSetBiIter(const TPagedMultiset<T>& aSet)

   136 	: TPagedSetBiIterBase(aSet)

   137 	{}

   138 template <class T>

   139 inline T TPagedSetBiIter<T>::AtL() const

   140 	{T t;TPagedSetBiIterBase::ExtractAtL(&t);return t;}

   141 template <class T>

   142 inline void TPagedSetBiIter<T>::ExtractAtL(T& anObject) const

   143 	{TPagedSetBiIterBase::ExtractAtL(&anObject);}

   144 inline TPagedSetBiIter<TAny>::TPagedSetBiIter(const TPagedSetBase& aSet)

   145 	: TPagedSetBiIterBase(aSet)

   146 	{}

   148 // Class TPagedSetRIterBase

   149 inline TBool TPagedSetRIterBase::ResetL()

   150 	{return iIter.LastL();}

   151 inline TBool TPagedSetRIterBase::NextL()

   152 	{return iIter.PreviousL();}

   153 inline void TPagedSetRIterBase::ExtractAtL(TAny* aPtr) const

   154 	{iIter.ExtractAtL(aPtr);}

   155 inline TPagedSetRIterBase::TPagedSetRIterBase(const TPagedSetBase& aSet)

   156 	: iIter(aSet)

   157 	{}

   159 // Class TPagedSetRIter

   160 template <class T>

   161 inline TPagedSetRIter<T>::TPagedSetRIter(const TPagedSet<T>& aSet)

   162 	: TPagedSetRIterBase(aSet)

   163 	{}

   164 template <class T>

   165 inline TPagedSetRIter<T>::TPagedSetRIter(const TPagedMultiset<T>& aSet)

   166 	: TPagedSetRIterBase(aSet)

   167 	{}

   168 template <class T>

   169 inline T TPagedSetRIter<T>::AtL() const

   170 	{T t;TPagedSetRIterBase::ExtractAtL(&t);return t;}

   171 template <class T>

   172 inline void TPagedSetRIter<T>::ExtractAtL(T& anObject) const

   173 	{TPagedSetRIterBase::ExtractAtL(&anObject);}

   174 inline TPagedSetRIter<TAny>::TPagedSetRIter(const TPagedSetBase& aSet)

   175 	: TPagedSetRIterBase(aSet)

   176 	{}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--