1 /* |
|
2 * Copyright (c) 2008 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: ?Description |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <liwcommon.h> |
|
20 |
|
21 #include "cpserverdef.h" |
|
22 #include "cpublisherregistrymap.h" |
|
23 #include "cpglobals.h" |
|
24 #include "cpdebug.h" |
|
25 #include "cpssqlcommands.h" |
|
26 #include "cpsecuritypolicy.h" |
|
27 |
|
28 // --------------------------------------------------------------------------- |
|
29 // |
|
30 // --------------------------------------------------------------------------- |
|
31 // |
|
32 |
|
33 CPublisherRegistryMap::CPublisherRegistryMap() |
|
34 { |
|
35 |
|
36 } |
|
37 |
|
38 // --------------------------------------------------------------------------- |
|
39 // |
|
40 // --------------------------------------------------------------------------- |
|
41 // |
|
42 void CPublisherRegistryMap::ConstructL() |
|
43 { |
|
44 CCPLiwMap::ConstructL( ); |
|
45 } |
|
46 |
|
47 // --------------------------------------------------------------------------- |
|
48 // |
|
49 // --------------------------------------------------------------------------- |
|
50 // |
|
51 EXPORT_C CPublisherRegistryMap* CPublisherRegistryMap::NewL( ) |
|
52 { |
|
53 CPublisherRegistryMap* self = CPublisherRegistryMap::NewLC( ); |
|
54 CleanupStack::Pop( self ); |
|
55 return self; |
|
56 } |
|
57 |
|
58 // --------------------------------------------------------------------------- |
|
59 // |
|
60 // --------------------------------------------------------------------------- |
|
61 // |
|
62 EXPORT_C CPublisherRegistryMap* CPublisherRegistryMap::NewLC( ) |
|
63 { |
|
64 CPublisherRegistryMap* self = new (ELeave) CPublisherRegistryMap(); |
|
65 self->PushL(); |
|
66 self->ConstructL( ); |
|
67 return self; |
|
68 } |
|
69 |
|
70 // --------------------------------------------------------------------------- |
|
71 // |
|
72 // --------------------------------------------------------------------------- |
|
73 // |
|
74 CPublisherRegistryMap::~CPublisherRegistryMap() |
|
75 { |
|
76 } |
|
77 |
|
78 // --------------------------------------------------------------------------- |
|
79 // |
|
80 // --------------------------------------------------------------------------- |
|
81 // |
|
82 TInt32 CPublisherRegistryMap::AddL( RSqlDatabase aSqlDb, |
|
83 CLiwDefaultList* aNotificationList ) const |
|
84 { |
|
85 CP_DEBUG( _L8("CPublisherRegistryMap::AddL") ); |
|
86 TInt32 id( 0); |
|
87 if ( !GetProperty( KId, id ) ) |
|
88 { |
|
89 FetchIdL( aSqlDb, KSQLFetchIdFromRegistry, id ); |
|
90 } |
|
91 if ( id ) |
|
92 { |
|
93 UpdateL( aSqlDb, id , aNotificationList ); |
|
94 } |
|
95 else |
|
96 { |
|
97 id = AddToDbL( aSqlDb , aNotificationList ); |
|
98 } |
|
99 return id; |
|
100 |
|
101 } |
|
102 |
|
103 // --------------------------------------------------------------------------- |
|
104 // |
|
105 // --------------------------------------------------------------------------- |
|
106 // |
|
107 TUint CPublisherRegistryMap::GetListL( RSqlDatabase aSqlDb, |
|
108 CLiwGenericParamList* aList, RArray<TInt32>& aItemsToDelete ) const |
|
109 { |
|
110 CP_DEBUG( _L8("CPublisherRegistryMap::GetListL") ); |
|
111 aItemsToDelete.Reset( ); //no items to delete |
|
112 return CCPLiwMap::GetListL( aSqlDb, KSQLGetListFromRegistry, aList, |
|
113 aItemsToDelete ); |
|
114 } |
|
115 |
|
116 // --------------------------------------------------------------------------- |
|
117 // |
|
118 // --------------------------------------------------------------------------- |
|
119 // |
|
120 void CPublisherRegistryMap::RemoveL( RSqlDatabase aSqlDb, |
|
121 CLiwDefaultList* aNotificationList ) const |
|
122 { |
|
123 CP_DEBUG( _L8("CContentMap::RemoveL") ); |
|
124 //get ids of items to be deleted |
|
125 GetIdsOfRemovedEntriesL( aSqlDb, KSQLGetIdsRegistry, aNotificationList ); |
|
126 CCPLiwMap::RemoveL( aSqlDb, KSQLDeleteFromRegistry ); |
|
127 } |
|
128 |
|
129 // --------------------------------------------------------------------------- |
|
130 // |
|
131 // --------------------------------------------------------------------------- |
|
132 // |
|
133 void CPublisherRegistryMap::SaveQueryResultsL( RSqlStatement& aStmt, |
|
134 CLiwGenericParamList& aList, RArray<TInt32>& /*aItemsToDelete*/) const |
|
135 { |
|
136 CP_DEBUG( _L8("CPublisherRegistryMap::SaveQueryResultsL") ); |
|
137 TInt idIndex = ColumnIndexL( aStmt, KColumnId ); |
|
138 TInt publisherIndex = ColumnIndexL( aStmt, KColumnPublisher ); |
|
139 TInt contentIndex = ColumnIndexL( aStmt, KColumnContent_type ); |
|
140 TInt content_idIndex = ColumnIndexL( aStmt, KColumnContent_id ); |
|
141 TInt flagIndex = ColumnIndexL( aStmt, KColumnFlag ); |
|
142 TInt acl_Index = ColumnIndexL( aStmt, KColumnAccessList ); |
|
143 TInt data_Index = ColumnIndexL( aStmt, KColumnData ); |
|
144 TInt action_Index = ColumnIndexL( aStmt, KColumnAction ); |
|
145 |
|
146 TBool aclCheckFailed( EFalse ); |
|
147 while ( aStmt.Next( ) == KSqlAtRow ) |
|
148 { |
|
149 TBool securityOk(EFalse); |
|
150 if( iPolicy ) |
|
151 { |
|
152 TPtrC8 acl; |
|
153 User::LeaveIfError( aStmt.ColumnBinary( acl_Index, acl ) ); |
|
154 securityOk = iPolicy->CheckSecurityL( acl , |
|
155 CCPSecurityPolicy::ERead ); |
|
156 if ( !securityOk ) |
|
157 { |
|
158 aclCheckFailed = ETrue; |
|
159 } |
|
160 } |
|
161 |
|
162 if( !iPolicy || securityOk ) |
|
163 { |
|
164 TInt32 id = aStmt.ColumnInt( idIndex ) ; |
|
165 TPtrC publisher; |
|
166 User::LeaveIfError( aStmt.ColumnText( publisherIndex, |
|
167 publisher ) ); |
|
168 TPtrC content_type; |
|
169 User::LeaveIfError( aStmt.ColumnText( contentIndex, |
|
170 content_type ) ); |
|
171 TPtrC content_id; |
|
172 User::LeaveIfError( aStmt.ColumnText( content_idIndex, |
|
173 content_id )); |
|
174 TInt32 flag_db = aStmt.ColumnInt( flagIndex ); |
|
175 TInt32 flag_map(0); |
|
176 |
|
177 TUint filter = GetFilterL(); |
|
178 GetProperty( KFlag, flag_map ); |
|
179 |
|
180 if (!(filter & EFlag) || ( (flag_db & flag_map)==flag_map)) |
|
181 { |
|
182 CLiwDefaultMap* targetMap = CLiwDefaultMap::NewLC(); |
|
183 targetMap->InsertL( KId , TLiwVariant( id ) ); |
|
184 targetMap->InsertL( KPublisherId , TLiwVariant( publisher ) ); |
|
185 targetMap->InsertL( KContentType , TLiwVariant( content_type ) ); |
|
186 targetMap->InsertL( KContentId , TLiwVariant( content_id ) ); |
|
187 targetMap->InsertL( KFlag , TLiwVariant( flag_db ) ); |
|
188 TPtrC8 data; |
|
189 User::LeaveIfError( aStmt.ColumnBinary( data_Index, data ) ); |
|
190 TPtrC8 action; |
|
191 User::LeaveIfError( aStmt.ColumnBinary( action_Index, action ) ); |
|
192 if( data.Ptr() ) |
|
193 { |
|
194 targetMap->InsertL( KDataMap , TLiwVariant( data ) ); |
|
195 } |
|
196 if( action.Ptr() ) |
|
197 { |
|
198 targetMap->InsertL( KActionMap , TLiwVariant( action ) ); |
|
199 } |
|
200 TLiwGenericParam result( KListMap, TLiwVariant( targetMap )); |
|
201 aList.AppendL( result ); |
|
202 CleanupStack::PopAndDestroy( targetMap ); |
|
203 } |
|
204 }//if |
|
205 }//while |
|
206 //leave only if ACL security check for all items failed |
|
207 if ( aclCheckFailed && !aList.Count()) |
|
208 { |
|
209 User::Leave( KErrPermissionDenied ); |
|
210 } |
|
211 } |
|
212 |
|
213 |
|
214 // --------------------------------------------------------------------------- |
|
215 // |
|
216 // --------------------------------------------------------------------------- |
|
217 // |
|
218 TInt32 CPublisherRegistryMap::AddToDbL( RSqlDatabase aSqlDb, |
|
219 CLiwDefaultList* aNotificationList ) const |
|
220 { |
|
221 CP_DEBUG( _L8("CPublisherRegistryMap::AddToDbL") ); |
|
222 RSqlStatement stmt; |
|
223 CleanupClosePushL( stmt ); |
|
224 PrepareStmtforAddL( aSqlDb, stmt, KSQLInsertToRegistry ); |
|
225 |
|
226 TInt dataIndex = stmt.ParameterIndex( KSQLData ); |
|
227 TInt actionIndex = stmt.ParameterIndex( KSQLAction ); |
|
228 TInt aclIndex = stmt.ParameterIndex( KSQLAccessList ); |
|
229 |
|
230 RBuf8 data; |
|
231 data.CleanupClosePushL(); |
|
232 GetPropertyL( KDataMap, data ) ; |
|
233 BindBinaryL( stmt, dataIndex, data ); |
|
234 RBuf8 action; |
|
235 action.CleanupClosePushL(); |
|
236 GetPropertyL( KActionMap, action ) ; |
|
237 BindBinaryL( stmt, actionIndex, action ); |
|
238 |
|
239 RBuf8 acl; |
|
240 acl.CleanupClosePushL(); |
|
241 if( !GetPropertyL( KAccessList , acl ) ) |
|
242 { |
|
243 iPolicy->GetDefaultSecurityL( acl ); |
|
244 } |
|
245 BindBinaryL( stmt, aclIndex, acl ); |
|
246 |
|
247 if ( stmt.Exec( ) <= 0 ) |
|
248 { |
|
249 User::Leave( KErrGeneral ); |
|
250 } |
|
251 |
|
252 TSqlScalarFullSelectQuery id_query(aSqlDb); |
|
253 TInt32 ret( 0); |
|
254 ret = id_query.SelectIntL( KSQLGetLastInsertId ); |
|
255 |
|
256 if ( aNotificationList ) |
|
257 { |
|
258 RBuf publisher; |
|
259 publisher.CleanupClosePushL(); |
|
260 RBuf contentType; |
|
261 contentType.CleanupClosePushL(); |
|
262 RBuf contentId; |
|
263 contentId.CleanupClosePushL(); |
|
264 GetPropertyL( KPublisherId, publisher ) ; |
|
265 GetPropertyL( KContentType, contentType ); |
|
266 GetPropertyL( KContentId, contentId ); |
|
267 CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( ); |
|
268 changeInfoMap->InsertL( KId, TLiwVariant( ret ) ); |
|
269 changeInfoMap->InsertL( KType, TLiwVariant( KPublisher ) ); |
|
270 changeInfoMap->InsertL( KPublisherId, TLiwVariant( publisher ) ); |
|
271 changeInfoMap->InsertL( KContentType, TLiwVariant( contentType ) ); |
|
272 changeInfoMap->InsertL( KContentId, TLiwVariant( contentId ) ); |
|
273 changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationAdd ) ); |
|
274 TInt32 flag( 0 ); |
|
275 GetProperty( KFlag, flag ); |
|
276 changeInfoMap->InsertL( KFlag, TLiwVariant( flag ) ); |
|
277 aNotificationList->AppendL( TLiwVariant( changeInfoMap ) ); |
|
278 CleanupStack::PopAndDestroy( changeInfoMap ) ; |
|
279 CleanupStack::PopAndDestroy( &contentId ) ; |
|
280 CleanupStack::PopAndDestroy( &contentType ) ; |
|
281 CleanupStack::PopAndDestroy( &publisher ) ; |
|
282 } |
|
283 |
|
284 CleanupStack::PopAndDestroy( &acl ); |
|
285 CleanupStack::PopAndDestroy( &action ); |
|
286 CleanupStack::PopAndDestroy( &data ); |
|
287 CleanupStack::PopAndDestroy( &stmt ) ; |
|
288 |
|
289 return ret; |
|
290 } |
|
291 |
|
292 // --------------------------------------------------------------------------- |
|
293 // |
|
294 // --------------------------------------------------------------------------- |
|
295 // |
|
296 void CPublisherRegistryMap::AppendFilterL( RBuf& aQuery, |
|
297 TUint& aFilter ) const |
|
298 { |
|
299 CP_DEBUG( _L8("CPublisherRegistryMap::AppendFilterL") ); |
|
300 if( aFilter & EFlag ) |
|
301 { |
|
302 aQuery.ReAllocL( aQuery.Length() + KSQLGetFlag().Length() + |
|
303 KWhere().Length() ); |
|
304 aQuery.Append( KWhere ); |
|
305 aQuery.Append( KSQLGetFlag ); |
|
306 } |
|
307 else |
|
308 { |
|
309 CCPLiwMap::AppendFilterL( aQuery, aFilter ); |
|
310 } |
|
311 } |
|
312 |
|
313 // --------------------------------------------------------------------------- |
|
314 // |
|
315 // --------------------------------------------------------------------------- |
|
316 // |
|
317 void CPublisherRegistryMap::AppendSortL( RBuf& aQuery, |
|
318 const TCPSortOrder& aSort ) const |
|
319 { |
|
320 CP_DEBUG( _L8("CPublisherRegistryMap::AppendSortL") ); |
|
321 switch ( aSort ) |
|
322 { |
|
323 case ECPContentId: |
|
324 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderContentId().Length( ) ); |
|
325 aQuery.Append( KSQLOrderContentId ); |
|
326 break; |
|
327 case ECPContent: |
|
328 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderContent().Length( ) ); |
|
329 aQuery.Append( KSQLOrderContent ); |
|
330 break; |
|
331 case ECPPublisher: |
|
332 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderPublisher().Length( ) ); |
|
333 aQuery.Append( KSQLOrderPublisher ); |
|
334 break; |
|
335 default: |
|
336 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderRecent().Length( ) ); |
|
337 aQuery.Append( KSQLOrderRecent ); |
|
338 break; |
|
339 } |
|
340 } |
|
341 |
|
342 // --------------------------------------------------------------------------- |
|
343 // |
|
344 // --------------------------------------------------------------------------- |
|
345 // |
|
346 void CPublisherRegistryMap::PrepareStmtforAddL( RSqlDatabase aSqlDb, |
|
347 RSqlStatement& aStmt , |
|
348 const TDesC& aQuery ) const |
|
349 { |
|
350 CP_DEBUG( _L8("CPublisherRegistryMap::PrepareStmtforAddL") ); |
|
351 CCPLiwMap::PrepareStmtforAddL( aSqlDb,aStmt,aQuery); |
|
352 TInt32 flag( 0x00000000 ); |
|
353 GetProperty( KFlag, flag ); |
|
354 TInt flagIndex = aStmt.ParameterIndex( KSQLFlag ); |
|
355 if (flagIndex != KErrNotFound) |
|
356 { |
|
357 BindIntL( aStmt, flagIndex , flag ); |
|
358 } |
|
359 } |
|
360 |
|
361 // --------------------------------------------------------------------------- |
|
362 // |
|
363 // --------------------------------------------------------------------------- |
|
364 // |
|
365 void CPublisherRegistryMap::PrepareStmtforUpdateL( RSqlDatabase aSqlDb, |
|
366 RSqlStatement& aStmt, TInt32 aId ) const |
|
367 { |
|
368 CP_DEBUG( _L8("CPublisherRegistryMap::PrepareStmtforUpdateL") ); |
|
369 TInt32 flag; |
|
370 TBool isFlagInfo = GetProperty( KFlag, flag ); |
|
371 |
|
372 TBool isParameter(EFalse); |
|
373 RBuf query; |
|
374 query.CleanupClosePushL(); |
|
375 query.CreateL( KSQLUpdateRegistry().Length( ) ); |
|
376 query.Append( KSQLUpdateRegistry ); |
|
377 RBuf8 data; |
|
378 data.CleanupClosePushL(); |
|
379 if ( GetPropertyL( KDataMap, data ) ) |
|
380 { |
|
381 query.ReAllocL( query.Length( ) + KSQLUpdateData().Length( ) ); |
|
382 query.Append( KSQLUpdateData ); |
|
383 isParameter = ETrue; |
|
384 } |
|
385 RBuf8 action; |
|
386 action.CleanupClosePushL(); |
|
387 if ( GetPropertyL( KActionMap, action ) ) |
|
388 { |
|
389 if ( isParameter ) |
|
390 { |
|
391 query.ReAllocL( query.Length( ) + KComma().Length( ) ); |
|
392 query.Append( KComma ); |
|
393 } |
|
394 query.ReAllocL( query.Length( ) + KSQLUpdateAction().Length( ) ); |
|
395 query.Append( KSQLUpdateAction ); |
|
396 isParameter = ETrue; |
|
397 } |
|
398 if( isFlagInfo ) |
|
399 { |
|
400 if(isParameter) |
|
401 { |
|
402 query.ReAllocL( query.Length() + KComma().Length()); |
|
403 query.Append( KComma ); |
|
404 } |
|
405 query.ReAllocL( query.Length() + KSQLUpdateFlag().Length()); |
|
406 query.Append( KSQLUpdateFlag ); |
|
407 isParameter = ETrue; |
|
408 } |
|
409 if( !isParameter ) User::Leave( KErrPathNotFound ); |
|
410 query.ReAllocL( query.Length( ) + KSQLUpdateWhere().Length( ) ); |
|
411 query.Append( KSQLUpdateWhere ); |
|
412 User::LeaveIfError( aStmt.Prepare( aSqlDb, query ) ); |
|
413 TInt dataId = aStmt.ParameterIndex( KSQLId ); |
|
414 BindIntL( aStmt, dataId, aId ); |
|
415 |
|
416 if ( data.Length( ) ) |
|
417 { |
|
418 TInt dataIndex = aStmt.ParameterIndex( KSQLData ); |
|
419 BindBinaryL( aStmt,dataIndex, data ); |
|
420 } |
|
421 if ( action.Length( ) ) |
|
422 { |
|
423 TInt actionIndex = aStmt.ParameterIndex( KSQLAction ); |
|
424 BindBinaryL( aStmt, actionIndex, action ); |
|
425 } |
|
426 if( isFlagInfo ) |
|
427 { |
|
428 TInt flagIndex = aStmt.ParameterIndex( KSQLFlag ); |
|
429 BindIntL( aStmt, flagIndex , flag ); |
|
430 } |
|
431 CleanupStack::PopAndDestroy( &action ); |
|
432 CleanupStack::PopAndDestroy( &data ); |
|
433 CleanupStack::PopAndDestroy( &query ); |
|
434 } |
|
435 |
|
436 // --------------------------------------------------------------------------- |
|
437 // |
|
438 // --------------------------------------------------------------------------- |
|
439 // |
|
440 void CPublisherRegistryMap::UpdateL( RSqlDatabase aSqlDb, TInt32 aId, |
|
441 CLiwDefaultList* aNotificationList) const |
|
442 { |
|
443 CP_DEBUG( _L8("CPublisherRegistryMap::UpdateL") ); |
|
444 RSqlStatement stmt; |
|
445 CleanupClosePushL( stmt ); |
|
446 CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( ); |
|
447 FetchIdsL( aId, KSQLFetchIdsFromRegistry, changeInfoMap, aSqlDb ); |
|
448 if ( aNotificationList ) |
|
449 { |
|
450 changeInfoMap->InsertL( KType, TLiwVariant( KPublisher ) ); |
|
451 TInt32 flag( 0 ); |
|
452 GetProperty( KFlag, flag ); |
|
453 changeInfoMap->InsertL( KFlag, TLiwVariant( flag ) ); |
|
454 aNotificationList->AppendL( TLiwVariant( changeInfoMap ) ); |
|
455 } |
|
456 CleanupStack::PopAndDestroy( changeInfoMap ) ; |
|
457 PrepareStmtforUpdateL( aSqlDb, stmt, aId ); |
|
458 if ( stmt.Exec( ) <= 0 ) |
|
459 { |
|
460 User::Leave( KErrNotFound ); |
|
461 } |
|
462 CleanupStack::PopAndDestroy( &stmt ) ; |
|
463 } |
|
464 |
|
465 // --------------------------------------------------------------------------- |
|
466 // |
|
467 // --------------------------------------------------------------------------- |
|
468 // |
|
469 void CPublisherRegistryMap::IsValidForDeleteL() const |
|
470 { |
|
471 TInt err( KErrNone ); |
|
472 TInt32 id( 0 ); |
|
473 if( GetProperty( KId, id ) && ( id < 1 ) ) |
|
474 { |
|
475 err = KErrArgument; |
|
476 } |
|
477 else if( !IsId() && PropertyExists( KId ) ) |
|
478 { |
|
479 err = KErrBadName; |
|
480 } |
|
481 |
|
482 if( err == KErrNone && !IsFlag() && !IsId( ) && !( IsPublisherNameL( ) |
|
483 || IsContentTypeL( ) || IsContentIdL() ) ) |
|
484 { |
|
485 err = KErrPathNotFound; |
|
486 } |
|
487 |
|
488 if( err != KErrNone ) |
|
489 { |
|
490 User::Leave( err ); |
|
491 } |
|
492 } |
|
493 |
|
494 // --------------------------------------------------------------------------- |
|
495 // |
|
496 // --------------------------------------------------------------------------- |
|
497 // |
|
498 void CPublisherRegistryMap::IsValidForGetListL() const |
|
499 { |
|
500 TInt err( KErrNone ); |
|
501 TInt32 id( 0 ); |
|
502 if( GetProperty( KId, id ) && ( id < 1 ) ) |
|
503 { |
|
504 err = KErrArgument; |
|
505 } |
|
506 else if( !IsId() && PropertyExists( KId ) ) |
|
507 { |
|
508 err = KErrBadName; |
|
509 } |
|
510 |
|
511 if( err != KErrNone ) |
|
512 { |
|
513 User::Leave( err ); |
|
514 } |
|
515 } |
|
516 // --------------------------------------------------------------------------- |
|
517 // |
|
518 // --------------------------------------------------------------------------- |
|
519 // |
|
520 TBool CPublisherRegistryMap::ActivateActionSupport( ) const |
|
521 { |
|
522 return ETrue; |
|
523 } |
|
524 |
|
525 // --------------------------------------------------------------------------- |
|
526 // |
|
527 // --------------------------------------------------------------------------- |
|
528 // |
|
529 TBool CPublisherRegistryMap::GetActivateInfo( ) const |
|
530 { |
|
531 TInt32 flag; |
|
532 GetProperty( KFlag, flag ); |
|
533 TBool activate = flag & EActivate; |
|
534 return activate; |
|
535 } |
|
536 |
|
537 |
|
538 // --------------------------------------------------------------------------- |
|
539 // |
|
540 // --------------------------------------------------------------------------- |
|
541 // |
|
542 void CPublisherRegistryMap::FillChangeInfoMapL( RSqlStatement& aStmt, |
|
543 CLiwDefaultMap* aMap )const |
|
544 { |
|
545 CCPLiwMap::FillChangeInfoMapL(aStmt, aMap); |
|
546 TInt flagIndex = ColumnIndexL( aStmt, KColumnFlag ); |
|
547 TInt32 flag_db = aStmt.ColumnInt( flagIndex ); |
|
548 aMap->InsertL( KFlag , TLiwVariant( flag_db ) ); |
|
549 } |
|
550 |
|