embox

1
/**
2
 * @file
3
 * @brief
4
 *
5
 * @date 09.10.12
6
 * @author Anton Bondarev
7
 * @author Ilia Vaprol
8
 */
9

10
#include <assert.h>
11
#include <stddef.h>
12

13
#include "index_priv.h"
14

15
int index_try_lock(struct indexator *ind, size_t idx) {
16
	int err;
17

18
	if ((err = ind_check(ind, idx))) {
19
		return err;
20
	}
21

22
	if (ind_get_bit(ind, idx)) {
23
		return 0;
24
	}
25

26
	index_lock(ind, idx);
27

28
	return 1;
29
}
30

31
void index_lock(struct indexator *ind, size_t idx) {
32
	ind_set_bit(ind, idx);
33

34
	assert(ind);
35
	assert(idx != INDEX_NONE);
36

37
	if ((idx >= ind->clamp_min) && (idx <= ind->clamp_max)) {
38
		ind->last = idx;
39

40
		if (idx == ind->min) {
41
			ind->min = ind_find_more(ind, ind->min, ind->clamp_max, INDEX_NONE);
42
		}
43
		if (idx == ind->max) {
44
			ind->max = ind_find_less(ind, ind->max, ind->clamp_min, INDEX_NONE);
45
		}
46
		ind->prev = ind_find_less(ind, idx, ind->clamp_min, ind->max);
47
		ind->next = ind_find_more(ind, idx, ind->clamp_max, ind->min);
48
	}
49
}
50

51
int index_locked(struct indexator *ind, size_t idx) {
52
	int err;
53

54
	if ((err = ind_check(ind, idx))) {
55
		return err;
56
	}
57

58
	return ind_get_bit(ind, idx);
59
}
60

61
void index_unlock(struct indexator *ind, size_t idx) {
62
	if (ind_check(ind, idx)) {
63
		return;
64
	}
65

66
	ind_unset_bit(ind, idx);
67

68
	assert(ind);
69
	assert(idx != INDEX_NONE);
70

71
	if ((idx >= ind->clamp_min) && (idx <= ind->clamp_max)) {
72
		assert(ind->last != INDEX_NONE);
73

74
		if (ind->min == INDEX_NONE) {
75
			ind->min = ind->max = ind->prev = ind->next = idx;
76
		}
77
		else {
78
			if (idx < ind->min) {
79
				ind->min = idx;
80
			}
81
			if (idx > ind->max) {
82
				ind->max = idx;
83
			}
84
			if (((idx > ind->prev) && (idx < ind->last))
85
			    || ((ind->prev > ind->last)
86
			        && ((idx > ind->prev) || (idx < ind->last)))
87
			    || (ind->prev == ind->last)) {
88
				ind->prev = idx;
89
			}
90
			if (((idx < ind->next) && (idx > ind->last))
91
			    || ((ind->next < ind->last)
92
			        && ((idx < ind->next) || (idx > ind->last)))
93
			    || (ind->next == ind->last)) {
94
				ind->next = idx;
95
			}
96
		}
97
	}
98
}
99