|
1 /* |
|
2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: common query and condition definitions for MdE* |
|
15 */ |
|
16 |
|
17 #include "mdcquery.h" |
|
18 |
|
19 |
|
20 ///////////////////// |
|
21 // TMdCCondition // |
|
22 ///////////////////// |
|
23 |
|
24 EXPORT_C const TMdCCondition& TMdCCondition::GetFromBufferL( |
|
25 CMdCSerializationBuffer& aBuffer ) |
|
26 { |
|
27 const TInt bufferPosition = aBuffer.Position(); |
|
28 TMdCCondition* condition = (TMdCCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
29 return *condition; |
|
30 } |
|
31 |
|
32 |
|
33 ////////////////////////// |
|
34 // TMdCLogicCondition // |
|
35 ////////////////////////// |
|
36 |
|
37 EXPORT_C TMdCLogicCondition::TMdCLogicCondition() : TMdCCondition( EMdCLogicCondition ) |
|
38 { |
|
39 } |
|
40 |
|
41 EXPORT_C void TMdCLogicCondition::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
42 { |
|
43 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
44 } |
|
45 |
|
46 EXPORT_C void TMdCLogicCondition::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
47 { |
|
48 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
49 } |
|
50 |
|
51 EXPORT_C const TMdCLogicCondition& TMdCLogicCondition::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
52 { |
|
53 const TInt bufferPosition = aBuffer.Position(); |
|
54 TMdCLogicCondition* logicCondition = (TMdCLogicCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
55 if (logicCondition->iType != EMdCLogicCondition) |
|
56 { |
|
57 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCLogicCondition!"), KErrCorrupt ) ); |
|
58 |
|
59 User::Leave( KErrCorrupt ); |
|
60 } |
|
61 const TInt size = sizeof(TMdCLogicCondition) % 2 ? sizeof(TMdCLogicCondition)+1 : sizeof(TMdCLogicCondition); |
|
62 aBuffer.PositionL( bufferPosition + size ); |
|
63 return *logicCondition; |
|
64 } |
|
65 |
|
66 |
|
67 /////////////////////////// |
|
68 // TMdCObjectCondition // |
|
69 /////////////////////////// |
|
70 |
|
71 EXPORT_C TMdCObjectCondition::TMdCObjectCondition() : TMdCCondition( EMdCObjectCondition ) |
|
72 { |
|
73 } |
|
74 |
|
75 EXPORT_C void TMdCObjectCondition::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
76 { |
|
77 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
78 } |
|
79 |
|
80 EXPORT_C void TMdCObjectCondition::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
81 { |
|
82 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
83 } |
|
84 |
|
85 EXPORT_C const TMdCObjectCondition& TMdCObjectCondition::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
86 { |
|
87 const TInt bufferPosition = aBuffer.Position(); |
|
88 TMdCObjectCondition* objectCondition = (TMdCObjectCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
89 if (objectCondition->iType != EMdCObjectCondition) |
|
90 { |
|
91 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCObjectCondition!"), KErrCorrupt ) ); |
|
92 |
|
93 User::Leave( KErrCorrupt ); |
|
94 } |
|
95 const TInt size = sizeof(TMdCObjectCondition) % 2 ? sizeof(TMdCObjectCondition)+1 : sizeof(TMdCObjectCondition); |
|
96 aBuffer.PositionL( bufferPosition + size ); |
|
97 return *objectCondition; |
|
98 } |
|
99 |
|
100 |
|
101 ////////////////////////// |
|
102 // TMdCEventCondition // |
|
103 ////////////////////////// |
|
104 |
|
105 EXPORT_C TMdCEventCondition::TMdCEventCondition() : TMdCCondition( EMdCEventCondition ) |
|
106 { |
|
107 } |
|
108 |
|
109 EXPORT_C void TMdCEventCondition::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
110 { |
|
111 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
112 } |
|
113 |
|
114 EXPORT_C void TMdCEventCondition::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
115 { |
|
116 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
117 } |
|
118 |
|
119 EXPORT_C const TMdCEventCondition& TMdCEventCondition::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
120 { |
|
121 const TInt bufferPosition = aBuffer.Position(); |
|
122 TMdCEventCondition* eventCondition = (TMdCEventCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
123 if (eventCondition->iType != EMdCEventCondition) |
|
124 { |
|
125 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCEventCondition!"), KErrCorrupt ) ); |
|
126 |
|
127 User::Leave( KErrCorrupt ); |
|
128 } |
|
129 const TInt size = sizeof(TMdCEventCondition) % 2 ? sizeof(TMdCEventCondition)+1 : sizeof(TMdCEventCondition); |
|
130 aBuffer.PositionL( bufferPosition + size ); |
|
131 return *eventCondition; |
|
132 } |
|
133 |
|
134 |
|
135 ///////////////////////////// |
|
136 // TMdCPropertyCondition // |
|
137 ///////////////////////////// |
|
138 |
|
139 EXPORT_C TMdCPropertyCondition::TMdCPropertyCondition() : TMdCCondition( EMdCPropertyCondition ) |
|
140 { |
|
141 } |
|
142 |
|
143 EXPORT_C void TMdCPropertyCondition::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
144 { |
|
145 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
146 } |
|
147 |
|
148 EXPORT_C void TMdCPropertyCondition::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
149 { |
|
150 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
151 } |
|
152 |
|
153 EXPORT_C const TMdCPropertyCondition& TMdCPropertyCondition::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
154 { |
|
155 const TInt bufferPosition = aBuffer.Position(); |
|
156 TMdCPropertyCondition* propertyCondition = (TMdCPropertyCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
157 if (propertyCondition->iType != EMdCPropertyCondition) |
|
158 { |
|
159 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCPropertyCondition!"), KErrCorrupt ) ); |
|
160 |
|
161 User::Leave( KErrCorrupt ); |
|
162 } |
|
163 const TInt size = sizeof(TMdCPropertyCondition) % 2 ? sizeof(TMdCPropertyCondition)+1 : sizeof(TMdCPropertyCondition); |
|
164 aBuffer.PositionL( bufferPosition + size ); |
|
165 return *propertyCondition; |
|
166 } |
|
167 |
|
168 |
|
169 ///////////////////////////// |
|
170 // TMdCRelationCondition // |
|
171 ///////////////////////////// |
|
172 |
|
173 EXPORT_C TMdCRelationCondition::TMdCRelationCondition() : TMdCCondition( EMdCRelationCondition ) |
|
174 { |
|
175 } |
|
176 |
|
177 EXPORT_C void TMdCRelationCondition::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
178 { |
|
179 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
180 } |
|
181 |
|
182 EXPORT_C void TMdCRelationCondition::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
183 { |
|
184 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
185 } |
|
186 |
|
187 EXPORT_C const TMdCRelationCondition& TMdCRelationCondition::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
188 { |
|
189 const TInt bufferPosition = aBuffer.Position(); |
|
190 TMdCRelationCondition* relationCondition = (TMdCRelationCondition*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
191 if (relationCondition->iType != EMdCRelationCondition) |
|
192 { |
|
193 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCRelationCondition!"), KErrCorrupt ) ); |
|
194 |
|
195 User::Leave( KErrCorrupt ); |
|
196 } |
|
197 const TInt size = sizeof(TMdCRelationCondition) % 2 ? sizeof(TMdCRelationCondition)+1 : sizeof(TMdCRelationCondition); |
|
198 aBuffer.PositionL( bufferPosition + size ); |
|
199 return *relationCondition; |
|
200 } |
|
201 |
|
202 |
|
203 ////////////////////////// |
|
204 // TMdCSearchCriteria // |
|
205 ////////////////////////// |
|
206 |
|
207 EXPORT_C TMdCSearchCriteria::TMdCSearchCriteria() : TMdCSerializationType( EMdCSearchCriteria ) |
|
208 { |
|
209 } |
|
210 |
|
211 EXPORT_C void TMdCSearchCriteria::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
212 { |
|
213 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
214 } |
|
215 |
|
216 EXPORT_C void TMdCSearchCriteria::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
217 { |
|
218 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
219 } |
|
220 |
|
221 EXPORT_C const TMdCSearchCriteria& TMdCSearchCriteria::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
222 { |
|
223 const TInt bufferPosition = aBuffer.Position(); |
|
224 TMdCSearchCriteria* searchCriteria = (TMdCSearchCriteria*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
225 if (searchCriteria->iType != EMdCSearchCriteria) |
|
226 { |
|
227 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCSearchCriteria!"), KErrCorrupt ) ); |
|
228 |
|
229 User::Leave( KErrCorrupt ); |
|
230 } |
|
231 const TInt size = sizeof(TMdCSearchCriteria) % 2 ? sizeof(TMdCSearchCriteria)+1 : sizeof(TMdCSearchCriteria); |
|
232 aBuffer.PositionL( bufferPosition + size ); |
|
233 return *searchCriteria; |
|
234 } |
|
235 |
|
236 ///////////////////// |
|
237 // TMdCOrderRule // |
|
238 ///////////////////// |
|
239 |
|
240 EXPORT_C TMdCOrderRule::TMdCOrderRule() : TMdCSerializationType( EMdCOrderRule ) |
|
241 { |
|
242 } |
|
243 |
|
244 EXPORT_C void TMdCOrderRule::SerializeL(CMdCSerializationBuffer& aBuffer) |
|
245 { |
|
246 TMdCSerializationType::SerializeL( aBuffer, sizeof(*this) ); |
|
247 } |
|
248 |
|
249 EXPORT_C void TMdCOrderRule::DeserializeL(CMdCSerializationBuffer& aBuffer) |
|
250 { |
|
251 TMdCSerializationType::DeserializeL( aBuffer, sizeof(*this) ); |
|
252 } |
|
253 |
|
254 EXPORT_C const TMdCOrderRule& TMdCOrderRule::GetFromBufferL( CMdCSerializationBuffer& aBuffer ) |
|
255 { |
|
256 const TInt bufferPosition = aBuffer.Position(); |
|
257 TMdCOrderRule* orderRule = (TMdCOrderRule*)(aBuffer.Buffer().Ptr() + bufferPosition); |
|
258 if (orderRule->iType != EMdCOrderRule) |
|
259 { |
|
260 __ASSERT_DEBUG( EFalse, User::Panic( _L("No TMdCOrderRule!"), KErrCorrupt ) ); |
|
261 |
|
262 User::Leave( KErrCorrupt ); |
|
263 } |
|
264 const TInt size = sizeof(TMdCOrderRule) % 2 ? sizeof(TMdCOrderRule)+1 : sizeof(TMdCOrderRule); |
|
265 aBuffer.PositionL( bufferPosition + size ); |
|
266 return *orderRule; |
|
267 } |
|
268 |