static void destroy_ship(struct GameState *game_state, struct Ship *ship)
{
struct UIntHashPair *pair = find_pair(&game_state->ship_id_map, ship->id);
ASSERT_NOT_NULL(pair);
uint32 array_index = pair->value;
ASSERT(array_index < game_state->ship_count);
remove_pair(&game_state->ship_id_map, ship->id);
// Ship is already at the end of the array.
if (array_index == game_state->ship_count - 1)
{
--game_state->ship_count;
return;
}
// Swap the destroyed ship with the last active ship in the array.
struct Ship last = game_state->ships[game_state->ship_count - 1];
game_state->ships[array_index] = last;
--game_state->ship_count;
// Update the ship ID map with the swapped ship's new array index.
struct UIntHashPair *last_pair = find_pair(&game_state->ship_id_map, last.id);
ASSERT_NOT_NULL(last_pair);
last_pair->value = array_index;
}
/*
* Searches a tree of pairs for a specific parameter
*/
static ini_pair *find_pair(ini_pair *root, const char *name) {
int c;
if(!root) return NULL;
c = my_stricmp(root->param, name);
if(c == 0)
return root;
else if(c < 0)
return find_pair(root->left, name);
else
return find_pair(root->right, name);
}
static void emplace(struct UIntHashMap *map, uint32 key, uint32 value)
{
struct UIntHashPair *pair = find_pair(map, key);
ASSERT(pair == NULL);
uint32 hash_map_size = ARRAY_SIZE(map->buckets);
uint32 hash = key;
uint32 bucket = hash % hash_map_size;
pair = &map->buckets[bucket];
while ((pair->key != NULL_UINT_HASH_KEY) && (pair->key != key))
{
bucket = (bucket + 1) % hash_map_size;
pair = &map->buckets[bucket];
if (pair->key == NULL_UINT_HASH_KEY)
{
pair->key = key;
pair->value = value;
return;
}
}
pair->key = key;
pair->value = value;
}
bool insert_uniq(std::multimap<K, V>& map, const std::pair<K, V>& pair)
{
if (find_pair(map, pair) == map.end()) {
map.insert(pair);
return true;
}
return false;
}
static void remove_pair(struct UIntHashMap *map, uint32 key)
{
struct UIntHashPair *pair = find_pair(map, key);
ASSERT(pair != NULL);
// Mark the pair as null.
pair->key = NULL_UINT_HASH_KEY;
pair->value = 0;
}
static pl_ini_pair* locate(const pl_ini_file *file,
const char *section_name,
const char *key_name)
{
pl_ini_section *section;
if (!(section = find_section(file, section_name)))
return NULL;
return find_pair(section, key_name);
}
static struct Ship *get_ship_by_id(struct GameState *game_state, uint32 id)
{
struct UIntHashPair *pair = find_pair(&game_state->ship_id_map, id);
if (pair == NULL)
return NULL;
uint32 array_index = pair->value;
ASSERT(array_index < game_state->ship_count);
struct Ship *ship = &game_state->ships[array_index];
return ship;
}
//validation
template<class X> void splay_forest<X>::test_find (Pos eqn)
{
//test find_pair
Pos pos = find_pair(get_root(eqn), get_key(eqn), get_val(eqn));
POMAGMA_ASSERT(pos, "invalid: eqn not found in own " << nameof<X>() << " tree");
POMAGMA_ASSERT(pos == eqn,
"invalid: wrong eqn found in own " << nameof<X>() << " tree");
//test find_key
pos = find_key(get_root(eqn), get_key(eqn));
POMAGMA_ASSERT(pos, "invalid: key not found in own " << nameof<X>() << " tree");
POMAGMA_ASSERT(get_key(pos) == get_key(eqn),
"invalid: wrong key found in own " << nameof<X>() << " tree");
}
static pl_ini_pair* locate_or_create(pl_ini_file *file,
const char *section_name,
const char *key_name)
{
pl_ini_section *section = find_section(file, section_name);
pl_ini_pair *pair = NULL;
if (section)
pair = find_pair(section, key_name);
else
{
/* Create section */
section = create_section(section_name);
if (!file->head)
file->head = section;
else
{
pl_ini_section *s;
for (s = file->head; s->next; s = s->next); /* Find the tail */
s->next = section;
}
}
if (!pair)
{
/* Create pair */
pair = (pl_ini_pair*)malloc(sizeof(pl_ini_pair));
pair->key = strdup(key_name);
pair->value = NULL;
pair->next = NULL;
if (!section->head)
section->head = pair;
else
{
pl_ini_pair *p;
for (p = section->head; p->next; p = p->next); /* Find the tail */
p->next = pair;
}
}
return pair;
}
/*
* Finds a specific parameter-value pair in the configuration file
*/
static ini_pair *find_param(const struct ini_file *ini,
const char *sec,
const char *par) {
ini_section *s;
ini_pair *p;
if(!ini) return NULL;
if(sec) {
s = find_section(ini->sections, sec);
if(!s) return NULL;
p = s->fields;
} else
p = ini->globals;
if(!p) return NULL;
return find_pair(p, par);
}
std::pair<int,int> KeyBindings::GetEventPair(QKeySequence sequence)
{
std::pair<int,int> find_pair(0,0);
KeyBindingList::const_iterator iter = bindings_.begin();
KeyBindingList::const_iterator end = bindings_.end();
while (iter != end)
{
Binding binding = (*iter);
if (binding.sequence == sequence)
{
find_pair.first = binding.event_ids.enter_id;
find_pair.second = binding.event_ids.leave_id;
break;
}
iter++;
}
return find_pair;
}
int
colmgr_get_pair(int fg, int bg)
{
assert(initialized && "colmgr_init() must be called before this function!");
if(fg < 0)
{
fg = -1;
}
if(bg < 0)
{
bg = -1;
}
int p = find_pair(fg, bg);
if(p != -1)
{
return p;
}
p = allocate_pair(fg, bg);
return (p == -1) ? 0 : p;
}
int
colmgr_get_pair(int fg, int bg)
{
int p;
if(fg < 0)
{
fg = -1;
}
if(bg < 0)
{
bg = -1;
}
p = find_pair(fg, bg);
if(p != -1)
{
return p;
}
p = allocate_pair(fg, bg);
return (p == -1) ? 0 : p;
}
int
colmgr_alloc_pair(int fg, int bg)
{
const int pair_index = find_pair(fg, bg);
return (pair_index != -1) ? pair_index : allocate_pair(fg, bg);
}
void print_disc_info(netmd_dev_handle* devh, minidisc* md)
{
uint8_t i = 0;
int size = 1;
uint8_t g, group = 0, lastgroup = 0;
unsigned char bitrate_id;
unsigned char flags;
unsigned char channel;
char *name, buffer[256];
struct netmd_track time;
struct netmd_pair const *trprot, *bitrate;
trprot = bitrate = 0;
for(i = 0; size >= 0; i++)
{
size = netmd_request_title(devh, i, buffer, 256);
if(size < 0)
{
break;
}
/* Figure out which group this track is in */
for( group = 0, g = 1; g < md->group_count; g++ )
{
if( (md->groups[g].start <= i+1U) && (md->groups[g].finish >= i+1U ))
{
group = g;
break;
}
}
/* Different to the last group? */
if( group != lastgroup )
{
lastgroup = group;
if( group ) /* Group 0 is 'no group' */
{
printf("Group: %s\n", md->groups[group].name);
}
}
/* Indent tracks which are in a group */
if( group )
{
printf(" ");
}
netmd_request_track_time(devh, i, &time);
netmd_request_track_flags(devh, i, &flags);
netmd_request_track_bitrate(devh, i, &bitrate_id, &channel);
trprot = find_pair(flags, trprot_settings);
bitrate = find_pair(bitrate_id, bitrates);
/* Skip 'LP:' prefix... the codec type shows up in the list anyway*/
if( strncmp( buffer, "LP:", 3 ))
{
name = buffer;
}
else
{
name = buffer + 3;
}
printf("Track %2i: %-6s %6s - %02i:%02i:%02i - %s\n",
i, trprot->name, bitrate->name, time.minute,
time.second, time.tenth, name);
}
/* XXX - This needs a rethink with the above method */
/* groups may not have tracks, print the rest. */
printf("\n--Empty Groups--\n");
for(group=1; group < md->group_count; group++)
{
if(md->groups[group].start == 0 && md->groups[group].finish == 0) {
printf("Group: %s\n", md->groups[group].name);
}
}
printf("\n\n");
}
__normal_call void_type roll_back (
list_type &_tnew,
list_type &_told
)
{
iptr_type _npos ;
iptr_type _fpos ;
for (auto _tpos = _tnew.head();
_tpos != _tnew.tend();
++_tpos )
{
for (_npos = tria_pred::_dims+1;
_npos-- != +0 ; )
{
node(tria(*_tpos )
->node( _npos))
->next() = null_flag();
}
}
for (auto _tpos = _told.head();
_tpos != _told.tend();
++_tpos )
{
for (_npos = tria_pred::_dims+1;
_npos-- != +0 ; )
{
node(tria(*_tpos )
->node( _npos))
->next() = *_tpos ;
}
for (_fpos = tria_pred::_dims+1;
_fpos-- != +0 ; )
{
iptr_type _tadj;
iptr_type _fadj;
iptr_type _flag;
find_pair(*_tpos, _tadj ,
_fpos, _fadj, _flag ) ;
push_pair(*_tpos, _tadj ,
_fpos, _fadj ,
_flag) ;
}
}
for (auto _tpos = _tnew.head();
_tpos != _tnew.tend();
++_tpos )
{
for (_npos = tria_pred::_dims+1;
_npos-- != +0 ; )
{
if (node(tria(*_tpos )
->node( _npos))
->mark()>= +0 )
if (node(tria(*_tpos )
->node( _npos))
->next() == null_flag())
{
_put_node(tria(*_tpos )
->node( _npos)) ;
}
}
}
for (auto _tpos = _tnew.head();
_tpos != _tnew.tend();
++_tpos )
{
_put_tria(*_tpos) ;
}
}
template<class X> bool splay_forest<X>::is_inserted (Pos p)
{
Pos found = find_pair(get_root(p), get_key(p), get_val(p), false);
POMAGMA_ASSERT5((!found) or (found==p), "two identical pos's have been inserted")
return found;
}
