--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailservices/emailstore/base_plugin/inc/Map.inl Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,562 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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: Map implementation inlines.
+*
+*/
+
+
+template <class Tkey, class Tvalue>
+inline RMap<Tkey, Tvalue>::RMap(const TLinearOrder<Tkey>& anOrder)
+:iOrder(anOrder)
+{
+}
+
+template <class Tkey, class Tvalue>
+inline void RMap<Tkey, Tvalue>::ResetAndDestroy()
+{
+ iKeys.ResetAndDestroy();
+ iValues.ResetAndDestroy();
+}
+
+template <class Tkey, class Tvalue>
+inline void RMap<Tkey, Tvalue>::Close()
+{
+ // ResetAndDestroy();
+ iKeys.Close();
+ iValues.Close();
+}
+
+template <class Tkey, class Tvalue>
+inline void RMap<Tkey, Tvalue>::InsertL(const Tkey* aKey, const Tvalue* aValue)
+{
+ TInt pos = Find(*aKey);
+ if (pos == KErrNotFound)
+ {
+ User::LeaveIfError(iKeys.InsertInOrder(aKey, iOrder));
+ pos = Find(*aKey);
+ User::LeaveIfError(iValues.Insert(aValue, pos));
+ } else
+ {
+ User::LeaveIfError(iKeys.InsertInOrderAllowRepeats(aKey, iOrder));
+
+ while (*(iKeys[pos]) == *aKey)
+ {
+ pos++;
+ }
+
+ //our position should be
+ pos--;
+
+ User::LeaveIfError(iValues.Insert(aValue, pos));
+ }
+}
+
+template <class Tkey, class Tvalue>
+inline const Tvalue* RMap<Tkey, Tvalue>::InsertReplaceL(const Tkey* aKey, const Tvalue* aValue)
+{
+ TInt pos = Find(*aKey);
+ if (pos == KErrNotFound)
+ {
+ User::LeaveIfError(iKeys.InsertInOrder(aKey, iOrder));
+ pos = Find(*aKey);
+ User::LeaveIfError(iValues.Insert(aValue, pos));
+ return aValue;
+ } else
+ {
+ Tvalue* v = iValues[pos];
+ iValues[pos] = const_cast<Tvalue*>(aValue);
+ return v;
+ }
+}
+
+template <class Tkey, class Tvalue>
+inline TInt RMap<Tkey, Tvalue>::Find(const Tkey& aKey) const
+{
+ TInt pos = KErrNotFound;
+ for (TInt i = 0; i < iKeys.Count(); i++)
+ {
+ if (*(iKeys[i]) == aKey)
+ {
+ pos = i;
+ break;
+ }
+ }
+
+ return pos;
+}
+
+
+template <class Tkey, class Tvalue>
+inline TBool RMap<Tkey, Tvalue>::ContainsKey(const Tkey& aKey) const
+{
+ return (Find(aKey) != KErrNotFound);
+}
+
+template <class Tkey, class Tvalue>
+inline TBool RMap<Tkey, Tvalue>::ContainsValue(const Tvalue& aValue) const
+{
+ TInt pos = KErrNotFound;
+ for (TInt i = 0; i < iValues.Count(); i++)
+ {
+ if (*(iValues[i]) == aValue)
+ {
+ pos = i;
+ break;
+ }
+ }
+ return (pos != KErrNotFound);
+}
+
+
+template <class Tkey, class Tvalue>
+inline Tvalue& RMap<Tkey, Tvalue>::GetValueL(const Tkey& aKey) const
+{
+ TInt pos = Find(aKey);
+
+ if (pos == KErrNotFound)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return *(iValues[pos]);
+}
+
+template <class Tkey, class Tvalue>
+inline Tkey& RMap<Tkey, Tvalue>::GetKeyL(const Tvalue& aValue) const
+{
+ TInt pos = KErrNotFound;
+ for (TInt i = 0; i < iValues.Count(); i++)
+ {
+ if (*(iValues[i]) == aValue)
+ {
+ pos = i;
+ break;
+ }
+ }
+
+ if (pos == KErrNotFound)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return *(iKeys[pos]);
+}
+
+
+template <class Tkey, class Tvalue>
+inline void RMap<Tkey, Tvalue>::RemoveL(const Tkey& aKey)
+{
+ TInt pos = Find(aKey);
+ if (pos == KErrNotFound)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ iKeys.Remove(pos);
+ iValues.Remove(pos);
+ iKeys.Compress();
+ iValues.Compress();
+}
+
+template <class Tkey, class Tvalue>
+inline void RMap<Tkey, Tvalue>::RemoveAtL(TInt anIndex, Tkey*& aKey, Tvalue*& aValue)
+{
+ if (anIndex >= iKeys.Count())
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ *aKey = *(iKeys[anIndex]);
+ *aValue = *(iValues[anIndex]);
+
+ iKeys.Remove(anIndex);
+ iValues.Remove(anIndex);
+ iKeys.Compress();
+ iValues.Compress();
+}
+
+template <class Tkey, class Tvalue>
+inline RSafePointerArray<Tkey>& RMap<Tkey, Tvalue>::Keys()
+{
+ return iKeys;
+}
+
+template <class Tkey, class Tvalue>
+inline RSafePointerArray<Tvalue>& RMap<Tkey, Tvalue>::Values()
+{
+ return iValues;
+}
+//key by index
+template <class Tkey, class Tvalue>
+inline Tkey& RMap<Tkey, Tvalue>::KeyAt(TInt anIndex)
+{
+ return *(iKeys[anIndex]);
+}
+
+template <class Tkey, class Tvalue>
+inline const Tkey& RMap<Tkey, Tvalue>::KeyAt(TInt anIndex) const
+{
+ return *(iKeys[anIndex]);
+}
+//value by index
+template <class Tkey, class Tvalue>
+inline Tvalue& RMap<Tkey, Tvalue>::ValueAt(TInt anIndex)
+{
+ return *(iValues[anIndex]);
+}
+
+template <class Tkey, class Tvalue>
+inline const Tvalue& RMap<Tkey, Tvalue>::ValueAt(TInt anIndex) const
+{
+ return *(iValues[anIndex]);
+}
+
+template <class Tkey, class Tvalue>
+inline TInt RMap<Tkey, Tvalue>::Count() const
+{
+ return iKeys.Count();
+}
+
+/*
+//for test purposes
+class RDesMap: public RMap<TDesC, TDesC>
+{
+public:
+ RDesMap(const TLinearOrder<TDesC>& anOrder)
+ :RMap(anOrder)
+ {
+ }
+
+ void ResetAndDestroy()
+ {
+ RMap::ResetAndDestroy();
+ }
+
+ void InsertL(const TDesC* aKey, const TDesC* aValue)
+ {
+ RMap::InsertL(aKey, aValue);
+ }
+
+ const TDesC* InsertReplaceL(const TDesC* aKey, const TDesC* aValue)
+ {
+ return RMap::InsertReplaceL(aKey, aValue);
+ }
+
+ TInt Find(const TDesC& aKey)
+ {
+ return RMap::Find(aKey);
+ }
+
+ TBool ContainsKey(const TDesC& aKey)
+ {
+ return RMap::ContainsKey(aKey);
+ }
+
+ void GetValueL(const TDesC& aKey)
+ {
+ RMap::GetValueL(aKey);
+ }
+
+ void GetKeyL(const TDesC& aValue)
+ {
+ RMap::GetKeyL(aValue);
+ }
+
+ void RemoveL(const TDesC& aKey)
+ {
+ RMap::RemoveL(aKey);
+ }
+
+ RSafePointerArray<TDesC>& Keys()
+ {
+ return RMap::Keys();
+ }
+
+ RSafePointerArray<TDesC>& Values()
+ {
+ return RMap::Values();
+ }
+
+ TDesC& KeyAt(TInt anIndex)
+ {
+ return RMap::KeyAt(anIndex);
+ }
+
+ const TDesC& KeyAt(TInt anIndex) const
+ {
+ return RMap::KeyAt(anIndex);
+ }
+
+ TDesC& ValueAt(TInt anIndex)
+ {
+ return RMap::ValueAt(anIndex);
+ }
+
+ const TDesC& ValueAt(TInt anIndex) const
+ {
+ return RMap::ValueAt(anIndex);
+ }
+
+ TInt Count()
+ {
+ return RMap::Count();
+ }
+
+ static void InsertEntryL(RDesMap& aMap, const TDesC& aKey,const TDesC& aValue)
+ {
+ HBufC* k = HBufC::NewL(aKey.Length());
+ *k = aKey;
+ HBufC* v = HBufC::NewL(aValue.Length());
+ *v = aValue;
+
+ aMap.InsertL(k, v);
+ //MGLOG2(*k, *v);
+ }
+
+ static void InsertEntryReplaceL(RDesMap& aMap, const TDesC& aKey,const TDesC& aValue)
+ {
+ HBufC* k = HBufC::NewL(aKey.Length());
+ *k = aKey;
+ HBufC* v = HBufC::NewL(aValue.Length());
+ *v = aValue;
+
+ const HBufC* result = static_cast<const HBufC*>(aMap.InsertReplaceL(k, v));
+ if (result != v)
+ {
+ //MGLOG2(_L("Deleted"), *result);
+ delete result;
+ }
+
+ //MGLOG2(*k, *v);
+ }
+
+ static void DoTest()
+ {
+ TLinearOrder<TDesC> order(RDesMap::CompareAlphabetDes);
+ RDesMap map(order);
+ InsertEntryL(map, _L("bbb"), _L("My name is Mud"));
+ InsertEntryL(map, _L("aaa"), _L("Hello big brother"));
+ InsertEntryL(map, _L("aaa"), _L("Hello big brother 1"));
+ InsertEntryL(map, _L("ddd"), _L("Ala bala nica"));
+ InsertEntryL(map, _L("aaa"), _L("Hello big brother 2"));
+ InsertEntryL(map, _L("cc"), _L("Ala bala"));
+ InsertEntryL(map, _L("x"), _L("Ala bala nica turska panica"));
+ InsertEntryL(map, _L("fff"), _L("Ala bala nica turska"));
+
+ //MGLOG1(_L("")); //new line
+
+ for (TInt i = 0; i<map.Count(); i++)
+ {
+ //MGLOG2(*(map.Keys()[i]), *(map.Values()[i]));
+ }
+
+ map.ResetAndDestroy();
+
+ //MGLOG1(_L("")); //new line
+ InsertEntryReplaceL(map, _L("bbb"), _L("My name is Mud"));
+ InsertEntryReplaceL(map, _L("aaa"), _L("Hello big brother"));
+ InsertEntryReplaceL(map, _L("aaa"), _L("Hello big brother 1"));
+ InsertEntryReplaceL(map, _L("ddd"), _L("Ala bala nica"));
+ InsertEntryReplaceL(map, _L("aaa"), _L("Hello big brother 2"));
+ InsertEntryReplaceL(map, _L("cc"), _L("Ala bala"));
+ InsertEntryReplaceL(map, _L("x"), _L("Ala bala nica turska panica"));
+ InsertEntryReplaceL(map, _L("fff"), _L("Ala bala nica turska"));
+
+ //MGLOG1(_L("")); //new line
+
+ for (TInt i = 0; i<map.Count(); i++)
+ {
+ //MGLOG2(*(map.Keys()[i]), *(map.Values()[i]));
+ }
+ }
+
+};
+
+
+//for test purposes
+class RIntMap: public RMap<TInt64, TInt64>
+{
+public:
+ RIntMap(const TLinearOrder<TInt64>& anOrder)
+ :RMap(anOrder)
+ {
+ }
+
+ void ResetAndDestroy()
+ {
+ RMap::ResetAndDestroy();
+ }
+
+ void InsertL(const TInt64* aKey, const TInt64* aValue)
+ {
+ RMap::InsertL(aKey, aValue);
+ }
+
+ const TInt64* InsertReplaceL(const TInt64* aKey, const TInt64* aValue)
+ {
+ return RMap::InsertReplaceL(aKey, aValue);
+ }
+
+ TInt Find(const TInt64& aKey)
+ {
+ return RMap::Find(aKey);
+ }
+
+ TBool ContainsKey(const TInt64& aKey)
+ {
+ return RMap::ContainsKey(aKey);
+ }
+
+ TInt64 GetValueL(const TInt64& aKey)
+ {
+ return RMap::GetValueL(aKey);
+ }
+
+ TInt64 GetKeyL(const TInt64& aValue)
+ {
+ return RMap::GetKeyL(aValue);
+ }
+
+ void RemoveL(const TInt64& aKey)
+ {
+ RMap::RemoveL(aKey);
+ }
+
+ RSafePointerArray<TInt64>& Keys()
+ {
+ return RMap::Keys();
+ }
+
+ RSafePointerArray<TInt64>& Values()
+ {
+ return RMap::Values();
+ }
+
+ TInt64& KeyAt(TInt anIndex)
+ {
+ return RMap::KeyAt(anIndex);
+ }
+
+ const TInt64& KeyAt(TInt anIndex) const
+ {
+ return RMap::KeyAt(anIndex);
+ }
+
+ TInt64& ValueAt(TInt anIndex)
+ {
+ return RMap::ValueAt(anIndex);
+ }
+
+ const TInt64& ValueAt(TInt anIndex) const
+ {
+ return RMap::ValueAt(anIndex);
+ }
+
+ TInt Count()
+ {
+ return RMap::Count();
+ }
+
+ static void InsertEntryL(RIntMap& aMap, const TInt aKey,const TInt aValue)
+ {
+ TBuf<16> k;
+ k.Num(aKey);
+
+ TBuf<16> v;
+ v.Num(aValue);
+
+ TInt64* k64 = new TInt64;
+ *k64 = aKey;
+ TInt64* v64 = new TInt64;
+ *v64 = aValue;
+
+ aMap.InsertL(k64, v64);
+ //MGLOG2(k, v);
+ }
+
+ static void InsertEntryReplaceL(RIntMap& aMap, const TInt aKey,const TInt aValue)
+ {
+ TBuf<16> k;
+ k.Num(aKey);
+
+ TBuf<16> v;
+ v.Num(aValue);
+
+ TInt64* k64 = new TInt64;
+ *k64 = aKey;
+ TInt64* v64 = new TInt64;
+ *v64 = aValue;
+
+ const TInt64* result = static_cast<const TInt64*>(aMap.InsertReplaceL(k64, v64));
+ if (result != v64)
+ {
+ //MGLOG2(_L("Deleted"), (*result).GetTInt());
+ delete result;
+ }
+
+ //MGLOG2(k, v);
+ }
+
+ static void DoTest()
+ {
+ TLinearOrder<TInt64> order(RMap::CompareInt);
+ RIntMap map(order);
+ InsertEntryL(map, 2, 325);
+ InsertEntryL(map, 1, 226);
+ InsertEntryL(map, 1, 227);
+ InsertEntryL(map, 4, 6623);
+ InsertEntryL(map, 1, 228);
+ InsertEntryL(map, 3, 6534);
+ InsertEntryL(map, 9, 7443);
+ InsertEntryL(map, 7, 8643);
+
+ //MGLOG1(_L("")); //new line
+
+ for (TInt i = 0; i<map.Count(); i++)
+ {
+ TBuf<16> k;
+ k.Num(*(map.Keys()[i]));
+
+ TBuf<16> v;
+ v.Num(*(map.Values()[i]));
+ //MGLOG2(k, v);
+ }
+
+ map.ResetAndDestroy();
+
+ //MGLOG1(_L("")); //new line
+ InsertEntryReplaceL(map, 2, 325);
+ InsertEntryReplaceL(map, 1, 226);
+ InsertEntryReplaceL(map, 1, 227);
+ InsertEntryReplaceL(map, 4, 6623);
+ InsertEntryReplaceL(map, 1, 228);
+ InsertEntryReplaceL(map, 3, 6534);
+ InsertEntryReplaceL(map, 9, 7443);
+ InsertEntryReplaceL(map, 7, 8643);
+
+ //MGLOG1(_L("")); //new line
+
+ for (TInt i = 0; i<map.Count(); i++)
+ {
+ TBuf<16> k;
+ k.Num(*(map.Keys()[i]));
+
+ TBuf<16> v;
+ v.Num(*(map.Values()[i]));
+ //MGLOG2(k, v);
+ }
+ }
+
+};
+*/