void map_init_copy(map_t* pt_mapdest, const map_t* cpt_mapsrc)
{
assert(pt_mapdest != NULL && cpt_mapsrc != NULL);
assert(
pt_mapdest->_t_pair._t_firsttypesize ==
cpt_mapsrc->_t_pair._t_firsttypesize &&
pt_mapdest->_t_pair._t_secondtypesize ==
cpt_mapsrc->_t_pair._t_secondtypesize);
assert(
strncmp(
pt_mapdest->_t_pair._sz_firsttypename,
cpt_mapsrc->_t_pair._sz_firsttypename,
_ELEM_TYPE_NAME_SIZE) == 0 &&
strncmp(
pt_mapdest->_t_pair._sz_secondtypename,
cpt_mapsrc->_t_pair._sz_secondtypename,
_ELEM_TYPE_NAME_SIZE) == 0);
/* initialize dest map with src map attribute */
map_init(pt_mapdest);
/* insert all element from src to dest */
if(!map_empty(cpt_mapsrc))
{
map_insert_range(pt_mapdest, map_begin(cpt_mapsrc), map_end(cpt_mapsrc));
}
}
void map_assign(map_t* pt_mapdest, const map_t* cpt_mapsrc)
{
assert(pt_mapdest != NULL && cpt_mapsrc != NULL);
assert(_same_map_pair_type(&pt_mapdest->_t_pair, &cpt_mapsrc->_t_pair));
/* destroy dest map */
map_destroy(pt_mapdest);
/* initialize dest map with src map attribute */
map_init(pt_mapdest);
/* insert all element from src to dest */
if(!map_empty(cpt_mapsrc))
{
map_insert_range(pt_mapdest, map_begin(cpt_mapsrc), map_end(cpt_mapsrc));
}
}
static void sample_particle_gausian(const map_t* map, particle_t *particle,
const real_t initial_sample_pose_x, const real_t initial_sample_pose_y, const real_t initial_sample_pose_phi,
const real_t initial_sample_std_xy, const real_t initial_sample_std_phi) {
while (TRUE) {
int x, y;
particle->pose.x = random_gaussian(initial_sample_std_xy) + initial_sample_pose_x;
particle->pose.y = random_gaussian(initial_sample_std_xy) + initial_sample_pose_y;
particle->pose.th = random_gaussian(initial_sample_std_phi) + initial_sample_pose_phi;
pose_to_cell(&particle->pose, map, &x, &y);
if (map_validate_index(map, x, y)) {
if (map_empty(map, x, y)) {
break;
}
}
}
}
/**
* Assign map container.
*/
void map_assign(map_t* pmap_dest, const map_t* cpmap_src)
{
assert(pmap_dest != NULL);
assert(cpmap_src != NULL);
assert(_pair_is_inited(&pmap_dest->_pair_temp));
assert(_pair_is_inited(&cpmap_src->_pair_temp));
assert(_map_same_pair_type_ex(&pmap_dest->_pair_temp, &cpmap_src->_pair_temp));
/* clear */
map_clear(pmap_dest);
/* insert all element from src to dest */
if(!map_empty(cpmap_src))
{
map_insert_range(pmap_dest, map_begin(cpmap_src), map_end(cpmap_src));
}
}
static void sample_particle_uniform(const map_t* map, particle_t *particle,
const real_t pose_x, const real_t pose_y, const real_t pose_phi,
const real_t x_min, const real_t x_max,
const real_t y_min, const real_t y_max,
const real_t phi_min, const real_t phi_max) {
while (TRUE) {
int x, y;
particle->pose.x = random_uniform() * (x_max - x_min) + x_min + pose_x;
particle->pose.y = random_uniform() * (y_max - y_min) + y_min + pose_y;
particle->pose.th = random_uniform() * (phi_max - phi_min) + phi_min + pose_phi;
pose_to_cell(&particle->pose, map, &x, &y);
if (map_validate_index(map, x, y)) {
if (map_empty(map, x, y)) {
break;
}
}
}
}
/**
* Initialize map container with specific range and compare function.
*/
void map_init_copy_range_ex(map_t* pmap_dest, map_iterator_t it_begin, map_iterator_t it_end, binary_function_t bfun_keycompare)
{
assert(pmap_dest != NULL);
assert(_pair_is_created(&pmap_dest->_pair_temp));
assert(_GET_MAP_CONTAINER_TYPE(it_begin) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_begin) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER_TYPE(it_end) == _MAP_CONTAINER);
assert(_GET_MAP_ITERATOR_TYPE(it_end) == _BIDIRECTIONAL_ITERATOR);
assert(_GET_MAP_CONTAINER(it_begin) != pmap_dest);
assert(_GET_MAP_CONTAINER(it_end) != pmap_dest);
assert(_GET_MAP_CONTAINER(it_begin) == _GET_MAP_CONTAINER(it_end));
assert(_map_same_pair_type(&pmap_dest->_pair_temp, &_GET_MAP_CONTAINER(it_begin)->_pair_temp));
/* initialize dest map with src map attribute */
map_init_ex(pmap_dest, bfun_keycompare);
/* insert all element from src to dest */
if(!map_empty(_GET_MAP_CONTAINER(it_begin)))
{
map_insert_range(pmap_dest, it_begin, it_end);
}
}
/**
* Initialize map container with map.
*/
void map_init_copy(map_t* pmap_dest, const map_t* cpmap_src)
{
assert(pmap_dest != NULL);
assert(cpmap_src != NULL);
assert(_pair_is_created(&pmap_dest->_pair_temp));
assert(_pair_is_inited(&cpmap_src->_pair_temp));
/* initialize dest map with src map attribute */
map_init(pmap_dest);
pmap_dest->_bfun_keycompare = cpmap_src->_bfun_keycompare;
pmap_dest->_bfun_valuecompare = cpmap_src->_bfun_valuecompare;
pmap_dest->_pair_temp._bfun_mapkeycompare = cpmap_src->_pair_temp._bfun_mapkeycompare;
pmap_dest->_pair_temp._bfun_mapvaluecompare = cpmap_src->_pair_temp._bfun_mapvaluecompare;
assert(_map_same_pair_type_ex(&pmap_dest->_pair_temp, &cpmap_src->_pair_temp));
/* insert all element from src to dest */
if(!map_empty(cpmap_src))
{
map_insert_range(pmap_dest, map_begin(cpmap_src), map_end(cpmap_src));
}
}
void map_init_copy_range_cmp(
map_t* pt_mapdest, map_iterator_t t_begin, map_iterator_t t_end,
int (*pfun_key_cmp)(const void*, const void*))
{
assert(pt_mapdest != NULL);
assert(
_GET_MAP_CONTAINER_TYPE(&t_begin) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_begin) == _BIDIRECTIONAL_ITERATOR &&
_GET_MAP_CONTAINER_TYPE(&t_end) == _MAP_CONTAINER &&
_GET_MAP_ITERATOR_TYPE(&t_end) == _BIDIRECTIONAL_ITERATOR);
assert(
_GET_MAP_CONTAINER(&t_begin) != pt_mapdest &&
_GET_MAP_CONTAINER(&t_end) != pt_mapdest &&
_GET_MAP_CONTAINER(&t_begin) == _GET_MAP_CONTAINER(&t_end));
assert(
pt_mapdest->_t_pair._t_firsttypesize ==
_GET_MAP_CONTAINER(&t_begin)->_t_pair._t_firsttypesize &&
pt_mapdest->_t_pair._t_secondtypesize ==
_GET_MAP_CONTAINER(&t_begin)->_t_pair._t_secondtypesize);
assert(
strncmp(
pt_mapdest->_t_pair._sz_firsttypename,
_GET_MAP_CONTAINER(&t_begin)->_t_pair._sz_firsttypename,
_ELEM_TYPE_NAME_SIZE) == 0 &&
strncmp(
pt_mapdest->_t_pair._sz_secondtypename,
_GET_MAP_CONTAINER(&t_begin)->_t_pair._sz_secondtypename,
_ELEM_TYPE_NAME_SIZE) == 0);
/* initialize dest map with src map attribute */
map_init(pt_mapdest);
pt_mapdest->_t_pair._pfun_first_cmp = pfun_key_cmp;
/* insert all element from src to dest */
if(!map_empty(_GET_MAP_CONTAINER(&t_begin)))
{
map_insert_range(pt_mapdest, t_begin, t_end);
}
}
void
PackageSet::clear()
{
map_empty(&pImpl->map);
}
int main(int argc, char *argv[]) {
const char *key = "404";
const int values[3] = { 0, 1, 2 };
plan_no_plan();
Map *map = map_new();
ok(map && map_empty(map), "Creation");
ok(map_first(map, &key) == NULL && strcmp(key, "404") == 0, "First on empty map");
ok(map_empty(map_prefix(map, "404")), "Empty prefix map");
ok(!map_get(map, "404"), "Get non-existing key");
ok(!map_contains(map, "404"), "Contains non-existing key");
ok(!map_closest(map, "404") && errno == ENOENT, "Closest non-existing key");
ok(!map_put(map, "a", NULL) && errno == EINVAL && map_empty(map) && !map_get(map, "a"), "Put NULL value");
ok(map_put(map, "a", &values[0]) && !map_empty(map) && get(map, "a", &values[0]), "Put 1");
ok(map_first(map, &key) == &values[0] && strcmp(key, "a") == 0, "First on map with 1 value");
key = NULL;
ok(map_first(map_prefix(map, "a"), &key) == &values[0] && strcmp(key, "a") == 0, "First on prefix map");
ok(map_contains(map, "a"), "Contains existing key");
ok(map_closest(map, "a") == &values[0], "Closest match existing key");
ok(!map_put(map, "a", &values[1]) && errno == EEXIST && get(map, "a", &values[0]), "Put duplicate");
ok(map_put(map, "cafebabe", &values[2]) && get(map, "cafebabe", &values[2]), "Put 2");
ok(map_put(map, "cafe", &values[1]) && get(map, "cafe", &values[1]), "Put 3");
key = NULL;
ok(map_first(map_prefix(map, "cafe"), &key) == &values[1] && strcmp(key, "cafe") == 0, "First on prefix map with multiple suffixes");
Map *copy = map_new();
ok(map_copy(copy, map), "Copy");
ok(!map_empty(copy), "Not empty after copying");
map_iterate(copy, compare, map);
map_iterate(map, compare, copy);
int counter = 0;
map_iterate(copy, once, &counter);
ok(counter == 1, "Iterate stop condition");
ok(!map_get(map, "ca") && !map_closest(map, "ca") && errno == 0, "Closest ambigious");
int visited[] = { 0, 0, 0 };
map_iterate(map, visit, &visited);
ok(visited[0] == 1 && visited[1] == 1 && visited[2] == 1, "Iterate map");
memset(visited, 0, sizeof visited);
order_counter = 0;
map_iterate(map, order, &visited);
ok(visited[0] == 1 && visited[1] == 2 && visited[2] == 3, "Ordered iteration");
memset(visited, 0, sizeof visited);
map_iterate(map_prefix(map, "ca"), visit, &visited);
ok(visited[0] == 0 && visited[1] == 1 && visited[2] == 1, "Iterate sub map");
memset(visited, 0, sizeof visited);
order_counter = 0;
map_iterate(map_prefix(map, "ca"), order, &visited);
ok(visited[0] == 0 && visited[1] == 1 && visited[2] == 2, "Ordered sub map iteration");
ok(map_empty(map_prefix(map, "404")), "Empty map for non-existing prefix");
ok(!map_delete(map, "404"), "Delete non-existing key");
ok(map_delete(map, "cafe") == &values[1] && !map_get(map, "cafe"), "Delete existing key");
ok(map_closest(map, "cafe") == &values[2], "Closest unambigious");
ok(map_put(map, "cafe", &values[1]) && get(map, "cafe", &values[1]), "Put 3 again");
map_clear(map);
ok(map_empty(map), "Empty after clean");
map_free(map);
map_free(copy);
return exit_status();
}
