Cross Reference: /system/bt/osi/src/fixed

Lines Matching refs:queue
68 void fixed_queue_free(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
69   if (!queue) return;
71   fixed_queue_unregister_dequeue(queue);
74     for (const list_node_t* node = list_begin(queue->list);
75          node != list_end(queue->list); node = list_next(node))
78   list_free(queue->list);
79   semaphore_free(queue->enqueue_sem);
80   semaphore_free(queue->dequeue_sem);
81   delete queue->mutex;
82   osi_free(queue);
85 void fixed_queue_flush(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
86   if (!queue) return;
88   while (!fixed_queue_is_empty(queue)) {
89     void* data = fixed_queue_try_dequeue(queue);
96 bool fixed_queue_is_empty(fixed_queue_t* queue) {
97   if (queue == NULL) return true;
99   std::lock_guard<std::mutex> lock(*queue->mutex);
100   return list_is_empty(queue->list);
103 size_t fixed_queue_length(fixed_queue_t* queue) {
104   if (queue == NULL) return 0;
106   std::lock_guard<std::mutex> lock(*queue->mutex);
107   return list_length(queue->list);
110 size_t fixed_queue_capacity(fixed_queue_t* queue) {
111   CHECK(queue != NULL);
113   return queue->capacity;
116 void fixed_queue_enqueue(fixed_queue_t* queue, void* data) {
117   CHECK(queue != NULL);
120   semaphore_wait(queue->enqueue_sem);
123     std::lock_guard<std::mutex> lock(*queue->mutex);
124     list_append(queue->list, data);
127   semaphore_post(queue->dequeue_sem);
130 void* fixed_queue_dequeue(fixed_queue_t* queue) {
131   CHECK(queue != NULL);
133   semaphore_wait(queue->dequeue_sem);
137     std::lock_guard<std::mutex> lock(*queue->mutex);
138     ret = list_front(queue->list);
139     list_remove(queue->list, ret);
142   semaphore_post(queue->enqueue_sem);
147 bool fixed_queue_try_enqueue(fixed_queue_t* queue, void* data) {
148   CHECK(queue != NULL);
151   if (!semaphore_try_wait(queue->enqueue_sem)) return false;
154     std::lock_guard<std::mutex> lock(*queue->mutex);
155     list_append(queue->list, data);
158   semaphore_post(queue->dequeue_sem);
162 void* fixed_queue_try_dequeue(fixed_queue_t* queue) {
163   if (queue == NULL) return NULL;
165   if (!semaphore_try_wait(queue->dequeue_sem)) return NULL;
169     std::lock_guard<std::mutex> lock(*queue->mutex);
170     ret = list_front(queue->list);
171     list_remove(queue->list, ret);
174   semaphore_post(queue->enqueue_sem);
179 void* fixed_queue_try_peek_first(fixed_queue_t* queue) {
180   if (queue == NULL) return NULL;
182   std::lock_guard<std::mutex> lock(*queue->mutex);
183   return list_is_empty(queue->list) ? NULL : list_front(queue->list);
186 void* fixed_queue_try_peek_last(fixed_queue_t* queue) {
187   if (queue == NULL) return NULL;
189   std::lock_guard<std::mutex> lock(*queue->mutex);
190   return list_is_empty(queue->list) ? NULL : list_back(queue->list);
193 void* fixed_queue_try_remove_from_queue(fixed_queue_t* queue, void* data) {
194   if (queue == NULL) return NULL;
198     std::lock_guard<std::mutex> lock(*queue->mutex);
199     if (list_contains(queue->list, data) &&
200         semaphore_try_wait(queue->dequeue_sem)) {
201       removed = list_remove(queue->list, data);
207     semaphore_post(queue->enqueue_sem);
213 list_t* fixed_queue_get_list(fixed_queue_t* queue) {
214   CHECK(queue != NULL);
218   // to the queue can break our assumptions and the queue in general.
219   return queue->list;
222 int fixed_queue_get_dequeue_fd(const fixed_queue_t* queue) {
223   CHECK(queue != NULL);
224   return semaphore_get_fd(queue->dequeue_sem);
227 int fixed_queue_get_enqueue_fd(const fixed_queue_t* queue) {
228   CHECK(queue != NULL);
229   return semaphore_get_fd(queue->enqueue_sem);
232 void fixed_queue_register_dequeue(fixed_queue_t* queue, reactor_t* reactor,
234   CHECK(queue != NULL);
239   fixed_queue_unregister_dequeue(queue);
241   queue->dequeue_ready = ready_cb;
242   queue->dequeue_context = context;
243   queue->dequeue_object =
244       reactor_register(reactor, fixed_queue_get_dequeue_fd(queue), queue,
248 void fixed_queue_unregister_dequeue(fixed_queue_t* queue) {
249   CHECK(queue != NULL);
251   if (queue->dequeue_object) {
252     reactor_unregister(queue->dequeue_object);
253     queue->dequeue_object = NULL;
260   fixed_queue_t* queue = static_cast<fixed_queue_t*>(context);
261   queue->dequeue_ready(queue, queue->dequeue_context);