diff --git a/examples/set_ops.c b/examples/set_ops.c index 95dc5fc..f794f0f 100644 --- a/examples/set_ops.c +++ b/examples/set_ops.c @@ -28,10 +28,24 @@ int intcmp(int a, int b) return a - b; } +size_t inthash(int t) +{ + size_t a = t; + a += ~(a << 15); + a ^= (a >> 10); + a += (a << 3); + a ^= (a >> 6); + a += ~(a << 11); + a ^= (a >> 16); + return a; +} + int main(int argc, char const *argv[]) { set *set1 = set_new(intcmp); set *set2 = set_new(intcmp); + //set *set1 = set_new(50, 0.9, intcmp, inthash); + //set *set2 = set_new(50, 0.9, intcmp, inthash); for (int i = 1; i <= 20; i++) set_insert(set1, i); diff --git a/src/hashset.h b/src/hashset.h index 6ffa0c1..52c9a15 100644 --- a/src/hashset.h +++ b/src/hashset.h @@ -115,385 +115,489 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079, FMOD bool PFX##_iter_end(SNAME##_iter *iter); \ FMOD void PFX##_iter_tostart(SNAME##_iter *iter); \ FMOD void PFX##_iter_toend(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *result, size_t *index); \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *result, size_t *index); \ + FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *value, size_t *index); \ + FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *value, size_t *index); \ \ /* SOURCE ********************************************************************/ -#define HASHSET_GENERATE_SOURCE(PFX, SNAME, FMOD, V) \ - \ - FMOD bool PFX##_grow(SNAME *_set_); \ - FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element); \ - FMOD size_t PFX##_calculate_size(size_t required); \ - \ - FMOD SNAME *PFX##_new(size_t size, double load, int (*compare)(V, V), size_t (*hash)(V)) \ - { \ - if (size == 0 || load <= 0 || load >= 1) \ - return NULL; \ - \ - size_t real_size = PFX##_calculate_size(size); \ - \ - SNAME *_set_ = malloc(sizeof(SNAME)); \ - \ - if (!_set_) \ - return NULL; \ - \ - _set_->buffer = malloc(sizeof(SNAME##_entry) * real_size); \ - \ - if (!_set_->buffer) \ - { \ - free(_set_); \ - return NULL; \ - } \ - \ - memset(_set_->buffer, 0, sizeof(SNAME##_entry) * real_size); \ - \ - _set_->count = 0; \ - _set_->capacity = real_size; \ - _set_->load = load; \ - _set_->cmp = compare; \ - _set_->hash = hash; \ - \ - return _set_; \ - } \ - \ - FMOD void PFX##_free(SNAME *_set_) \ - { \ - free(_set_->buffer); \ - free(_set_); \ - } \ - \ - FMOD bool PFX##_insert(SNAME *_set_, V element) \ - { \ - if ((double)_set_->capacity * _set_->load <= (double)_set_->count) \ - { \ - if (!PFX##_grow(_set_)) \ - return false; \ - } \ - \ - size_t hash = _set_->hash(element); \ - size_t original_pos = hash % _set_->capacity; \ - size_t pos = original_pos; \ - \ - SNAME##_entry *target = &(_set_->buffer[pos]); \ - \ - if (PFX##_get_entry(_set_, element) != NULL) \ - return false; \ - \ - if (target->state == ES_EMPTY || target->state == ES_DELETED) \ - { \ - target->value = element; \ - target->dist = original_pos - pos; \ - target->state = ES_FILLED; \ - } \ - else \ - { \ - while (true) \ - { \ - pos++; \ - target = &(_set_->buffer[pos % _set_->capacity]); \ - \ - if (target->state == ES_EMPTY || target->state == ES_DELETED) \ - { \ - target->value = element; \ - target->dist = pos - original_pos; \ - target->state = ES_FILLED; \ - break; \ - } \ - else if (target->dist < original_pos - pos) \ - { \ - V tmp = target->value; \ - size_t tmp_dist = target->dist; \ - \ - target->value = element; \ - target->dist = pos - original_pos; \ - \ - element = tmp; \ - original_pos = pos - tmp_dist; \ - } \ - } \ - } \ - \ - _set_->count++; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_remove(SNAME *_set_, V element) \ - { \ - SNAME##_entry *result = PFX##_get_entry(_set_, element); \ - \ - if (result == NULL) \ - return false; \ - \ - result->value = 0; \ - result->dist = 0; \ - result->state = ES_DELETED; \ - \ - _set_->count--; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_insert_if(SNAME *_set_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_insert(_set_, element); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_remove_if(SNAME *_set_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_remove(_set_, element); \ - \ - return false; \ - } \ - \ - FMOD V PFX##_max(SNAME *_set_) \ - { \ - if (PFX##_empty(_set_)) \ - return 0; \ - \ - SNAME##_iter iter; \ - V result, max; \ - size_t index; \ - \ - for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ - { \ - PFX##_iter_next(&iter, &result, &index); \ - \ - if (index == 0) \ - max = result; \ - else if (_set_->cmp(result, max) > 0) \ - max = result; \ - } \ - \ - return max; \ - } \ - \ - FMOD V PFX##_min(SNAME *_set_) \ - { \ - if (PFX##_empty(_set_)) \ - return 0; \ - \ - SNAME##_iter iter; \ - V result, min; \ - size_t index; \ - \ - for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ - { \ - PFX##_iter_next(&iter, &result, &index); \ - \ - if (index == 0) \ - min = result; \ - else if (_set_->cmp(result, min) < 0) \ - min = result; \ - } \ - \ - return min; \ - } \ - \ - FMOD bool PFX##_empty(SNAME *_set_) \ - { \ - return _set_->count == 0; \ - } \ - \ - FMOD size_t PFX##_count(SNAME *_set_) \ - { \ - return _set_->count; \ - } \ - \ - FMOD bool PFX##_grow(SNAME *_set_) \ - { \ - size_t new_size = PFX##_calculate_size((size_t)((double)_set_->capacity * 1.5)); \ - \ - SNAME *_new_set_ = PFX##_new(new_size, _set_->load, _set_->cmp, _set_->hash); \ - \ - if (!_new_set_) \ - return false; \ - \ - SNAME##_iter iter; \ - V value; \ - size_t index; \ - \ - for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ - { \ - PFX##_iter_next(&iter, &value, &index); \ - PFX##_insert(_new_set_, value); \ - } \ - \ - if (_set_->count != _new_set_->count) \ - { \ - PFX##_free(_new_set_); \ - return false; \ - } \ - \ - SNAME##_entry *tmp = _set_->buffer; \ - _set_->buffer = _new_set_->buffer; \ - _new_set_->buffer = tmp; \ - \ - _set_->capacity = _new_set_->capacity; \ - \ - PFX##_free(_new_set_); \ - \ - return true; \ - } \ - \ - FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element) \ - { \ - size_t hash = _set_->hash(element); \ - size_t pos = hash % _set_->capacity; \ - \ - SNAME##_entry *target = &(_set_->buffer[pos % _set_->capacity]); \ - \ - while (target->state == ES_FILLED || target->state == ES_DELETED) \ - { \ - if (_set_->cmp(target->value, element) == 0) \ - return target; \ - \ - pos++; \ - target = &(_set_->buffer[pos % _set_->capacity]); \ - } \ - \ - return NULL; \ - } \ - \ - FMOD size_t PFX##_calculate_size(size_t required) \ - { \ - const size_t count = sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ - \ - if (cmc_hashtable_primes[count - 1] < required) \ - return required; \ - \ - size_t i = 0; \ - while (cmc_hashtable_primes[i] < required) \ - i++; \ - \ - return cmc_hashtable_primes[i]; \ - } \ - \ - FMOD SNAME *PFX##_union(SNAME *_set1_, SNAME *_set2_); \ - FMOD SNAME *PFX##_intersection(SNAME *_set1_, SNAME *_set2_); \ - FMOD SNAME *PFX##_difference(SNAME *_set1_, SNAME *_set2_); \ - FMOD SNAME *PFX##_symmetric_difference(SNAME *_set1_, SNAME *_set2_); \ - \ - FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \ - { \ - iter->target = target; \ - iter->cursor = 0; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - \ - if (!PFX##_empty(target)) \ - { \ - for (size_t i = 0; i < target->capacity; i++) \ - { \ - if (target->buffer[i].state == ES_FILLED) \ - { \ - iter->first = i; \ - break; \ - } \ - } \ - \ - iter->cursor = iter->first; \ - \ - for (size_t i = target->capacity; i > 0; i--) \ - { \ - if (target->buffer[i - 1].state == ES_FILLED) \ - { \ - iter->last = i - 1; \ - break; \ - } \ - } \ - } \ - } \ - \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter) \ - { \ - return iter->start && iter->cursor == iter->first; \ - } \ - \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter) \ - { \ - return iter->end && iter->cursor == iter->last; \ - } \ - \ - FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \ - { \ - iter->cursor = iter->first; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - } \ - \ - FMOD void PFX##_iter_toend(SNAME##_iter *iter) \ - { \ - iter->cursor = iter->last; \ - iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - } \ - \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *result, size_t *index) \ - { \ - if (iter->end) \ - return false; \ - \ - SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ - \ - *result = scan->value; \ - *index = iter->index; \ - \ - if (iter->cursor == iter->last) \ - iter->end = true; \ - else \ - { \ - iter->index++; \ - while (1) \ - { \ - iter->cursor++; \ - scan = &(iter->target->buffer[iter->cursor]); \ - \ - if (scan->state == ES_FILLED) \ - break; \ - } \ - } \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *result, size_t *index) \ - { \ - if (iter->start) \ - return false; \ - \ - SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ - \ - *result = scan->value; \ - *index = iter->index; \ - \ - if (iter->cursor == iter->first) \ - iter->start = true; \ - else \ - { \ - iter->index--; \ - while (1) \ - { \ - iter->cursor--; \ - scan = &(iter->target->buffer[iter->cursor]); \ - \ - if (scan->state == ES_FILLED) \ - break; \ - } \ - } \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - return true; \ +#define HASHSET_GENERATE_SOURCE(PFX, SNAME, FMOD, V) \ + \ + FMOD bool PFX##_grow(SNAME *_set_); \ + FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element); \ + FMOD size_t PFX##_calculate_size(size_t required); \ + \ + FMOD SNAME *PFX##_new(size_t size, double load, int (*compare)(V, V), size_t (*hash)(V)) \ + { \ + if (size == 0 || load <= 0 || load >= 1) \ + return NULL; \ + \ + size_t real_size = PFX##_calculate_size(size); \ + \ + SNAME *_set_ = malloc(sizeof(SNAME)); \ + \ + if (!_set_) \ + return NULL; \ + \ + _set_->buffer = malloc(sizeof(SNAME##_entry) * real_size); \ + \ + if (!_set_->buffer) \ + { \ + free(_set_); \ + return NULL; \ + } \ + \ + memset(_set_->buffer, 0, sizeof(SNAME##_entry) * real_size); \ + \ + _set_->count = 0; \ + _set_->capacity = real_size; \ + _set_->load = load; \ + _set_->cmp = compare; \ + _set_->hash = hash; \ + \ + return _set_; \ + } \ + \ + FMOD void PFX##_free(SNAME *_set_) \ + { \ + free(_set_->buffer); \ + free(_set_); \ + } \ + \ + FMOD bool PFX##_insert(SNAME *_set_, V element) \ + { \ + if ((double)_set_->capacity * _set_->load <= (double)_set_->count) \ + { \ + if (!PFX##_grow(_set_)) \ + return false; \ + } \ + \ + size_t hash = _set_->hash(element); \ + size_t original_pos = hash % _set_->capacity; \ + size_t pos = original_pos; \ + \ + SNAME##_entry *target = &(_set_->buffer[pos]); \ + \ + if (PFX##_get_entry(_set_, element) != NULL) \ + return false; \ + \ + if (target->state == ES_EMPTY || target->state == ES_DELETED) \ + { \ + target->value = element; \ + target->dist = original_pos - pos; \ + target->state = ES_FILLED; \ + } \ + else \ + { \ + while (true) \ + { \ + pos++; \ + target = &(_set_->buffer[pos % _set_->capacity]); \ + \ + if (target->state == ES_EMPTY || target->state == ES_DELETED) \ + { \ + target->value = element; \ + target->dist = pos - original_pos; \ + target->state = ES_FILLED; \ + break; \ + } \ + else if (target->dist < original_pos - pos) \ + { \ + V tmp = target->value; \ + size_t tmp_dist = target->dist; \ + \ + target->value = element; \ + target->dist = pos - original_pos; \ + \ + element = tmp; \ + original_pos = pos - tmp_dist; \ + } \ + } \ + } \ + \ + _set_->count++; \ + \ + return true; \ + } \ + \ + FMOD bool PFX##_remove(SNAME *_set_, V element) \ + { \ + SNAME##_entry *result = PFX##_get_entry(_set_, element); \ + \ + if (result == NULL) \ + return false; \ + \ + result->value = 0; \ + result->dist = 0; \ + result->state = ES_DELETED; \ + \ + _set_->count--; \ + \ + return true; \ + } \ + \ + FMOD bool PFX##_insert_if(SNAME *_set_, V element, bool condition) \ + { \ + if (condition) \ + return PFX##_insert(_set_, element); \ + \ + return false; \ + } \ + \ + FMOD bool PFX##_remove_if(SNAME *_set_, V element, bool condition) \ + { \ + if (condition) \ + return PFX##_remove(_set_, element); \ + \ + return false; \ + } \ + \ + FMOD V PFX##_max(SNAME *_set_) \ + { \ + if (PFX##_empty(_set_)) \ + return 0; \ + \ + SNAME##_iter iter; \ + V result, max; \ + size_t index; \ + \ + for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ + { \ + PFX##_iter_next(&iter, &result, &index); \ + \ + if (index == 0) \ + max = result; \ + else if (_set_->cmp(result, max) > 0) \ + max = result; \ + } \ + \ + return max; \ + } \ + \ + FMOD V PFX##_min(SNAME *_set_) \ + { \ + if (PFX##_empty(_set_)) \ + return 0; \ + \ + SNAME##_iter iter; \ + V result, min; \ + size_t index; \ + \ + for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ + { \ + PFX##_iter_next(&iter, &result, &index); \ + \ + if (index == 0) \ + min = result; \ + else if (_set_->cmp(result, min) < 0) \ + min = result; \ + } \ + \ + return min; \ + } \ + \ + FMOD bool PFX##_empty(SNAME *_set_) \ + { \ + return _set_->count == 0; \ + } \ + \ + FMOD size_t PFX##_count(SNAME *_set_) \ + { \ + return _set_->count; \ + } \ + \ + FMOD bool PFX##_grow(SNAME *_set_) \ + { \ + size_t new_size = PFX##_calculate_size((size_t)((double)_set_->capacity * 1.5)); \ + \ + SNAME *_new_set_ = PFX##_new(new_size, _set_->load, _set_->cmp, _set_->hash); \ + \ + if (!_new_set_) \ + return false; \ + \ + SNAME##_iter iter; \ + V value; \ + size_t index; \ + \ + for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \ + { \ + PFX##_iter_next(&iter, &value, &index); \ + PFX##_insert(_new_set_, value); \ + } \ + \ + if (_set_->count != _new_set_->count) \ + { \ + PFX##_free(_new_set_); \ + return false; \ + } \ + \ + SNAME##_entry *tmp = _set_->buffer; \ + _set_->buffer = _new_set_->buffer; \ + _new_set_->buffer = tmp; \ + \ + _set_->capacity = _new_set_->capacity; \ + \ + PFX##_free(_new_set_); \ + \ + return true; \ + } \ + \ + FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element) \ + { \ + size_t hash = _set_->hash(element); \ + size_t pos = hash % _set_->capacity; \ + \ + SNAME##_entry *target = &(_set_->buffer[pos % _set_->capacity]); \ + \ + while (target->state == ES_FILLED || target->state == ES_DELETED) \ + { \ + if (_set_->cmp(target->value, element) == 0) \ + return target; \ + \ + pos++; \ + target = &(_set_->buffer[pos % _set_->capacity]); \ + } \ + \ + return NULL; \ + } \ + \ + FMOD size_t PFX##_calculate_size(size_t required) \ + { \ + const size_t count = sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ + \ + if (cmc_hashtable_primes[count - 1] < required) \ + return required; \ + \ + size_t i = 0; \ + while (cmc_hashtable_primes[i] < required) \ + i++; \ + \ + return cmc_hashtable_primes[i]; \ + } \ + \ + FMOD SNAME *PFX##_union(SNAME *_set1_, SNAME *_set2_) \ + { \ + SNAME##_iter iter1, iter2; \ + size_t index; \ + V value; \ + \ + SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \ + \ + if (!_set_r_) \ + return false; \ + \ + PFX##_iter_new(&iter1, _set1_); \ + PFX##_iter_new(&iter2, _set2_); \ + \ + for (PFX##_iter_tostart(&iter1); !PFX##_iter_end(&iter1);) \ + { \ + PFX##_iter_next(&iter1, &value, &index); \ + PFX##_insert(_set_r_, value); \ + } \ + \ + for (PFX##_iter_tostart(&iter2); !PFX##_iter_end(&iter2);) \ + { \ + PFX##_iter_next(&iter2, &value, &index); \ + PFX##_insert(_set_r_, value); \ + } \ + \ + return _set_r_; \ + } \ + \ + FMOD SNAME *PFX##_intersection(SNAME *_set1_, SNAME *_set2_) \ + { \ + SNAME##_iter iter; \ + size_t index; \ + V value; \ + \ + SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \ + \ + if (!_set_r_) \ + return false; \ + \ + SNAME *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_; \ + SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ + \ + PFX##_iter_new(&iter, _set_A_); \ + \ + for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \ + { \ + PFX##_iter_next(&iter, &value, &index); \ + if (PFX##_get_entry(_set_B_, value) != NULL) \ + PFX##_insert(_set_r_, value); \ + } \ + \ + return _set_r_; \ + } \ + \ + FMOD SNAME *PFX##_difference(SNAME *_set1_, SNAME *_set2_) \ + { \ + SNAME##_iter iter; \ + size_t index; \ + V value; \ + \ + SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \ + \ + if (!_set_r_) \ + return false; \ + \ + PFX##_iter_new(&iter, _set1_); \ + \ + for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \ + { \ + PFX##_iter_next(&iter, &value, &index); \ + if (PFX##_get_entry(_set2_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ + } \ + \ + return _set_r_; \ + } \ + \ + FMOD SNAME *PFX##_symmetric_difference(SNAME *_set1_, SNAME *_set2_) \ + { \ + SNAME##_iter iter1, iter2; \ + size_t index; \ + V value; \ + \ + SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \ + \ + if (!_set_r_) \ + return false; \ + \ + PFX##_iter_new(&iter1, _set1_); \ + PFX##_iter_new(&iter2, _set2_); \ + \ + for (PFX##_iter_tostart(&iter1); !PFX##_iter_end(&iter1);) \ + { \ + PFX##_iter_next(&iter1, &value, &index); \ + if (PFX##_get_entry(_set2_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ + } \ + \ + for (PFX##_iter_tostart(&iter2); !PFX##_iter_end(&iter2);) \ + { \ + PFX##_iter_next(&iter2, &value, &index); \ + if (PFX##_get_entry(_set1_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ + } \ + \ + return _set_r_; \ + } \ + \ + FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \ + { \ + iter->target = target; \ + iter->cursor = 0; \ + iter->index = 0; \ + iter->start = true; \ + iter->end = PFX##_empty(target); \ + \ + if (!PFX##_empty(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i].state == ES_FILLED) \ + { \ + iter->first = i; \ + break; \ + } \ + } \ + \ + iter->cursor = iter->first; \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1].state == ES_FILLED) \ + { \ + iter->last = i - 1; \ + break; \ + } \ + } \ + } \ + } \ + \ + FMOD bool PFX##_iter_start(SNAME##_iter *iter) \ + { \ + return iter->start && iter->cursor == iter->first; \ + } \ + \ + FMOD bool PFX##_iter_end(SNAME##_iter *iter) \ + { \ + return iter->end && iter->cursor == iter->last; \ + } \ + \ + FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \ + { \ + iter->cursor = iter->first; \ + iter->index = 0; \ + iter->start = true; \ + iter->end = PFX##_empty(iter->target); \ + } \ + \ + FMOD void PFX##_iter_toend(SNAME##_iter *iter) \ + { \ + iter->cursor = iter->last; \ + iter->index = iter->target->count - 1; \ + iter->start = PFX##_empty(iter->target); \ + iter->end = true; \ + } \ + \ + FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *value, size_t *index) \ + { \ + if (iter->end) \ + return false; \ + \ + SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + \ + *value = scan->value; \ + *index = iter->index; \ + \ + if (iter->cursor == iter->last) \ + iter->end = true; \ + else \ + { \ + iter->index++; \ + while (1) \ + { \ + iter->cursor++; \ + scan = &(iter->target->buffer[iter->cursor]); \ + \ + if (scan->state == ES_FILLED) \ + break; \ + } \ + } \ + \ + iter->start = PFX##_empty(iter->target); \ + \ + return true; \ + } \ + \ + FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *value, size_t *index) \ + { \ + if (iter->start) \ + return false; \ + \ + SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + \ + *value = scan->value; \ + *index = iter->index; \ + \ + if (iter->cursor == iter->first) \ + iter->start = true; \ + else \ + { \ + iter->index--; \ + while (1) \ + { \ + iter->cursor--; \ + scan = &(iter->target->buffer[iter->cursor]); \ + \ + if (scan->state == ES_FILLED) \ + break; \ + } \ + } \ + \ + iter->end = PFX##_empty(iter->target); \ + \ + return true; \ } #endif /* CMC_HASHSET_H */ diff --git a/src/treeset.h b/src/treeset.h index be5925a..77b316d 100644 --- a/src/treeset.h +++ b/src/treeset.h @@ -562,23 +562,26 @@ { \ SNAME##_iter iter1, iter2; \ size_t index; \ - V var; \ + V value; \ \ SNAME *_set_r_ = PFX##_new(_set1_->cmp); \ \ + if (!_set_r_) \ + return false; \ + \ PFX##_iter_new(&iter1, _set1_); \ PFX##_iter_new(&iter2, _set2_); \ \ for (PFX##_iter_tostart(&iter1); !PFX##_iter_end(&iter1);) \ { \ - PFX##_iter_next(&iter1, &var, &index); \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter1, &value, &index); \ + PFX##_insert(_set_r_, value); \ } \ \ for (PFX##_iter_tostart(&iter2); !PFX##_iter_end(&iter2);) \ { \ - PFX##_iter_next(&iter2, &var, &index); \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter2, &value, &index); \ + PFX##_insert(_set_r_, value); \ } \ \ return _set_r_; \ @@ -588,9 +591,13 @@ { \ SNAME##_iter iter; \ size_t index; \ - V var; \ + V value; \ \ SNAME *_set_r_ = PFX##_new(_set1_->cmp); \ + \ + if (!_set_r_) \ + return false; \ + \ SNAME *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_; \ SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ \ @@ -598,9 +605,9 @@ \ for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \ { \ - PFX##_iter_next(&iter, &var, &index); \ - if (PFX##_get_node(_set_B_, var) != NULL) \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter, &value, &index); \ + if (PFX##_get_node(_set_B_, value) != NULL) \ + PFX##_insert(_set_r_, value); \ } \ \ return _set_r_; \ @@ -610,17 +617,20 @@ { \ SNAME##_iter iter; \ size_t index; \ - V var; \ + V value; \ \ SNAME *_set_r_ = PFX##_new(_set1_->cmp); \ \ + if (!_set_r_) \ + return false; \ + \ PFX##_iter_new(&iter, _set1_); \ \ for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \ { \ - PFX##_iter_next(&iter, &var, &index); \ - if (PFX##_get_node(_set2_, var) == NULL) \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter, &value, &index); \ + if (PFX##_get_node(_set2_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ } \ \ return _set_r_; \ @@ -630,25 +640,28 @@ { \ SNAME##_iter iter1, iter2; \ size_t index; \ - V var; \ + V value; \ \ SNAME *_set_r_ = PFX##_new(_set1_->cmp); \ \ + if (!_set_r_) \ + return false; \ + \ PFX##_iter_new(&iter1, _set1_); \ PFX##_iter_new(&iter2, _set2_); \ \ for (PFX##_iter_tostart(&iter1); !PFX##_iter_end(&iter1);) \ { \ - PFX##_iter_next(&iter1, &var, &index); \ - if (PFX##_get_node(_set2_, var) == NULL) \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter1, &value, &index); \ + if (PFX##_get_node(_set2_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ } \ \ for (PFX##_iter_tostart(&iter2); !PFX##_iter_end(&iter2);) \ { \ - PFX##_iter_next(&iter2, &var, &index); \ - if (PFX##_get_node(_set1_, var) == NULL) \ - PFX##_insert(_set_r_, var); \ + PFX##_iter_next(&iter2, &value, &index); \ + if (PFX##_get_node(_set1_, value) == NULL) \ + PFX##_insert(_set_r_, value); \ } \ \ return _set_r_; \