idex.cpp

Go to the documentation of this file.

/*__            ___                 ***************************************
/   \          /   \          Copyright (c) 1996-2020 Freeciv21 and Freeciv
\_   \        /  __/          contributors. This file is part of Freeciv21.
 _\   \      /  /__     Freeciv21 is free software: you can redistribute it
 \___  \____/   __/    and/or modify it under the terms of the GNU  General
     \_       _/          Public License  as published by the Free Software
       | @ @  \_               Foundation, either version 3 of the  License,
       |                              or (at your option) any later version.
     _/     /\                  You should have received  a copy of the GNU
    /o)  (o/\ \_                General Public License along with Freeciv21.
    \_____/ /                     If not, see https://www.gnu.org/licenses/.
      \____/        ********************************************************/
 
// utility
#include "log.h"
 
// common
#include "city.h"
#include "unit.h"
 
#include "idex.h"
 
void idex_init(struct world *iworld)
{
  iworld->cities = new QHash<int, const struct city *>;
  iworld->units = new QHash<int, const struct unit *>;
}
 
void idex_free(struct world *iworld)
{
  delete iworld->cities;
  delete iworld->units;
  iworld->cities = nullptr;
  iworld->units = nullptr;
}
 
void idex_register_city(struct world *iworld, struct city *pcity)
{
  const struct city *old;
 
  if (iworld->cities->contains(pcity->id)) {
    old = iworld->cities->value(pcity->id);
    fc_assert_ret_msg(nullptr == old,
                      "IDEX: city collision: new %d %p %s, old %d %p %s",
                      pcity->id, (void *) pcity, city_name_get(pcity),
                      old->id, (void *) old, city_name_get(old));
  }
  iworld->cities->insert(pcity->id, pcity);
}
 
void idex_register_unit(struct world *iworld, struct unit *punit)
{
  const struct unit *old;
 
  if (iworld->units->contains(punit->id)) {
    old = iworld->units->value(punit->id);
    fc_assert_ret_msg(nullptr == old,
                      "IDEX: unit collision: new %d %p %s, old %d %p %s",
                      punit->id, (void *) punit, unit_rule_name(punit),
                      old->id, (void *) old, unit_rule_name(old));
  }
  iworld->units->insert(punit->id, punit);
}
 
void idex_unregister_city(struct world *iworld, struct city *pcity)
{
  const struct city *old;
 
  if (!iworld->units->contains(pcity->id)) {
    old = pcity;
    fc_assert_ret_msg(nullptr != old, "IDEX: city unreg missing: %d %p %s",
                      pcity->id, (void *) pcity, city_name_get(pcity));
    fc_assert_ret_msg(old == pcity,
                      "IDEX: city unreg mismatch: "
                      "unreg %d %p %s, old %d %p %s",
                      pcity->id, (void *) pcity, city_name_get(pcity),
                      old->id, (void *) old, city_name_get(old));
  }
  iworld->cities->remove(pcity->id);
}
 
void idex_unregister_unit(struct world *iworld, struct unit *punit)
{
  const struct unit *old;
 
  if (!iworld->units->contains(punit->id)) {
    old = punit;
    fc_assert_ret_msg(nullptr != old, "IDEX: unit unreg missing: %d %p %s",
                      punit->id, (void *) punit, unit_rule_name(punit));
    fc_assert_ret_msg(old == punit,
                      "IDEX: unit unreg mismatch: "
                      "unreg %d %p %s, old %d %p %s",
                      punit->id, (void *) punit, unit_rule_name(punit),
                      old->id, (void *) old, unit_rule_name(old));
  }
  iworld->units->remove(punit->id);
}
 
struct city *idex_lookup_city(struct world *iworld, int id)
{
  const struct city *pcity;
 
  pcity = iworld->cities->value(id);
 
  return const_cast<struct city *>(pcity);
}
 
struct unit *idex_lookup_unit(struct world *iworld, int id)
{
  const struct unit *punit;
 
  punit = iworld->units->value(id);
 
  return const_cast<struct unit *>(punit);
}