1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #define LOG_TAG "bt_osi_future"
20
21 #include <assert.h>
22
23 #include "osi/include/allocator.h"
24 #include "osi/include/future.h"
25 #include "osi/include/osi.h"
26 #include "osi/include/log.h"
27 #include "osi/include/semaphore.h"
28
29 struct future_t {
30 bool ready_can_be_called;
31 semaphore_t *semaphore; // NULL semaphore means immediate future
32 void *result;
33 };
34
35 static void future_free(future_t *future);
36
future_new(void)37 future_t *future_new(void) {
38 future_t *ret = osi_calloc(sizeof(future_t));
39 if (!ret) {
40 LOG_ERROR("%s unable to allocate memory for return value.", __func__);
41 goto error;
42 }
43
44 ret->semaphore = semaphore_new(0);
45 if (!ret->semaphore) {
46 LOG_ERROR("%s unable to allocate memory for the semaphore.", __func__);
47 goto error;
48 }
49
50 ret->ready_can_be_called = true;
51 return ret;
52 error:;
53 future_free(ret);
54 return NULL;
55 }
56
future_new_immediate(void * value)57 future_t *future_new_immediate(void *value) {
58 future_t *ret = osi_calloc(sizeof(future_t));
59 if (!ret) {
60 LOG_ERROR("%s unable to allocate memory for return value.", __func__);
61 goto error;
62 }
63
64 ret->result = value;
65 ret->ready_can_be_called = false;
66 return ret;
67 error:;
68 future_free(ret);
69 return NULL;
70 }
71
future_ready(future_t * future,void * value)72 void future_ready(future_t *future, void *value) {
73 assert(future != NULL);
74 assert(future->ready_can_be_called);
75
76 future->ready_can_be_called = false;
77 future->result = value;
78 semaphore_post(future->semaphore);
79 }
80
future_await(future_t * future)81 void *future_await(future_t *future) {
82 assert(future != NULL);
83
84 // If the future is immediate, it will not have a semaphore
85 if (future->semaphore)
86 semaphore_wait(future->semaphore);
87
88 void *result = future->result;
89 future_free(future);
90 return result;
91 }
92
future_free(future_t * future)93 static void future_free(future_t *future) {
94 if (!future)
95 return;
96
97 semaphore_free(future->semaphore);
98 osi_free(future);
99 }
100