1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // LOGSERVEROPERATIONS.H

    15 // 

    16 //

    17 

    18 #ifndef __LOGSERVEROPERATIONS_H__

    19 #define __LOGSERVEROPERATIONS_H__

    20 

    21 #include "LogServOperationBase.h"

    22 

    23 // Classes referenced

    24 class CLogEvent;

    25 class CLogServViewBase;

    26 class CLogServViewRecent;

    27 

    28 /**

    29 CLogServOperationBase derived class that initiates the "add event" operation.  

    30  

    31 @see CLogServOperationBase

    32 @see CLogAddEvent

    33 @internalComponent

    34 */

    35 class CLogServOpEventAdd : public CLogServOperationBase

    36 	{

    37 public:

    38 	CLogServOpEventAdd(MLogServTaskInterface& aTaskInterface, 

    39 					   MLogServOperationManager& aOperationManager, 

    40 					   const RMessage2& aMessage, 

    41 					   CLogPackage& aPackage,

    42 					   const TLogClientServerData& aCliServData,

    43 					   TLogServSessionId aSessionId);

    44 	~CLogServOpEventAdd();

    45 	void StartL(TRequestStatus& aStatus);

    46 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

    47 	void WriteL(const RMessage2& aMessage);

    48 	//

    49 private:

    50 	CLogEvent* iEvent;

    51 	};

    52 

    53 /**

    54 CLogServOperationBase derived class that initiates the "change event" operation.  

    55  

    56 @see CLogServOperationBase

    57 @see CLogChangeEvent

    58 @internalComponent

    59 */

    60 class CLogServOpEventChange : public CLogServOperationBase

    61 	{

    62 public:

    63 	CLogServOpEventChange(MLogServTaskInterface& aTaskInterface, 

    64 						  MLogServOperationManager& aOperationManager, 

    65 						  const RMessage2& aMessage, 

    66 						  CLogPackage& aPackage,

    67 						  const TLogClientServerData& aCliServData,

    68 						  TLogServSessionId aSessionId);

    69 	~CLogServOpEventChange();

    70 	void StartL(TRequestStatus& aStatus);

    71 	//

    72 private:

    73 	CLogEvent* iEvent;

    74 	};

    75 

    76 /**

    77 CLogServOperationBase derived class that initiates the "get event" operation.  

    78  

    79 @see CLogServOperationBase

    80 @see CLogGetEvent

    81 @internalComponent

    82 */

    83 class CLogServOpEventGet : public CLogServOperationBase

    84 	{

    85 public:

    86 	CLogServOpEventGet(MLogServTaskInterface& aTaskInterface, 

    87 					   MLogServOperationManager& aOperationManager, 

    88 					   const RMessage2& aMessage, 

    89 					   CLogPackage& aPackage,

    90 					   const TLogClientServerData& aCliServData,

    91 					   TLogServSessionId aSessionId);

    92 	~CLogServOpEventGet();

    93 	void StartL(TRequestStatus& aStatus);

    94 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

    95 	void WriteL(const RMessage2& aMessage);

    96 	//

    97 private:

    98 	CLogEvent* iEvent;

    99 	};

   100 

   101 /**

   102 CLogServOperationBase derived class that initiates the "delete event" operation.  

   103  

   104 @see CLogServOperationBase

   105 @see CLogDeleteEvent

   106 @internalComponent

   107 */

   108 class CLogServOpEventDelete : public CLogServOperationBase

   109 	{

   110 public:

   111 	CLogServOpEventDelete(MLogServTaskInterface& aTaskInterface, 

   112 						  MLogServOperationManager& aOperationManager, 

   113 						  const RMessage2& aMessage, 

   114 						  CLogPackage& aPackage,

   115 						  const TLogClientServerData& aCliServData,

   116 						  TLogServSessionId aSessionId);

   117 	void StartL(TRequestStatus& aStatus);

   118 	};

   119 

   120 /**

   121 CLogServOperationBase derived class that initiates the "add event type" operation.  

   122  

   123 @see CLogServOperationBase

   124 @see CLogServCacheTypes

   125 @internalComponent

   126 */

   127 class CLogServOpTypeAdd : public CLogServOperationBase

   128 	{

   129 public:

   130 	CLogServOpTypeAdd(MLogServTaskInterface& aTaskInterface, 

   131 					  MLogServOperationManager& aOperationManager, 

   132 					  const RMessage2& aMessage, 

   133 					  CLogPackage& aPackage,

   134 					  const TLogClientServerData& aCliServData,

   135 					  TLogServSessionId aSessionId);

   136 	~CLogServOpTypeAdd();

   137 	void StartL(TRequestStatus& aStatus);

   138 	//

   139 private:

   140 	CLogEventType* iEventType;

   141 	};

   142 

   143 /**

   144 CLogServOperationBase derived class that initiates the "get event type" operation.  

   145  

   146 @see CLogServOperationBase

   147 @see CLogServCacheTypes

   148 @internalComponent

   149 */

   150 class CLogServOpTypeGet : public CLogServOperationBase

   151 	{

   152 public:

   153 	CLogServOpTypeGet(MLogServTaskInterface& aTaskInterface, 

   154 					  MLogServOperationManager& aOperationManager, 

   155 					  const RMessage2& aMessage, 

   156 					  CLogPackage& aPackage,

   157 					  const TLogClientServerData& aCliServData,

   158 					  TLogServSessionId aSessionId);

   159 	void StartL(TRequestStatus& aStatus);

   160 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

   161 	void WriteL(const RMessage2& aMessage);

   162 	//

   163 private:

   164 	CLogEventType* iEventType;

   165 	};

   166 

   167 /**

   168 CLogServOperationBase derived class that initiates the "change event type" operation.  

   169  

   170 @see CLogServOperationBase

   171 @see CLogServCacheTypes

   172 @internalComponent

   173 */

   174 class CLogServOpTypeChange : public CLogServOperationBase

   175 	{

   176 public:

   177 	CLogServOpTypeChange(MLogServTaskInterface& aTaskInterface, 

   178 						 MLogServOperationManager& aOperationManager, 

   179 						 const RMessage2& aMessage, 

   180 						 CLogPackage& aPackage,

   181 						  const TLogClientServerData& aCliServData,

   182 						  TLogServSessionId aSessionId);

   183 	~CLogServOpTypeChange();

   184 	void StartL(TRequestStatus& aStatus);

   185 	//

   186 private:

   187 	CLogEventType* iEventType;

   188 	};

   189 

   190 /**

   191 CLogServOperationBase derived class that initiates the "delete event type" operation.  

   192  

   193 @see CLogServOperationBase

   194 @see CLogServCacheTypes

   195 @internalComponent

   196 */

   197 class CLogServOpTypeDelete : public CLogServOperationBase

   198 	{

   199 public:

   200 	CLogServOpTypeDelete(MLogServTaskInterface& aTaskInterface, 

   201 						 MLogServOperationManager& aOperationManager, 

   202 						 const RMessage2& aMessage, 

   203 						 CLogPackage& aPackage,

   204 						  const TLogClientServerData& aCliServData,

   205 						  TLogServSessionId aSessionId);

   206 	void StartL(TRequestStatus& aStatus);

   207 	};

   208 

   209 /**

   210 CLogServOperationBase derived class that initiates the "get config" operation.  

   211  

   212 @see CLogServOperationBase

   213 @see CLogServCacheConfig

   214 @internalComponent

   215 */

   216 class CLogServOpConfigGet : public CLogServOperationBase

   217 	{

   218 public:

   219 	CLogServOpConfigGet(MLogServTaskInterface& aTaskInterface, 

   220 						MLogServOperationManager& aOperationManager, 

   221 						const RMessage2& aMessage, 

   222 						CLogPackage& aPackage,

   223 						  const TLogClientServerData& aCliServData,

   224 						  TLogServSessionId aSessionId);

   225 	void StartL(TRequestStatus& aStatus);

   226 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

   227 	void WriteL(const RMessage2& aMessage);

   228 

   229 	//

   230 private:

   231 	TLogConfig iConfig;

   232 	};

   233 

   234 /**

   235 CLogServOperationBase derived class that initiates the "change config" operation.  

   236  

   237 @see CLogServOperationBase

   238 @see CLogServCacheConfig

   239 @internalComponent

   240 */

   241 class CLogServOpConfigChange : public CLogServOperationBase

   242 	{

   243 public:

   244 	CLogServOpConfigChange(MLogServTaskInterface& aTaskInterface, 

   245 						   MLogServOperationManager& aOperationManager, 

   246 						   const RMessage2& aMessage, 

   247 						   CLogPackage& aPackage,

   248 						   const TLogClientServerData& aCliServData,

   249 						   TLogServSessionId aSessionId);

   250 	void StartL(TRequestStatus& aStatus);

   251 	//

   252 private:

   253 	TLogConfig iConfig;

   254 	};

   255 

   256 /**

   257 CLogServOperationBase derived class that initiates the "clear events log" operation.  

   258  

   259 @see CLogServOperationBase

   260 @see CLogServDatabaseDriver

   261 @internalComponent

   262 */

   263 class CLogServOpClearLog : public CLogServOperationBase

   264 	{

   265 public:

   266 	CLogServOpClearLog(MLogServTaskInterface& aTaskInterface, 

   267 					   MLogServOperationManager& aOperationManager, 

   268 					   const RMessage2& aMessage, 

   269 					   CLogPackage& aPackage,

   270 					   const TLogClientServerData& aCliServData,

   271 					   TLogServSessionId aSessionId);

   272 	void StartL(TRequestStatus& aStatus);

   273 	};

   274 

   275 /**

   276 CLogServOperationBase derived class that initiates the "clear recent list" operation.  

   277  

   278 @see CLogServOperationBase

   279 @see CLogServDatabaseDriver

   280 @internalComponent

   281 */

   282 class CLogServOpClearRecent : public CLogServOperationBase

   283 	{

   284 public:

   285 	CLogServOpClearRecent(MLogServTaskInterface& aTaskInterface, 

   286 						  MLogServOperationManager& aOperationManager, 

   287 						  const RMessage2& aMessage, 

   288 						  CLogPackage& aPackage,

   289 						  const TLogClientServerData& aCliServData,

   290 						  TLogServSessionId aSessionId);

   291 	void StartL(TRequestStatus& aStatus);

   292 	};

   293 

   294 /**

   295 CLogServOperationBase derived class that initiates database maintenance tasks such as:

   296 database recover, database compaction, etc.  

   297 

   298 @see CLogServOperationBase

   299 @see CLogMaintenance

   300 @internalComponent

   301 */

   302 class CLogServOpMaintenance : public CLogServOperationBase

   303 	{

   304 public:

   305 	CLogServOpMaintenance(MLogServTaskInterface& aTaskInterface, 

   306 						  MLogServOperationManager& aOperationManager, 

   307 						  const RMessage2& aMessage, 

   308 						  CLogPackage& aPackage,

   309 						  const TLogClientServerData& aCliServData,

   310 						  TLogServSessionId aSessionId);

   311 	void StartL(TRequestStatus& aStatus);

   312 	};

   313 

   314 /**

   315 CLogServOperationBase derived class that initiates the "setup view" operation.

   316 

   317 @see CLogServOperationBase

   318 @see CLogServViewBase

   319 @see CLogServViewLockObserver

   320 @see CLogServViewEvent

   321 @see CLogServViewRecent

   322 @see CLogServViewDuplicate

   323 @internalComponent

   324 */

   325 class CLogServOpViewSetup : public CLogServOperationBase

   326 	{

   327 public:

   328 	CLogServOpViewSetup(MLogServTaskInterface& aTaskInterface, 

   329 			            MLogServOperationManager& aOperationManager, 

   330                         const RMessage2& aMessage, 

   331                         CLogPackage& aPackage, 

   332                         CLogServViewBase& aView,

   333  					    const TLogClientServerData& aCliServData,

   334  					    TLogServSessionId aSessionId);

   335 	void StartL(TRequestStatus& aStatus);

   336 	//

   337 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

   338 	//

   339 private:

   340 	CLogServViewBase& iView;

   341 	};

   342 

   343 /**

   344 CLogServOperationBase derived class that initiates the "remove event from view" operation.

   345 

   346 @see CLogServOperationBase

   347 @see CLogServViewBase

   348 @see CLogServViewLockObserver

   349 @see CLogServViewEvent

   350 @see CLogServViewRecent

   351 @see CLogServViewDuplicate

   352 @internalComponent

   353 */

   354 class CLogServOpViewEventRemove : public CLogServOperationBase

   355 	{

   356 public:

   357 	CLogServOpViewEventRemove(MLogServTaskInterface& aTaskInterface, 

   358 							  MLogServOperationManager& aOperationManager, 

   359 							  const RMessage2& aMessage, 

   360 							  CLogPackage& aPackage, 

   361 							  CLogServViewBase& aView,

   362 							  const TLogClientServerData& aCliServData,

   363 							  TLogServSessionId aSessionId);

   364 	void StartL(TRequestStatus& aStatus);

   365 	//

   366 private:

   367 	CLogServViewBase& iView;

   368 	};

   369 

   370 /**

   371 CLogServOperationBase derived class that initiates the "clear duplicates from view" operation.

   372 

   373 @see CLogServOperationBase

   374 @see CLogServViewBase

   375 @see CLogServViewLockObserver

   376 @see CLogServViewEvent

   377 @see CLogServViewRecent

   378 @see CLogServViewDuplicate

   379 @internalComponent

   380 */

   381 class CLogServOpViewClearDuplicates : public CLogServOperationBase

   382 	{

   383 public:

   384 	CLogServOpViewClearDuplicates(MLogServTaskInterface& aTaskInterface, 

   385 								  MLogServOperationManager& aOperationManager, 

   386 								  const RMessage2& aMessage, 

   387 								  CLogPackage& aPackage, 

   388 								  CLogServViewBase& aView,

   389 								  const TLogClientServerData& aCliServData,

   390 								  TLogServSessionId aSessionId);

   391 	void StartL(TRequestStatus& aStatus);

   392 	//

   393 private:

   394 	CLogServViewBase& iView;

   395 	};

   396 

   397 /**

   398 CLogServOperationBase derived class that initiates the "set view events flags" operation.

   399 

   400 @see CLogServOperationBase

   401 @see CLogServViewBase

   402 @see CLogServViewLockObserver

   403 @see CLogServViewEvent

   404 @see CLogServViewRecent

   405 @see CLogServViewDuplicate

   406 @internalComponent

   407 */

   408 class CLogServOpViewSetFlags : public CLogServOperationBase

   409 	{

   410 public:

   411 	CLogServOpViewSetFlags(MLogServTaskInterface& aTaskInterface, 

   412 						   MLogServOperationManager& aOperationManager, 

   413 						   const RMessage2& aMessage, 

   414 						   CLogPackage& aPackage, 

   415 						   CLogServViewBase& aView,

   416 						   const TLogClientServerData& aCliServData,

   417 						   TLogServSessionId aSessionId);

   418 	void StartL(TRequestStatus& aStatus);

   419 	//

   420 private:

   421 	CLogServViewBase& iView;

   422 	};

   423 

   424 /**

   425 CLogServOperationBase derived class that initiates the "get events window" operation.

   426 

   427 @see CLogServOperationBase

   428 @see CLogServViewBase

   429 @see CLogServViewLockObserver

   430 @see CLogServViewEvent

   431 @see CLogServViewRecent

   432 @see CLogServViewDuplicate

   433 @internalComponent

   434 */

   435 class CLogServOpViewWindowFetcher : public CLogServOperationBase

   436 	{

   437 public:

   438 	CLogServOpViewWindowFetcher(MLogServTaskInterface& aTaskInterface, 

   439 								MLogServOperationManager& aOperationManager, 

   440 								const RMessage2& aMessage, 

   441 								CLogPackage& aPackage, 

   442 								CLogServViewBase& aView,

   443 								const TLogClientServerData& aCliServData,

   444 								TLogServSessionId aSessionId);

   445 	void StartL(TRequestStatus& aStatus);

   446 	TCompletionStatus CompleteProcessingL(TInt aFinalCompletionCode);

   447 	//

   448 private:

   449 	CLogServViewBase& iView;

   450 	};

   451 

   452 

   453 #endif