src/server/sensor_info_list.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <sensor_info_list.h>
  21 #include <algorithm>
  22
  23 interval_info::interval_info(int client_id, bool is_processor, unsigned int interval)
  24 {
  25         this->client_id = client_id;
  26         this->is_processor = is_processor;
  27         this->interval = interval;
  28 }
  29
  30 batch_info::batch_info(int client_id, unsigned int latency)
  31 {
  32         this->client_id = client_id;
  33         this->latency = latency;
  34 }
  35
  36 bool sensor_info_list::comp_interval_info(interval_info a, interval_info b)
  37 {
  38         return a.interval < b.interval;
  39 }
  40
  41 bool sensor_info_list::comp_batch_info(batch_info a, batch_info b)
  42 {
  43         return a.latency < b.latency;
  44 }
  45
  46 interval_info_iterator sensor_info_list::find_if_interval_info(int client_id, bool is_processor)
  47 {
  48         auto iter = m_interval_info_list.begin();
  49
  50         while (iter != m_interval_info_list.end()) {
  51                 if ((iter->client_id == client_id) && (iter->is_processor == is_processor))
  52                         break;
  53
  54                 ++iter;
  55         }
  56
  57         return iter;
  58 }
  59
  60 batch_info_iterator sensor_info_list::find_if_batch_info(int client_id)
  61 {
  62         auto iter = m_batch_info_list.begin();
  63
  64         while (iter != m_batch_info_list.end()) {
  65                 if ((iter->client_id == client_id))
  66                         break;
  67
  68                 ++iter;
  69         }
  70
  71         return iter;
  72 }
  73
  74 bool sensor_info_list::add_interval(int client_id, unsigned int interval, bool is_processor)
  75 {
  76         auto iter = find_if_interval_info(client_id, is_processor);
  77
  78         if (iter != m_interval_info_list.end())
  79                 *iter = interval_info(client_id, is_processor, interval);
  80         else
  81                 m_interval_info_list.push_back(interval_info(client_id, is_processor, interval));
  82
  83         return true;
  84 }
  85
  86 bool sensor_info_list::delete_interval(int client_id, bool is_processor)
  87 {
  88         auto iter = find_if_interval_info(client_id, is_processor);
  89
  90         if (iter == m_interval_info_list.end())
  91                 return false;
  92
  93         m_interval_info_list.erase(iter);
  94
  95         return true;
  96 }
  97
  98 unsigned int sensor_info_list::get_interval(int client_id, bool is_processor)
  99 {
 100         auto iter = find_if_interval_info(client_id, is_processor);
 101
 102         if (iter == m_interval_info_list.end())
 103                 return 0;
 104
 105         return iter->interval;
 106 }
 107
 108 unsigned int sensor_info_list::get_min_interval(void)
 109 {
 110         if (m_interval_info_list.empty())
 111                 return 0;
 112
 113         auto iter = min_element(m_interval_info_list.begin(), m_interval_info_list.end(), comp_interval_info);
 114
 115         return iter->interval;
 116 }
 117
 118 bool sensor_info_list::add_batch(int client_id, unsigned int latency)
 119 {
 120         auto iter = find_if_batch_info(client_id);
 121
 122         if (iter != m_batch_info_list.end())
 123                 *iter = batch_info(client_id, latency);
 124         else
 125                 m_batch_info_list.push_back(batch_info(client_id, latency));
 126
 127         return true;
 128 }
 129
 130 bool sensor_info_list::delete_batch(int client_id)
 131 {
 132         auto iter = find_if_batch_info(client_id);
 133
 134         if (iter == m_batch_info_list.end())
 135                 return false;
 136
 137         m_batch_info_list.erase(iter);
 138
 139         return true;
 140 }
 141
 142 unsigned int sensor_info_list::get_batch(int client_id)
 143 {
 144         auto iter = find_if_batch_info(client_id);
 145
 146         if (iter == m_batch_info_list.end())
 147                 return 0;
 148
 149         return iter->latency;
 150 }
 151
 152 unsigned int sensor_info_list::get_max_batch(void)
 153 {
 154         if (m_batch_info_list.empty())
 155                 return 0;
 156
 157         auto iter = max_element(m_batch_info_list.begin(), m_batch_info_list.end(), comp_batch_info);
 158
 159         return iter->latency;
 160 }
 161