22 #include <scs/cleanuputils.h>

    23 #include <scs/streamingarray.h>

    24 #include "sifcommon_internal.h"

   796 	

   800 EXPORT_C const RPointerArray<HBufC>& COpaqueNamedParams::StringArrayByNameL(const TDesC& aName) const

   801     {

   802     InternalizeFromExternalBufferL();

   803   

   804     const TInt count = iParams.Count();

   805     TInt i;

   806     for (i=0; i<count; ++i)

   807         {

   808         if (iParams[i]->Type() == MOpaqueParam::EStringArray && iParams[i]->Name().CompareF(aName) == 0)

   809             {

   810             break;

   811             }

   812         }

   813     

   814     if(i == count)

   815         {

   816         User::Leave(KErrNotFound); 

   817         }

   818     CStringArrayItem* stringArray = static_cast<CStringArrayItem*>(iParams[i]);  

   819     return stringArray->StringArrayValue();

   820     }

   821 

   852 EXPORT_C  const RArray<TInt>& COpaqueNamedParams::IntArrayByNameL(const TDesC& aName) const

   853     {  

   854     InternalizeFromExternalBufferL();

   855   

   856     const TInt count = iParams.Count();

   857     TInt i;

   858     for (i=0; i<count; ++i)

   859         {

   860         if (iParams[i]->Type() == MOpaqueParam::EIntegerArray && iParams[i]->Name().CompareF(aName) == 0)

   861             {

   862             break;

   863             }

   864         }

   865     

   866     if(i == count)

   867         {

   868         User::Leave(KErrNotFound); 

   869         }

   870     CIntegerArrayItem* integerArray = static_cast<CIntegerArrayItem*>(iParams[i]);      

   871     return integerArray->IntegerArrayValue();

   872     }

   873 

   900 	

   901 

   902 /*

   903  * SifCommon internal classes

   904  */

   905 

   906 

   907 CItemBase::CItemBase(TType aType):

   908     iType(aType)

   909     {

   910     

   911     }

   912 

   913 CItemBase::TType CItemBase::Type() const

   914     {

   915     return iType;

   916     }

   917 

   918 void CItemBase::SetNameL(const TDesC& aName)

   919     {

   920     delete iName;

   921     iName = aName.AllocL();

   922     }

   923 

   924 

   925 CItemBase::~CItemBase()

   926     {

   927     delete iName;

   928     }

   929 

   930 const HBufC& CItemBase::Name() const

   931     {

   932     return *iName;

   933     }

   934 

   935 void CItemBase::SetValueSize(TInt aSize)

   936     {

   937     iSize = aSize;

   938     }

   939 

   940 TInt CItemBase::ValueSize() const

   941     {

   942     return iSize;

   943     }

   944 

   945 void CItemBase::VerifyExternalizedSizeForParamL(TUint aValueSize) const

   946     {

   947     if(aValueSize > KMaxOpaqueParamsDescriptorSize)

   948         {

   949         User::Leave(KErrOverflow);

   950         }

   951     }

   952 

   953 void CItemBase::ExternalizeL(RWriteStream& aStream) const

   954     {

   955     aStream << Name();

   956     aStream.WriteInt32L(iSize);

   957     }

   958 

   959 void CItemBase::InternalizeL (RReadStream& aStream)

   960     {

   961     delete iName;

   962     iName = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);

   963     iSize = aStream.ReadInt32L();

   964     }

   965     

   966 /*

   967  * CStringItem

   968  */

   969 CStringItem::CStringItem():

   970     CItemBase(EString)

   971     {

   972     

   973     }

   974 

   975 CStringItem* CStringItem::NewL(const TDesC& aName, const TDesC& aValue)

   976     {

   977     CStringItem* self = new(ELeave)CStringItem();

   978     CleanupStack::PushL(self);

   979     self->ConstructL(aName, aValue);

   980     CleanupStack::Pop(self);

   981     return self;

   982     }

   983 

   984 CStringItem* CStringItem::NewL(RReadStream& aStream)

   985     {   

   986     CStringItem *self = new(ELeave)CStringItem();

   987     CleanupStack::PushL(self);

   988     self->InternalizeL(aStream);

   989     CleanupStack::Pop(self);

   990     return self;

   991     }

   992 

   993 void CStringItem::ConstructL(const TDesC& aName, const TDesC& aValue)

   994     {

   995     VerifyExternalizedSizeForParamL(aValue.Size());

   996     SetNameL(aName);

   997     iString = aValue.AllocL();

   998     SetValueSize(iString->Size());

   999     }

  1000 

  1001 CStringItem::~CStringItem()

  1002     {

  1003     delete iString;

  1004     }

  1005 

  1006 void CStringItem::ExternalizeL(RWriteStream& aStream) const

  1007     {

  1008 	CItemBase::ExternalizeL(aStream);

  1009     aStream << *iString;

  1010     }

  1011 

  1012 void CStringItem::InternalizeL(RReadStream& aStream)

  1013     {

  1014     CItemBase::InternalizeL(aStream);

  1015     delete iString;

  1016     iString = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);

  1017     }

  1018 

  1019 const TDesC& CStringItem::StringValue() const

  1020     {

  1021     return *iString;

  1022     }

  1023 

  1024 const HBufC& CStringItem::Name() const

  1025     {

  1026     return CItemBase::Name(); 

  1027     }

  1028 

  1029 MOpaqueParam::TType CStringItem::Type() const

  1030     {

  1031     return CItemBase::Type();

  1032     }

  1033 

  1034 TInt CStringItem::ValueSize() const

  1035     {

  1036     return CItemBase::ValueSize();

  1037     }

  1038 /*

  1039  * CStringArrayItem

  1040  */

  1041 

  1042 CStringArrayItem::CStringArrayItem():

  1043     CItemBase(EStringArray)

  1044     {

  1045     

  1046     }

  1047 

  1048 CStringArrayItem* CStringArrayItem::NewL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)

  1049     {

  1050     CStringArrayItem* self = new(ELeave)CStringArrayItem();

  1051     CleanupStack::PushL(self);

  1052     self->ConstructL(aName, aValueArray);

  1053     CleanupStack::Pop(self);    

  1054     return self;

  1055     }

  1056 

  1057 CStringArrayItem* CStringArrayItem::NewL(RReadStream& aStream)

  1058     {   

  1059     CStringArrayItem *self = new(ELeave)CStringArrayItem();

  1060     CleanupStack::PushL(self);    

  1061     self->InternalizeL(aStream);

  1062     CleanupStack::Pop(self);

  1063     return self;

  1064     }

  1065 

  1066 void CStringArrayItem::ConstructL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)

  1067     {

  1068     SetNameL(aName);

  1069     for(TInt i=0; i< aValueArray.Count(); ++i)

  1070         {

  1071         VerifyExternalizedSizeForParamL(aValueArray[i]->Size());

  1072         HBufC* value = aValueArray[i]->AllocLC();

  1073         iStringArray.AppendL(value);

  1074         SetValueSize(ValueSize()+ value->Size());

  1075         CleanupStack::Pop();

  1076         }

  1077     }

  1078 

  1079 void CStringArrayItem::ExternalizeL(RWriteStream& aStream) const

  1080     {

  1081     CItemBase::ExternalizeL(aStream);

  1082     ExternalizePointersArrayL(iStringArray, aStream);

  1083     }

  1084 

  1085 void CStringArrayItem::InternalizeL(RReadStream& aStream)

  1086     {

  1087     CItemBase::InternalizeL(aStream);

  1088     iStringArray.ResetAndDestroy();

  1089     InternalizePointersArrayL(iStringArray, aStream);

  1090     }

  1091 

  1092 const RPointerArray<HBufC>& CStringArrayItem:: StringArrayValue() const

  1093     {

  1094     return iStringArray;

  1095     }

  1096 

  1097 const HBufC& CStringArrayItem::Name() const

  1098     {

  1099     return CItemBase::Name(); 

  1100     }

  1101 

  1102 MOpaqueParam::TType CStringArrayItem::Type() const

  1103     {

  1104     return CItemBase::Type();

  1105     }

  1106 

  1107 TInt CStringArrayItem::ValueSize() const

  1108     {

  1109     return CItemBase::ValueSize();

  1110     }

  1111 

  1112 CStringArrayItem::~CStringArrayItem()

  1113     {

  1114     iStringArray.ResetAndDestroy();

  1115     }

  1116 

  1117 /*

  1118  * CIntegerItem

  1119  */

  1120 

  1121 CIntegerItem::CIntegerItem(TInt aValue):

  1122     CItemBase(EInteger),

  1123     iInteger(aValue)

  1124     {

  1125     

  1126     }

  1127 

  1128 CIntegerItem* CIntegerItem::NewL(const TDesC& aName, TInt aValue)

  1129     {

  1130     CIntegerItem* self = new(ELeave)CIntegerItem(aValue);

  1131     CleanupStack::PushL(self);

  1132     self->ConstructL(aName);

  1133     CleanupStack::Pop(self);  

  1134     return self;

  1135     }

  1136 

  1137 CIntegerItem* CIntegerItem::NewL(RReadStream& aStream)

  1138     {   

  1139     CIntegerItem *self = new(ELeave)CIntegerItem(0);

  1140     CleanupStack::PushL(self);

  1141     self->InternalizeL(aStream);

  1142     CleanupStack::Pop(self);

  1143     return self;

  1144     }

  1145 

  1146 void CIntegerItem::ConstructL(const TDesC& aName)

  1147     {

  1148     SetNameL(aName);

  1149     SetValueSize(sizeof(TInt));

  1150     }

  1151 

  1152 void CIntegerItem::ExternalizeL(RWriteStream& aStream) const

  1153     {

  1154     CItemBase::ExternalizeL(aStream);

  1155     aStream.WriteInt32L(iInteger);

  1156     }

  1157 

  1158 void CIntegerItem::InternalizeL(RReadStream& aStream)

  1159     {

  1160     CItemBase::InternalizeL(aStream);

  1161     iInteger = aStream.ReadInt32L();

  1162     }

  1163 

  1164 TInt CIntegerItem::IntegerValue() const

  1165     {

  1166     return iInteger;

  1167     }

  1168 

  1169 const HBufC& CIntegerItem::Name() const

  1170     {

  1171     return CItemBase::Name(); 

  1172     }

  1173 

  1174 MOpaqueParam::TType CIntegerItem::Type() const

  1175     {

  1176     return CItemBase::Type();

  1177     }

  1178 

  1179 TInt CIntegerItem::ValueSize() const

  1180     {

  1181     return CItemBase::ValueSize();

  1182     }

  1183 

  1184 CIntegerItem::~CIntegerItem()

  1185     {

  1186     }

  1187 

  1188 /*

  1189  * CIntegerArrayItem

  1190  */

  1191 

  1192 CIntegerArrayItem::CIntegerArrayItem():

  1193     CItemBase(EIntegerArray)

  1194     {

  1195     

  1196     }

  1197 

  1198 CIntegerArrayItem* CIntegerArrayItem::NewL(const TDesC& aName, const RArray<TInt>& aValueArray)

  1199     {

  1200     CIntegerArrayItem* self = new(ELeave)CIntegerArrayItem();

  1201     CleanupStack::PushL(self);

  1202     self->ConstructL(aName, aValueArray);

  1203     CleanupStack::Pop(self);    

  1204     return self;

  1205     }

  1206 

  1207 CIntegerArrayItem* CIntegerArrayItem::NewL(RReadStream& aStream)

  1208     {   

  1209     CIntegerArrayItem *self = new(ELeave)CIntegerArrayItem();

  1210     CleanupStack::PushL(self);    

  1211     self->InternalizeL(aStream);

  1212     CleanupStack::Pop(self);

  1213     return self;

  1214     }

  1215 

  1216 

  1217 void CIntegerArrayItem::ConstructL(const TDesC& aName, const RArray<TInt>& aValueArray)

  1218     {

  1219     SetNameL(aName);

  1220     

  1221     for(TInt i=0; i<aValueArray.Count(); ++i)

  1222         {

  1223         iIntegerArray.AppendL(aValueArray[i]);

  1224         SetValueSize(ValueSize()+sizeof(TInt));

  1225         }

  1226     }

  1227 

  1228 void CIntegerArrayItem::ExternalizeL(RWriteStream& aStream) const

  1229     {

  1230     CItemBase::ExternalizeL(aStream);

  1231     ExternalizeFixedLengthArrayL(iIntegerArray, aStream);

  1232     }

  1233 

  1234 void CIntegerArrayItem::InternalizeL(RReadStream& aStream)

  1235     {

  1236     CItemBase::InternalizeL(aStream);

  1237     iIntegerArray.Reset();

  1238     InternalizeFixedLengthArrayL(iIntegerArray, aStream);

  1239     }

  1240 

  1241 const RArray<TInt>& CIntegerArrayItem::IntegerArrayValue() const

  1242     {

  1243     return iIntegerArray;

  1244     }

  1245 

  1246 const HBufC& CIntegerArrayItem::Name() const

  1247     {

  1248     return CItemBase::Name(); 

  1249     }

  1250 

  1251 MOpaqueParam::TType CIntegerArrayItem::Type() const

  1252     {

  1253     return CItemBase::Type();

  1254     }

  1255 

  1256 TInt CIntegerArrayItem::ValueSize() const

  1257     {

  1258     return CItemBase::ValueSize();

  1259     }

  1260 

  1261 CIntegerArrayItem::~CIntegerArrayItem()

  1262     {

  1263     iIntegerArray.Close();

  1264     }