tool/mbed/mbed-sdk/libraries/net/cellular/CellularModem/core/MtxCircBuffer.h

   1 /* MtxCircBuf.h */
   2 /* Copyright (C) 2012 mbed.org, MIT License
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
   5  * and associated documentation files (the "Software"), to deal in the Software without restriction,
   6  * including without limitation the rights to use, copy, modify, merge, publish, distribute,
   7  * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in all copies or
  11  * substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  14  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  16  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  17  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  18  */
  19
  20 #ifndef MTXCIRCBUFFER_H
  21 #define MTXCIRCBUFFER_H
  22
  23 #include "rtos.h"
  24
  25 //Mutex protected circualr buffer
  26 template<typename T, int size>
  27 class MtxCircBuffer
  28 {
  29 public:
  30   MtxCircBuffer() //:
  31       //mtx()
  32   {
  33     write = 0;
  34     read = 0;
  35   }
  36
  37   bool isFull()
  38   {
  39     mtx.lock();
  40     bool r = (((write + 1) % size) == read);
  41     mtx.unlock();
  42     return r;
  43   }
  44
  45   bool isEmpty()
  46   {
  47     mtx.lock();
  48     bool r = (read == write);
  49     mtx.unlock();
  50     return r;
  51   }
  52
  53   void queue(T k)
  54   {
  55     mtx.lock();
  56     buf[write++] = k;
  57     write %= size;
  58     if (isFull())
  59     {
  60         read++;
  61         read %= size;
  62     }
  63     mtx.unlock();
  64   }
  65
  66   uint16_t available()
  67   {
  68     mtx.lock();
  69     uint16_t a = (write >= read) ? (write - read) : (size - read + write);
  70     mtx.unlock();
  71     return a;
  72   }
  73
  74   bool dequeue(T * c)
  75   {
  76     mtx.lock();
  77     bool empty = (read == write);
  78     if (!empty)
  79     {
  80       *c = buf[read++];
  81       read %= size;
  82     }
  83     mtx.unlock();
  84     return (!empty);
  85   }
  86
  87 private:
  88   volatile uint16_t write;
  89   volatile uint16_t read;
  90   volatile T buf[size];
  91   Mutex mtx;
  92 };
  93
  94 #endif
  95