src/session/command_queue.h

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __MAPS_SERVICE_SESSION_COMMAND_QUEUE_H__
  18 #define __MAPS_SERVICE_SESSION_COMMAND_QUEUE_H__
  19
  20 #include "module.h"
  21
  22 namespace session
  23 {
  24
  25         class command;
  26
  27         class command_queue
  28         {
  29         public:
  30                 virtual int push(command *c) = 0;
  31                 virtual command *pop(plugin::plugin_s *p) = 0;
  32                 virtual void process(plugin::plugin_s *p) = 0;
  33                 virtual void clear(plugin::plugin_s *p) = 0;
  34         public:
  35                 static command_queue *interface();
  36                 static bool is_async()
  37                 {
  38                         return false;
  39                 }
  40         };
  41
  42         class command_queue_sync:public command_queue
  43         {
  44         private:
  45                 command_queue_sync()
  46                 {
  47                 }
  48                 virtual ~command_queue_sync()
  49                 {
  50                 }
  51         private:
  52                 virtual int push(command *c);
  53                 virtual command *pop(plugin::plugin_s *p);
  54                 virtual void process(plugin::plugin_s *p);
  55                 virtual void clear(plugin::plugin_s *p);
  56
  57                 friend class command_queue;
  58         };
  59
  60 /*
  61  * This is the implementation of asynchronous queue.
  62  * In order to pass code coverage tests it is blocked.
  63  */
  64 #ifdef _MAPS_SERVICE_SUPPORTS_ASYNC_QUEUE_
  65         class command_queue_async:public command_queue
  66         {
  67         private:
  68                 command_queue_async()
  69                 {
  70                 }
  71                 virtual ~command_queue_async()
  72                 {
  73                 }
  74         private:
  75                 virtual int push(command *c);
  76                 virtual command *pop(plugin::plugin_s *p);
  77                 virtual void process(plugin::plugin_s *p);
  78                 virtual void clear(plugin::plugin_s *p);
  79
  80                 friend class command_queue;
  81         };
  82
  83         /*
  84          * This queue is intended to process mainly the commands, assigned to
  85          * user gestures
  86          */
  87         class command_queue_view : public command_queue
  88         {
  89         private:
  90                 command_queue_view()
  91                 {
  92                 }
  93                 virtual ~command_queue_view()
  94                 {
  95                 }
  96         public:
  97                 static command_queue* interface();
  98         private:
  99                 virtual int push(command *c);
 100                 virtual command *pop(plugin::plugin_s *p);
 101                 virtual void process(plugin::plugin_s *p);
 102                 virtual void clear(plugin::plugin_s *p);
 103
 104                 friend class command_queue;
 105         private:
 106                 static gint iterate(gconstpointer a,
 107                                     gconstpointer b,
 108                                     gpointer user_data);
 109         };
 110
 111         class queue_autoref
 112         {
 113         public:
 114                 GAsyncQueue *q;
 115         public:
 116                 queue_autoref(GAsyncQueue *async_queue) : q(async_queue)
 117                 {
 118                         g_async_queue_ref(q);
 119                 }
 120                 ~queue_autoref()
 121                 {
 122                         g_async_queue_unref(q);
 123                 }
 124         };
 125 #endif /* _MAPS_SERVICE_SUPPORTS_ASYNC_QUEUE_ */
 126
 127 };
 128
 129 #endif                          /* __MAPS_SERVICE_SESSION_COMMAND_QUEUE_H__ */