common/CRingBuffer.h

   1 // \8b\9e\r
   2 #ifndef INC_CRingBuffer\r
   3 #define INC_CRingBuffer\r
   4 \r
   5 \r
   6 #include <vector>\r
   7 \r
   8 ////////////////////////////////////////////////////////////////////////////////\r
   9 // CRingBuffer\r
  10 ////////////////////////////////////////////////////////////////////////////////\r
  11 template<typename T>\r
  12 class CRingBuffer\r
  13 {\r
  14         ////////////////////////////////////////////////////////////////////////////////\r
  15         // \83\81\83\93\83o\95Ï\90\94\r
  16         ////////////////////////////////////////////////////////////////////////////////\r
  17 private:\r
  18         std::vector<T> m_Buffer;\r
  19         int m_ReadPosition;\r
  20         int m_WritePosition;\r
  21 \r
  22         ////////////////////////////////////////////////////////////////////////////////\r
  23         // \83R\83\93\83X\83g\83\89\83N\83^\r
  24         ////////////////////////////////////////////////////////////////////////////////\r
  25 public:\r
  26         CRingBuffer()\r
  27         {\r
  28                 m_ReadPosition = 0;\r
  29                 m_WritePosition = 0;\r
  30         }\r
  31 \r
  32         ////////////////////////////////////////////////////////////////////////////////\r
  33         // \83f\83X\83g\83\89\83N\83^\r
  34         ////////////////////////////////////////////////////////////////////////////////\r
  35 public:\r
  36         virtual ~CRingBuffer()\r
  37         {\r
  38                 clear();\r
  39         }\r
  40 \r
  41         ////////////////////////////////////////////////////////////////////////////////\r
  42         // static\8aÖ\90\94\81A\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94\r
  43         ////////////////////////////////////////////////////////////////////////////////\r
  44         ////////////////////////////////////////////////////////////////////////////////\r
  45         // \91\80\8dì\83\81\83\\83b\83h\r
  46         ////////////////////////////////////////////////////////////////////////////////\r
  47 public:\r
  48         bool allocate(unsigned int in_Size)\r
  49         {\r
  50                 if(in_Size < 2){\r
  51                         return false;\r
  52                 }\r
  53 \r
  54                 m_Buffer.resize(in_Size);\r
  55                 m_ReadPosition = 0;\r
  56                 m_WritePosition = 0;\r
  57                 return true;\r
  58         }\r
  59 \r
  60         void clear()\r
  61         {\r
  62                 m_Buffer.clear();\r
  63                 m_ReadPosition = 0;\r
  64                 m_WritePosition = 0;\r
  65         }\r
  66 \r
  67         bool nextReadBuffer()\r
  68         {\r
  69                 if(empty()){\r
  70                         return false;\r
  71                 }\r
  72 \r
  73                 m_ReadPosition = (m_ReadPosition + 1) % m_Buffer.size();\r
  74                 return true;\r
  75         }\r
  76 \r
  77         bool nextWriteBuffer()\r
  78         {\r
  79                 if(full()){\r
  80                         return false;\r
  81                 }\r
  82 \r
  83                 m_WritePosition = (m_WritePosition + 1) % m_Buffer.size();\r
  84                 return true;\r
  85         }\r
  86 \r
  87         ////////////////////////////////////////////////////////////////////////////////\r
  88         // \91®\90«\83\81\83\\83b\83h\r
  89         ////////////////////////////////////////////////////////////////////////////////\r
  90 public:\r
  91         size_t size() const\r
  92         {\r
  93                 return m_Buffer.size();\r
  94         }\r
  95 \r
  96         T* at(size_t in_Index)\r
  97         {\r
  98                 return &m_Buffer[in_Index];\r
  99         }\r
 100 \r
 101         const T* at(size_t in_Index) const\r
 102         {\r
 103                 return &m_Buffer[in_Index];\r
 104         }\r
 105 \r
 106         T* getReadPointer()\r
 107         {\r
 108                 if(empty()){\r
 109                         return NULL;\r
 110                 }\r
 111                 return &m_Buffer[m_ReadPosition];\r
 112         }\r
 113 \r
 114         const T* getReadPointer() const\r
 115         {\r
 116                 return &m_Buffer[m_ReadPosition];\r
 117         }\r
 118 \r
 119         T* getWritePointer()\r
 120         {\r
 121                 return &m_Buffer[m_WritePosition];\r
 122         }\r
 123 \r
 124         const T* getWritePointer() const\r
 125         {\r
 126                 return &m_Buffer[m_WritePosition];\r
 127         }\r
 128 \r
 129         ////////////////////////////////////////////////////////////////////////////////\r
 130         // \83C\83e\83\8c\81[\83V\83\87\83\93\r
 131         ////////////////////////////////////////////////////////////////////////////////\r
 132         ////////////////////////////////////////////////////////////////////////////////\r
 133         // \8fó\91Ô\r
 134         ////////////////////////////////////////////////////////////////////////////////\r
 135 public:\r
 136         // check if the buffer is full\r
 137         bool full() const\r
 138         {\r
 139                 return m_ReadPosition == (m_WritePosition + 1) % m_Buffer.size();\r
 140         }\r
 141 \r
 142         // check if the buffer is empty\r
 143         bool empty() const\r
 144         {\r
 145                 return m_ReadPosition == m_WritePosition;;\r
 146         }\r
 147 \r
 148         ////////////////////////////////////////////////////////////////////////////////\r
 149         // \89\89\8eZ\8eq\r
 150         ////////////////////////////////////////////////////////////////////////////////\r
 151         ////////////////////////////////////////////////////////////////////////////////\r
 152         // \8f\83\90\88\89¼\91z\8aÖ\90\94\81A\92è\8b`\82Ì\82Ý\81i\94ñ\8eÀ\91\95\92ñ\8b\9f\81j\r
 153         ////////////////////////////////////////////////////////////////////////////////\r
 154         ////////////////////////////////////////////////////////////////////////////////\r
 155         // \93à\95\94\83N\83\89\83X\r
 156         ////////////////////////////////////////////////////////////////////////////////\r
 157 \r
 158 \r
 159 };\r
 160 \r
 161 #endif //INC_CRingBuffer\r