resource/csdk/connectivity/common/src/uqueue.c

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include <stddef.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24
  25 #include "logger.h"
  26 #include "uqueue.h"
  27 #include "oic_malloc.h"
  28
  29 #define NO_MESSAGES 0
  30 #define TAG PCF("UQUEUE")
  31
  32 u_queue_t* u_queue_create()
  33 {
  34     u_queue_t* queuePtr = (u_queue_t*) OICMalloc(sizeof(u_queue_t));
  35     if (NULL == queuePtr)
  36     {
  37         OIC_LOG(DEBUG, TAG, "QueueCreate FAIL");
  38         return NULL;
  39     }
  40
  41     queuePtr->count = NO_MESSAGES;
  42     queuePtr->element = NULL;
  43
  44     return queuePtr;
  45 }
  46
  47 CAResult_t u_queue_add_element(u_queue_t* queue, u_queue_message_t *message)
  48 {
  49     u_queue_element* element = NULL;
  50     u_queue_element* ptr = NULL;
  51
  52     if (NULL == queue)
  53     {
  54         OIC_LOG(DEBUG, TAG, "QueueAddElement FAIL, Invalid Queue");
  55         return CA_STATUS_FAILED;
  56     }
  57
  58     if (NULL == message)
  59     {
  60         OIC_LOG(DEBUG, TAG, "QueueAddElement : FAIL, NULL Message");
  61         return CA_STATUS_FAILED;
  62     }
  63
  64     element = (u_queue_element*) OICMalloc(sizeof(u_queue_element));
  65     if (NULL == element)
  66     {
  67         OIC_LOG(DEBUG, TAG, "QueueAddElement FAIL, memory allocation failed");
  68         return CA_MEMORY_ALLOC_FAILED;
  69     }
  70
  71     element->message = message;
  72     element->next = NULL;
  73
  74     ptr = queue->element;
  75
  76     if (NULL != ptr)
  77     {
  78         while (NULL != ptr->next)
  79         {
  80             ptr = ptr->next;
  81         }
  82
  83         ptr->next = element;
  84         queue->count++;
  85
  86         OIC_LOG_V(DEBUG, TAG, "Queue Count : %d", queue->count);
  87     }
  88     else
  89     {
  90         if (NO_MESSAGES != queue->count)
  91         {
  92             OIC_LOG(DEBUG, TAG, "QueueAddElement : FAIL, count is not zero");
  93
  94             /* error in queue, free the allocated memory*/
  95             OICFree(element);
  96             return CA_STATUS_FAILED;
  97         }
  98
  99         queue->element = element;
 100         queue->count++;
 101         OIC_LOG_V(DEBUG, TAG, "Queue Count : %d", queue->count);
 102
 103         return CA_STATUS_OK;
 104     }
 105
 106     return CA_STATUS_OK;
 107 }
 108
 109 u_queue_message_t* u_queue_get_element(u_queue_t* queue)
 110 {
 111     u_queue_element* next = NULL;
 112     u_queue_element* element = NULL;
 113     u_queue_message_t* message = NULL;
 114
 115     if (NULL == queue)
 116     {
 117         OIC_LOG(DEBUG, TAG, "QueueAddElement FAIL, Invalid Queue");
 118         return NULL;
 119     }
 120
 121     element = queue->element;
 122
 123     if (NULL == element)
 124     {
 125         OIC_LOG(DEBUG, TAG, "QueueGetElement : FAIL, no messages");
 126         return NULL;
 127     }
 128
 129     next = element->next;
 130     queue->element = next;
 131     queue->count--;
 132
 133     message = element->message;
 134     OICFree(element);
 135     return message;
 136 }
 137
 138 CAResult_t u_queue_remove_element(u_queue_t* queue)
 139 {
 140     u_queue_element* next = NULL;
 141     u_queue_element* remove = NULL;
 142
 143     if (NULL == queue)
 144     {
 145         OIC_LOG(DEBUG, TAG, "QueueRemoveElement FAIL, Invalid Queue");
 146         return CA_STATUS_FAILED;
 147     }
 148
 149     remove = queue->element;
 150
 151     if (NULL == remove)
 152     {
 153         OIC_LOG(DEBUG, TAG, "QueueRemoveElement : no messages");
 154         return CA_STATUS_OK;
 155     }
 156
 157     next = remove->next;
 158
 159     OICFree(remove->message);
 160     OICFree(remove);
 161
 162     queue->element = next;
 163     queue->count--;
 164
 165     return CA_STATUS_OK;
 166 }
 167
 168 uint32_t u_queue_get_size(u_queue_t* queue)
 169 {
 170     if (NULL == queue)
 171     {
 172         OIC_LOG(DEBUG, TAG, "QueueGetSize FAIL, Invalid Queue");
 173         return NO_MESSAGES;
 174     }
 175
 176     return queue->count;
 177 }
 178
 179 CAResult_t u_queue_reset(u_queue_t* queue)
 180 {
 181     CAResult_t error = CA_STATUS_FAILED;
 182
 183     if (NULL == queue)
 184     {
 185         OIC_LOG(DEBUG, TAG, "QueueReset FAIL, Invalid Queue");
 186         return CA_STATUS_FAILED;
 187     }
 188
 189     if (NO_MESSAGES == queue->count)
 190     {
 191         OIC_LOG(DEBUG, TAG, "QueueReset, no elements in the queue");
 192         return CA_STATUS_OK;
 193     }
 194
 195     while (NULL != queue->element)
 196     {
 197         error = u_queue_remove_element(queue);
 198         if (error == CA_STATUS_FAILED)
 199             break;
 200     }
 201
 202     if (NO_MESSAGES != queue->count)
 203     {
 204         OIC_LOG(DEBUG, TAG, "QueueReset : FAIL, count is non zero");
 205         return CA_STATUS_FAILED;
 206     }
 207
 208     return CA_STATUS_OK;
 209
 210 }
 211
 212 CAResult_t u_queue_delete(u_queue_t* queue)
 213 {
 214     CAResult_t error = CA_STATUS_FAILED;
 215
 216     if (NULL == queue)
 217     {
 218         OIC_LOG(DEBUG, TAG, "QueueDelete FAIL, Invalid Queue");
 219         return CA_STATUS_FAILED;
 220     }
 221
 222     error = u_queue_reset(queue);
 223     if (error != CA_STATUS_OK)
 224     {
 225         OIC_LOG(DEBUG, TAG, "QueueDelete : FAIL, error in QueueReset");
 226         return error;
 227     }
 228
 229     OICFree(queue);
 230     return (CA_STATUS_OK);
 231 }
 232
 233 u_queue_message_t* u_queue_get_head(u_queue_t* queue)
 234 {
 235     if (NULL == queue)
 236     {
 237         OIC_LOG(DEBUG, TAG, "QueueGetHead FAIL, Invalid Queue");
 238         return NULL;
 239     }
 240
 241     if (NULL == queue->element)
 242     {
 243         OIC_LOG(DEBUG, TAG, "QueueGetHead : no messages in queue");
 244         return NULL;
 245     }
 246     return queue->element->message;
 247 }