bool LocationIndex::LoadAdminRegion(FileScanner& scanner,
AdminRegion& region) const
{
uint32_t aliasCount;
if (!scanner.GetPos(region.regionOffset)) {
return false;
}
if (!scanner.ReadFileOffset(region.dataOffset)) {
return false;
}
if (!scanner.ReadFileOffset(region.parentRegionOffset)) {
return false;
}
if (!scanner.Read(region.name)) {
return false;
}
if (!Read(scanner,
region.object)) {
return false;
}
if (!scanner.ReadNumber(aliasCount)) {
return false;
}
region.aliases.clear();
if (aliasCount>0) {
region.aliases.resize(aliasCount);
for (size_t i=0; i<aliasCount; i++) {
if (!scanner.Read(region.aliases[i].name)) {
return false;
}
if (!scanner.ReadFileOffset(region.aliases[i].objectOffset,
bytesForNodeFileOffset)) {
return false;
}
}
}
return !scanner.HasError();
}
bool DebugDatabase::ResolveReferences(const std::string& mapName,
RefType fileType,
const std::set<ObjectOSMRef>& ids,
const std::set<ObjectFileRef>& fileOffsets,
std::map<ObjectOSMRef,ObjectFileRef>& idFileOffsetMap,
std::map<ObjectFileRef,ObjectOSMRef>& fileOffsetIdMap)
{
FileScanner scanner;
uint32_t entryCount;
std::string filename=AppendFileToDir(path,mapName);
if (!scanner.Open(filename,FileScanner::LowMemRandom,false)) {
std::cerr << "Cannot open file '" << scanner.GetFilename() << "'!" << std::endl;
return false;
}
if (!scanner.Read(entryCount)) {
return false;
}
for (size_t i=1; i<=entryCount; i++) {
Id id;
uint8_t typeByte;
OSMRefType osmType;
FileOffset fileOffset;
if (!scanner.Read(id)) {
return false;
}
if (!scanner.Read(typeByte)) {
return false;
}
osmType=(OSMRefType)typeByte;
if (!scanner.ReadFileOffset(fileOffset)) {
return false;
}
ObjectOSMRef osmRef(id,osmType);
ObjectFileRef fileRef(fileOffset,fileType);
if (ids.find(osmRef)!=ids.end() ||
fileOffsets.find(fileRef)!=fileOffsets.end()) {
idFileOffsetMap.insert(std::make_pair(osmRef,fileRef));
fileOffsetIdMap.insert(std::make_pair(fileRef,osmRef));
}
}
return scanner.Close();
}
bool LocationIndex::Read(FileScanner& scanner,
ObjectFileRef& object) const
{
uint8_t type;
FileOffset fileOffset;
if (!scanner.Read(type)) {
return false;
}
switch (type) {
case refNode:
if (!scanner.ReadFileOffset(fileOffset,
bytesForNodeFileOffset)) {
return false;
}
break;
case refArea:
if (!scanner.ReadFileOffset(fileOffset,
bytesForAreaFileOffset)) {
return false;
}
break;
case refWay:
if (!scanner.ReadFileOffset(fileOffset,
bytesForWayFileOffset)) {
return false;
}
break;
default:
return false;
}
object.Set(fileOffset,
(RefType)type);
return true;
}
bool LocationIndex::VisitAdminRegions(AdminRegionVisitor& visitor) const
{
FileScanner scanner;
if (!scanner.Open(AppendFileToDir(path,
FILENAME_LOCATION_IDX),
FileScanner::LowMemRandom,
false)) {
log.Error() << "Cannot open file '" << scanner.GetFilename() << "'!";
return false;
}
if (!scanner.SetPos(indexOffset)) {
return false;
}
uint32_t regionCount;
if (!scanner.ReadNumber(regionCount)) {
return false;
}
for (size_t i=0; i<regionCount; i++) {
AdminRegionVisitor::Action action;
FileOffset nextChildOffset;
if (!scanner.ReadFileOffset(nextChildOffset)) {
return false;
}
action=VisitRegionEntries(scanner,
visitor);
if (action==AdminRegionVisitor::error) {
return false;
}
else if (action==AdminRegionVisitor::stop) {
return true;
}
else if (action==AdminRegionVisitor::skipChildren) {
if (i+1<regionCount) {
if (!scanner.SetPos(nextChildOffset)) {
return false;
}
}
}
}
return !scanner.HasError() && scanner.Close();
}
bool RouteNode::Read(FileScanner& scanner)
{
uint32_t objectCount;
uint32_t pathCount;
uint32_t excludesCount;
if (!scanner.GetPos(fileOffset)) {
return false;
}
scanner.ReadNumber(id);
if (!scanner.ReadCoord(coord)) {
return false;
}
scanner.ReadNumber(objectCount);
scanner.ReadNumber(pathCount);
scanner.ReadNumber(excludesCount);
if (scanner.HasError()) {
return false;
}
objects.resize(objectCount);
Id previousFileOffset=0;
for (size_t i=0; i<objectCount; i++) {
RefType type;
FileOffset fileOffset;
if (!scanner.ReadNumber(fileOffset)) {
return false;
}
if (fileOffset % 2==0) {
type=refWay;
}
else {
type=refArea;
}
fileOffset=fileOffset/2;
fileOffset+=previousFileOffset;
objects[i].object.Set(fileOffset,type);
scanner.ReadNumber(objects[i].type);
scanner.Read(objects[i].maxSpeed);
scanner.Read(objects[i].grade);
previousFileOffset=fileOffset;
}
if (pathCount>0) {
GeoCoord minCoord;
paths.resize(pathCount);
for (size_t i=0; i<pathCount; i++) {
uint32_t distanceValue;
scanner.ReadFileOffset(paths[i].offset);
scanner.ReadNumber(paths[i].objectIndex);
//scanner.Read(paths[i].bearing);
scanner.Read(paths[i].flags);
scanner.ReadNumber(distanceValue);
paths[i].distance=distanceValue/(1000.0*100.0);
}
}
excludes.resize(excludesCount);
for (size_t i=0; i<excludesCount; i++) {
scanner.Read(excludes[i].source);
scanner.ReadNumber(excludes[i].targetIndex);
}
return !scanner.HasError();
}
bool LocationIndex::VisitRegionLocationEntries(FileScanner& scanner,
LocationVisitor& visitor,
bool recursive,
bool& stopped) const
{
AdminRegion region;
FileOffset childrenOffset;
uint32_t childCount;
if (!LoadAdminRegion(scanner,
region)) {
return false;
}
if (!scanner.GetPos(childrenOffset)) {
return false;
}
if (!scanner.SetPos(region.dataOffset)) {
return false;
}
if (!LoadRegionDataEntry(scanner,
region,
visitor,
stopped)) {
return false;
}
if (stopped || !recursive) {
return !scanner.HasError();
}
if (!scanner.SetPos(childrenOffset)) {
return false;
}
if (!scanner.ReadNumber(childCount)) {
return false;
}
for (size_t i=0; i<childCount; i++) {
FileOffset nextChildOffset;
if (!scanner.ReadFileOffset(nextChildOffset)) {
return false;
}
if (!VisitRegionLocationEntries(scanner,
visitor,
recursive,
stopped)) {
return false;
}
if (stopped) {
break;
}
}
return !scanner.HasError();
}
bool LocationIndex::LoadRegionDataEntry(FileScanner& scanner,
const AdminRegion& adminRegion,
LocationVisitor& visitor,
bool& stopped) const
{
uint32_t poiCount;
uint32_t locationCount;
if (!scanner.ReadNumber(poiCount)) {
return false;
}
ObjectFileRefStreamReader objectFileRefReader(scanner);
for (size_t i=0; i<poiCount; i++) {
POI poi;
poi.regionOffset=adminRegion.regionOffset;
if (!scanner.Read(poi.name)) {
return false;
}
if (!objectFileRefReader.Read(poi.object)) {
return false;
}
if (!visitor.Visit(adminRegion,
poi)) {
stopped=true;
return true;
}
}
if (!scanner.ReadNumber(locationCount)) {
return false;
}
for (size_t i=0; i<locationCount; i++) {
Location location;
uint32_t objectCount;
if (!scanner.GetPos(location.locationOffset)) {
return false;
}
if (!scanner.Read(location.name)) {
return false;
}
location.regionOffset=adminRegion.regionOffset;
if (!scanner.ReadNumber(objectCount)) {
return false;
}
location.objects.reserve(objectCount);
bool hasAddresses;
if (!scanner.Read(hasAddresses)) {
return false;
}
if (hasAddresses) {
if (!scanner.ReadFileOffset(location.addressesOffset)) {
return false;
}
}
else {
location.addressesOffset=0;
}
objectFileRefReader.Reset();
for (size_t j=0; j<objectCount; j++) {
ObjectFileRef ref;
if (!objectFileRefReader.Read(ref)) {
return false;
}
location.objects.push_back(ref);
}
if (!visitor.Visit(adminRegion,
location)) {
stopped=true;
return true;
}
}
return !scanner.HasError();
}
AdminRegionVisitor::Action LocationIndex::VisitRegionEntries(FileScanner& scanner,
AdminRegionVisitor& visitor) const
{
AdminRegion region;
uint32_t childCount;
if (!LoadAdminRegion(scanner,
region)) {
return AdminRegionVisitor::error;
}
AdminRegionVisitor::Action action=visitor.Visit(region);
switch (action) {
case AdminRegionVisitor::stop:
return action;
case AdminRegionVisitor::error:
return action;
case AdminRegionVisitor::skipChildren:
return AdminRegionVisitor::skipChildren;
case AdminRegionVisitor::visitChildren:
// just continue...
break;
}
if (!scanner.ReadNumber(childCount)) {
return AdminRegionVisitor::error;
}
for (size_t i=0; i<childCount; i++) {
FileOffset nextChildOffset;
if (!scanner.ReadFileOffset(nextChildOffset)) {
return AdminRegionVisitor::error;
}
action=VisitRegionEntries(scanner,
visitor);
if (action==AdminRegionVisitor::stop ||
action==AdminRegionVisitor::error) {
return action;
}
else if (action==AdminRegionVisitor::skipChildren) {
if (i+1<childCount) {
if (!scanner.SetPos(nextChildOffset)) {
return AdminRegionVisitor::error;
}
}
else {
return AdminRegionVisitor::skipChildren;
}
}
}
if (scanner.HasError()) {
return AdminRegionVisitor::error;
}
else {
return AdminRegionVisitor::visitChildren;
}
}