Merge "Added new message type constants"
[ric-plt/lib/rmr.git] / src / rmr / common / src / ring_static.c
1 // :vi sw=4 ts=4 noet:
2 /*
3 ==================================================================================
4         Copyright (c) 2019 Nokia
5         Copyright (c) 2018-2019 AT&T Intellectual Property.
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         Mnemonic:       ring_static.c
22         Abstract:       Implements a ring of information (probably to act as a
23                                 message queue).
24         Author:         E. Scott Daniels
25         Date:           31 August 2017
26 */
27
28 #ifndef _ring_static_c
29 #define _ring_static_c
30
31 #include <unistd.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <strings.h>
35 #include <errno.h>
36 #include <string.h>
37 #include <stdint.h>
38
39 #define RING_FAST 1                     // when set we skip nil pointer checks on the ring pointer
40
41 /*
42         Make a new ring.
43 */
44 static void* uta_mk_ring( int size ) {
45         ring_t* r;
46         uint16_t max;
47
48         if( size <= 0 || (r = (ring_t *) malloc( sizeof( *r ) )) == NULL ) {
49                 return NULL;
50         }
51
52         r->head = r->tail = 0;
53
54         max = (r->head - 1);
55         if( size >= max ) {
56                 size--;
57         }
58
59         r->nelements = size;            // because we always have an empty element when full
60         if( (r->data = (void **) malloc( sizeof( void** ) * (r->nelements + 1) )) == NULL ) {
61                 free( r );
62                 return NULL;
63         }
64
65         memset( r->data, 0, sizeof( void** ) * r->nelements );
66         return (void *) r;
67 }
68
69 /*
70         Ditch the ring. The caller is responsible for extracting any remaining
71         pointers and freeing them as needed.
72 */
73 static void uta_ring_free( void* vr ) {
74         ring_t* r;
75
76         if( (r = (ring_t*) vr) == NULL ) {
77                 return;
78         }
79
80         free( r );
81 }
82
83
84 /*
85         Pull the next data pointer from the ring; null if there isn't
86         anything to be pulled.
87 */
88 static inline void* uta_ring_extract( void* vr ) {
89         ring_t*         r;
90         uint16_t        ti;             // real index in data
91
92         if( !RING_FAST ) {                                                              // compiler should drop the conditional when always false
93                 if( (r = (ring_t*) vr) == NULL ) {
94                         return 0;
95                 }
96         } else {
97                 r = (ring_t*) vr;
98         }
99
100         if( r->tail == r->head ) {                      // empty ring
101                 return NULL;
102         }
103
104         ti = r->tail;
105         r->tail++;
106         if( r->tail >= r->nelements ) {
107                 r->tail = 0;
108         }
109
110         return r->data[ti];
111 }
112
113 /*
114         Insert the pointer at the next open space in the ring.
115         Returns 1 if the inert was ok, and 0 if the ring is full.
116 */
117 static inline int uta_ring_insert( void* vr, void* new_data ) {
118         ring_t*         r;
119
120         if( !RING_FAST ) {                                                              // compiler should drop the conditional when always false
121                 if( (r = (ring_t*) vr) == NULL ) {
122                         return 0;
123                 }
124         } else {
125                 r = (ring_t*) vr;
126         }
127
128         if( r->head+1 == r->tail || (r->head+1 >= r->nelements && !r->tail) ) {         // ring is full
129                 return 0;
130         }
131
132         r->data[r->head] = new_data;
133         r->head++;
134         if( r->head >= r->nelements ) {
135                 r->head = 0;
136         }
137
138         return 1;
139 }
140
141
142
143 #endif