#endif
}
-u16 AreaStore::size() const
+const Area *AreaStore::getArea(u32 id) const
{
- return areas_map.size();
+ AreaMap::const_iterator it = areas_map.find(id);
+ if (it == areas_map.end())
+ return nullptr;
+ return &it->second;
}
-const Area *AreaStore::getArea(u32 id) const
+void AreaStore::serialize(std::ostream &os) const
{
- const Area *res = NULL;
- std::map<u32, Area>::const_iterator itr = areas_map.find(id);
- if (itr != areas_map.end()) {
- res = &itr->second;
+ writeU8(os, 0); // Serialisation version
+
+ // TODO: Compression?
+ writeU16(os, areas_map.size());
+ for (AreaMap::const_iterator it = areas_map.begin();
+ it != areas_map.end(); ++it) {
+ const Area &a = it->second;
+ writeV3S16(os, a.minedge);
+ writeV3S16(os, a.maxedge);
+ writeU16(os, a.data.size());
+ os.write(a.data.data(), a.data.size());
}
- return res;
}
-#if 0
-Currently, serialisation is commented out. This is because of multiple reasons:
-1. Why do we store the areastore into a file, why not into the database?
-2. We don't use libspatial's serialisation, but we should, or perhaps not, because
- it would remove the ability to switch. Perhaps write migration routines?
-3. Various things need fixing, e.g. the size is serialized as
- c++ implementation defined size_t
-bool AreaStore::deserialize(std::istream &is)
+void AreaStore::deserialize(std::istream &is)
{
u8 ver = readU8(is);
- if (ver != 1)
- return false;
- u16 count_areas = readU16(is);
- for (u16 i = 0; i < count_areas; i++) {
- // deserialize an area
+ if (ver != 0)
+ throw SerializationError("Unknown AreaStore "
+ "serialization version!");
+
+ u16 num_areas = readU16(is);
+ for (u32 i = 0; i < num_areas; ++i) {
Area a;
- a.id = readU32(is);
a.minedge = readV3S16(is);
a.maxedge = readV3S16(is);
- a.datalen = readU16(is);
- a.data = new char[a.datalen];
- is.read((char *) a.data, a.datalen);
- insertArea(a);
+ u16 data_len = readU16(is);
+ char *data = new char[data_len];
+ is.read(data, data_len);
+ a.data = std::string(data, data_len);
+ insertArea(&a);
+ delete [] data;
}
- return true;
-}
-
-
-static bool serialize_area(void *ostr, Area *a)
-{
- std::ostream &os = *((std::ostream *) ostr);
- writeU32(os, a->id);
- writeV3S16(os, a->minedge);
- writeV3S16(os, a->maxedge);
- writeU16(os, a->datalen);
- os.write(a->data, a->datalen);
-
- return false;
-}
-
-
-void AreaStore::serialize(std::ostream &os) const
-{
- // write initial data
- writeU8(os, 1); // serialisation version
- writeU16(os, areas_map.size()); //DANGER: not platform independent
- forEach(&serialize_area, &os);
}
-#endif
-
void AreaStore::invalidateCache()
{
if (m_cache_enabled) {
bool VectorAreaStore::insertArea(Area *a)
{
- a->id = getNextId();
+ if (a->id == U32_MAX)
+ a->id = getNextId();
std::pair<AreaMap::iterator, bool> res =
areas_map.insert(std::make_pair(a->id, *a));
if (!res.second)
}
}
-#if 0
-bool SimpleAreaStore::forEach(bool (*callback)(void *args, Area *a), void *args) const
-{
- for (size_t i = 0; i < m_areas.size(); ++i) {
- if (callback(m_areas[i], arg)) {
- return true;
- }
- }
- return false;
-}
-#endif
-
#if USE_SPATIAL
static inline SpatialIndex::Region get_spatial_region(const v3s16 minedge,
bool SpatialAreaStore::insertArea(Area *a)
{
- a->id = getNextId();
+ if (a->id == U32_MAX)
+ a->id = getNextId();
if (!areas_map.insert(std::make_pair(a->id, *a)).second)
// ID is not unique
return false;
- m_tree->insertData(0, NULL, get_spatial_region(a->minedge, a->maxedge), a->id);
+ m_tree->insertData(0, nullptr, get_spatial_region(a->minedge, a->maxedge), a->id);
invalidateCache();
return true;
}
Area *a = &itr->second;
bool result = m_tree->deleteData(get_spatial_region(a->minedge,
a->maxedge), id);
+ areas_map.erase(itr);
invalidateCache();
return result;
} else {
}
}
-#if 0
-bool SpatialAreaStore::forEach(bool (*callback)(void *args, Area *a), void *args) const
-{
- // TODO ?? (this is only needed for serialisation, but libspatial has its own serialisation)
- return false;
-}
-#endif
-
SpatialAreaStore::~SpatialAreaStore()
{
delete m_tree;