27 EXPORT_C TMTPTypeGuid::TMTPTypeGuid() |
27 EXPORT_C TMTPTypeGuid::TMTPTypeGuid() |
28 { |
28 { |
29 iData.FillZ(iData.MaxLength()); |
29 iData.FillZ(iData.MaxLength()); |
30 } |
30 } |
31 |
31 |
32 EXPORT_C TMTPTypeGuid::TMTPTypeGuid(const TPtrC8& aData) : |
32 EXPORT_C TMTPTypeGuid::TMTPTypeGuid(const TDesC& aData) |
33 TMTPTypeUint128::TMTPTypeUint128(aData) |
|
34 { |
33 { |
|
34 TGUID guid; |
|
35 if(StrToGUID(aData, guid) != KErrNone) |
|
36 { |
|
37 _LIT(KPainGUID,"TMTPTypeGuid"); |
|
38 User::Panic(KPainGUID, KErrArgument); |
|
39 } |
|
40 |
|
41 memcpy(&iData[0], &guid, KMTPTypeUINT128Size); |
35 } |
42 } |
36 |
|
37 |
43 |
38 EXPORT_C TMTPTypeGuid::TMTPTypeGuid(const TUint64 aData1,const TUint64 aData2) |
44 EXPORT_C TMTPTypeGuid::TMTPTypeGuid(const TUint64 aData1,const TUint64 aData2) |
39 { |
45 { |
40 const TUint KBitsOfByte = 8; |
46 const TUint KBitsOfByte = 8; |
41 const TUint KBitsOfWORD = 16; |
47 const TUint KBitsOfWORD = 16; |
84 } |
90 } |
85 |
91 |
86 memcpy(&iData[0], &guid, KMTPTypeUINT128Size); |
92 memcpy(&iData[0], &guid, KMTPTypeUINT128Size); |
87 } |
93 } |
88 |
94 |
89 EXPORT_C TInt TMTPTypeGuid::SetL(const TDesC& aData) |
95 EXPORT_C void TMTPTypeGuid::SetL(const TDesC& aData) |
90 { |
96 { |
91 TInt ret = KErrNone; |
|
92 TGUID guid; |
97 TGUID guid; |
93 |
98 if(StrToGUID(aData, guid) != KErrNone) |
94 ret = IsGuidFormat(aData); |
99 { |
95 |
100 User::Leave(KErrArgument); |
96 if ( ret != KErrNone ) |
101 } |
97 { |
102 |
98 return ret; |
103 memcpy(&iData[0], &guid, KMTPTypeUINT128Size); |
99 } |
104 } |
100 |
105 |
101 RBuf buf; |
106 EXPORT_C TBool TMTPTypeGuid::IsGuidFormat(const TDesC& aData) |
102 buf.CleanupClosePushL(); |
107 { |
103 buf.Create(aData); |
108 TBool ret = ETrue; |
|
109 |
|
110 //verify GUID style data xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
|
111 TBuf<KGUIDFormatStringLength> buf(aData); |
104 TPtr8 guidPtr = buf.Collapse(); |
112 TPtr8 guidPtr = buf.Collapse(); |
105 TInt length = guidPtr.Length(); |
113 TInt length = guidPtr.Length(); |
106 TInt offset = 0; |
114 const TInt KSeparatorCount = 4; |
107 |
115 TInt separatorcount = 0; |
108 TPtrC8 dataStr1(&guidPtr[offset], 8); |
116 if ( length == KGUIDFormatStringLength ) |
109 TLex8 t1(dataStr1); |
|
110 offset += 9; |
|
111 ret = t1.Val(guid.iUint32, EHex); |
|
112 |
|
113 TPtrC8 dataStr2(&guidPtr[offset], 4); |
|
114 TLex8 t2(dataStr2); |
|
115 offset += 5; |
|
116 ret = t2.Val(guid.iUint16[0], EHex); |
|
117 |
|
118 TPtrC8 dataStr3(&guidPtr[offset], 4); |
|
119 TLex8 t3(dataStr3); |
|
120 offset += 5; |
|
121 ret = t3.Val(guid.iUint16[1], EHex); |
|
122 |
|
123 TInt index = 0; |
|
124 for (TInt i(offset); (i<23); i = i+2) |
|
125 { |
|
126 TPtrC8 dataStr4(&guidPtr[offset], 2); |
|
127 TLex8 t4(dataStr4); |
|
128 offset += 2; |
|
129 ret = t4.Val(guid.iByte[index++], EHex); |
|
130 } |
|
131 offset++; |
|
132 for (TInt i(offset); (i<length); i = i+2) |
|
133 { |
|
134 TPtrC8 dataStr5(&guidPtr[offset], 2); |
|
135 TLex8 t5(dataStr5); |
|
136 offset += 2; |
|
137 ret = t5.Val(guid.iByte[index++], EHex); |
|
138 } |
|
139 |
|
140 memcpy(&iData[0], &guid, KMTPTypeUINT128Size); |
|
141 |
|
142 CleanupStack::PopAndDestroy(&buf); |
|
143 |
|
144 return ret; |
|
145 } |
|
146 |
|
147 TInt TMTPTypeGuid::IsGuidFormat(const TDesC& aData) |
|
148 { |
|
149 TInt ret = KErrNone; |
|
150 |
|
151 //verify GUID style data xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
|
152 RBuf buf; |
|
153 buf.CleanupClosePushL(); |
|
154 buf.Create(aData); |
|
155 TPtr8 guidPtr = buf.Collapse(); |
|
156 TInt length = guidPtr.Length(); |
|
157 |
|
158 if ( length == 36 ) |
|
159 { |
117 { |
160 for ( TInt i=0;i<length;++i) |
118 for ( TInt i=0;i<length;++i) |
161 { |
119 { |
162 TChar c(guidPtr[i]); |
120 TChar c(guidPtr[i]); |
163 if ( !c.IsHexDigit() ) |
121 if ( !c.IsHexDigit() ) |
164 { |
122 { |
165 if ( (guidPtr[i]=='-') && (i==8 || i==13 || i==18 || i==23) ) |
123 if ( (guidPtr[i]=='-') && (i==8 || i==13 || i==18 || i==23) ) |
166 {} |
124 { |
|
125 ++separatorcount; |
|
126 } |
167 else |
127 else |
168 { |
128 { |
169 ret = KErrArgument; |
129 ret = EFalse; |
|
130 break; |
170 } |
131 } |
171 } |
132 } |
172 } |
133 } |
173 } |
134 } |
174 else |
135 else |
175 { |
136 { |
176 ret = KErrArgument; |
137 ret = EFalse; |
177 } |
138 } |
178 CleanupStack::PopAndDestroy(&buf); |
139 |
179 |
140 if((ret) && (KSeparatorCount != separatorcount)) |
|
141 { |
|
142 ret = EFalse; |
|
143 } |
|
144 |
180 return ret; |
145 return ret; |
181 } |
146 } |
182 |
147 |
183 |
148 TInt TMTPTypeGuid::StrToGUID(const TDesC& aData, TGUID& aGUID) const |
184 |
149 { |
185 |
150 TInt ret = KErrNone; |
|
151 if ( !IsGuidFormat(aData) ) |
|
152 { |
|
153 return KErrArgument; |
|
154 } |
|
155 |
|
156 TBuf<KGUIDFormatStringLength> buf(aData); |
|
157 TPtr8 guidPtr = buf.Collapse(); |
|
158 TInt length = guidPtr.Length(); |
|
159 TInt offset = 0; |
|
160 |
|
161 TPtrC8 dataStr(&guidPtr[offset], 8); |
|
162 TLex8 t(dataStr); |
|
163 offset += 9; |
|
164 ret = t.Val(aGUID.iUint32, EHex); |
|
165 if(KErrNone != ret) |
|
166 { |
|
167 return ret; |
|
168 } |
|
169 |
|
170 dataStr.Set(&guidPtr[offset], 4); |
|
171 t.Assign(dataStr); |
|
172 offset += 5; |
|
173 ret = t.Val(aGUID.iUint16[0], EHex); |
|
174 if(KErrNone != ret) |
|
175 { |
|
176 return ret; |
|
177 } |
|
178 |
|
179 dataStr.Set(&guidPtr[offset], 4); |
|
180 t.Assign(dataStr); |
|
181 offset += 5; |
|
182 ret = t.Val(aGUID.iUint16[1], EHex); |
|
183 if(KErrNone != ret) |
|
184 { |
|
185 return ret; |
|
186 } |
|
187 |
|
188 TInt index = 0; |
|
189 for (TInt i(offset); (i<23); i = i+2) |
|
190 { |
|
191 dataStr.Set(&guidPtr[offset], 2); |
|
192 t.Assign(dataStr); |
|
193 offset += 2; |
|
194 ret = t.Val(aGUID.iByte[index++], EHex); |
|
195 if(KErrNone != ret) |
|
196 { |
|
197 return ret; |
|
198 } |
|
199 } |
|
200 |
|
201 offset++; |
|
202 for (TInt i(offset); (i<length); i = i+2) |
|
203 { |
|
204 dataStr.Set(&guidPtr[offset], 2); |
|
205 t.Assign(dataStr); |
|
206 offset += 2; |
|
207 ret = t.Val(aGUID.iByte[index++], EHex); |
|
208 if(KErrNone != ret) |
|
209 { |
|
210 return ret; |
|
211 } |
|
212 } |
|
213 |
|
214 return KErrNone; |
|
215 } |
|
216 |
|
217 EXPORT_C TInt TMTPTypeGuid::ToString( TDes& aRetDes ) const |
|
218 { |
|
219 if(aRetDes.MaxLength() < KGUIDFormatStringLength) |
|
220 return KErrOverflow; |
|
221 |
|
222 if(aRetDes.Length() > 0) |
|
223 aRetDes.Zero(); |
|
224 |
|
225 //xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
|
226 _LIT(KSeparatorChar, "-"); |
|
227 const TGUID* guid = reinterpret_cast< const TGUID*>(&iData[0]); |
|
228 aRetDes.AppendNumFixedWidth(guid->iUint32, EHex, 8); |
|
229 aRetDes.Append(KSeparatorChar); |
|
230 for(TInt i = 0; i < KMTPGUIDUint16Num; i++) |
|
231 { |
|
232 aRetDes.AppendNumFixedWidth(guid->iUint16[i], EHex, 4); |
|
233 aRetDes.Append(KSeparatorChar); |
|
234 } |
|
235 |
|
236 TInt j = 0; |
|
237 for(; j < 2; j++) |
|
238 { |
|
239 aRetDes.AppendNumFixedWidth(guid->iByte[j], EHex, 2); |
|
240 } |
|
241 aRetDes.Append(KSeparatorChar); |
|
242 |
|
243 for(; j < KMTPGUIDUint8Num; j++) |
|
244 { |
|
245 aRetDes.AppendNumFixedWidth(guid->iByte[j], EHex, 2); |
|
246 } |
|
247 |
|
248 return KErrNone; |
|
249 } |