def testAddData(self):
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
table = db.getTableByName("R_GR0")
beforedata = [curs.getRow().asList() for curs in table.getCursor(0)]
## Add an empty row
refrow = Row(table)
refrow.setColumn(0, 1)
table.writeRow(refrow)
refdata = refrow.asList()
db.close()
db = Database(MapDirectory(self.testdatadir), "db00")
table = db.getTableByName("R_GR0")
aux = db.getTableByName("AUX_GR0")
am = AuxTableManager(aux)
afterdata = [curs.getRow().asList() for curs in table.getCursor(0)]
for curs in table.getCursor(0):
row = curs.getRow()
index = row.asDict()['NAME_REF'] & 0xffffff
offset = row.asDict()['NAME_REF'] >> 24
self.assertEqual(beforedata + [refdata], afterdata)
def testWriteNewSlot(self):
random.seed(0)
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
f = db.getFileByIndex(4)
nslots = f.pz.next - 1
slotdatabefore = [f.readSlot(i + 1) for i in range(nslots)]
slotsize = f.fstruct.ft_slsize
writtendata = "".join(
[chr(random.randint(0, 255)) for i in xrange(slotsize)])
f.writeSlot(writtendata)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
nslots = f.pz.next - 1
slotdata = [f.readSlot(i + 1) for i in range(nslots)]
slotdataexpected = slotdatabefore + [writtendata]
self.assertEqual(len(slotdataexpected), len(slotdata))
if slotdataexpected != slotdata:
print "Equal elements", [
a == b for a, b in zip(slotdataexpected, slotdata)
]
self.assertEqual(slotdataexpected, slotdata)
def testOpenAppend(self):
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
f = db.getFileByIndex(4)
nslotsbefore = f.pz.next - 1
self.assertEqual(nslotsbefore, 3)
slotdatabefore = [f.readSlot(i + 1) for i in range(nslotsbefore)]
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
nslots = f.pz.next - 1
self.assertEqual(nslots, nslotsbefore)
slotdata = [f.readSlot(i + 1) for i in range(nslots)]
self.assertEqual(len(slotdata), len(slotdatabefore))
if slotdata != slotdatabefore:
print "Equal elements", [
a == b for a, b in zip(slotdatabefore, slotdata)
]
self.assertEqual(slotdata, slotdatabefore)
def testWriteSlot(self):
random.seed(0)
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
f = db.getFileByIndex(4)
nslots = f.pz.next - 1
slotdatabefore = [f.readSlot(i + 1) for i in range(nslots)]
slotsize = f.fstruct.ft_slsize
writtendata = "".join(
[chr(random.randint(0, 255)) for i in xrange(slotsize)])
slot = 2
f.writeSlot(writtendata, slot)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
slotdata = [f.readSlot(i + 1) for i in range(nslots)]
slotdataexpected = slotdatabefore
slotdataexpected[slot - 1] = writtendata
self.assertEqual(slotdataexpected, slotdata)
def testWritePage(self):
random.seed(0)
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
f = db.getFileByIndex(4)
npages = f.npages
pagesize = f.fstruct.ft_pgsize
writtendata = "".join(
[chr(random.randint(0, 255)) for i in xrange(pagesize)])
# import pdb
# pdb.set_trace()
## Override incomplete page
f.writePage(writtendata, 1)
## Update pz.next so that the incomplete_page buffer won't overwrite the written page
f.pz.next = f.fstruct.ft_slots * f.page + 1
assert (f.page == 2)
assert (f.relslotnum == 0)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
self.assertEqual(f.readPage(1), writtendata)
def testAddRows(self):
random.seed(0)
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
table = db.getTableByName("R_GR0")
rows = [curs.getRow() for curs in table.getCursor(0)]
data = [
"".join([
chr(random.randint(0, 255))
for i in xrange(table.rstruct.rt_len)
]) for j in xrange(5)
]
newrows = [Row(table, data=d) for d in data]
for row in newrows:
table.writeRow(row)
self.assertEqual(table.getRowCount(), 29 + 5)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
table = db.getTableByName("R_GR0")
rowsafter = [curs.getRow() for curs in table.getCursor(0)]
self.assertEqual(table.getRowCount(), 29 + 5)
self.assertEqual(rows + newrows, rowsafter)
def testCreateDatabase(self):
mapdir = MapDirectory()
db = Database(mapdir, "db00", 'w')
db.close()
self.assertTrue('db00.dbd' in mapdir.listdir())
# os.system('prdbd '+os.path.join(mapdir.dir, 'db00'))
db = Database(mapdir, "db00", 'r')
db.close()
def testOpenWrite(self):
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
f.close()
f.open('w')
nslotsbefore = f.pz.next - 1
self.assertEqual(nslotsbefore, 0)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
f = db.getFileByIndex(4)
nslots = f.pz.next - 1
self.assertEqual(nslots, 0)
def testAuxIndex(self):
db = Database(MapDirectory(self.testdatadir), "db00")
table = db.getTableByName("R_GR0")
aux = db.getTableByName("AUX_GR0")
rows = [x.getRow() for x in aux.getCursor(0)]
index = rows[0].asDict()['NAME_BUF']
n = len(index) / 4
index = struct.unpack('%dI' % n, index)
def testOpenForAppend(self):
random.seed(0)
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
table = db.getTableByName("R_GR0")
databefore = [curs.getRow() for curs in table.getCursor(0)]
rowcountbefore = table.getRowCount()
self.assertEqual(rowcountbefore, 29)
db.close()
## Read back
db = Database(MapDirectory(self.testdatadir), "db00", 'r')
table = db.getTableByName("R_GR0")
dataafter = [curs.getRow() for curs in table.getCursor(0)]
rowcountafter = table.getRowCount()
self.assertEqual(rowcountbefore, rowcountafter)
self.assertEqual(len(databefore), len(dataafter))
self.assertEqual(databefore, dataafter)
def testSimple(self):
db = Database(MapDirectory(self.testdatadir), "db00")
table = db.getTableByName("R_GR0")
for curs in table.getCursor(0):
row = curs.getRow()
aux = db.getTableByName("AUX_GR0")
am = AuxTableManager(aux)
index = row.asDict()['NAME_REF'] & 0xffffff
offset = row.asDict()['NAME_REF'] >> 24
def open(self, mode='r'):
if self.mode != None:
return None
self.mode = mode
if mode == 'w':
if self.gpsimage:
if self._inifile == None:
self._inifile = self.mapnumstr + 'map.ini'
## Create database
self._db = Database(self.mapdir, 'db' + self.mapnumstr, mode, self.bigendian)
## Create zip table
if self.has_zip:
buildziprecord(self._db,
zipfilename = self.mapnumstr + 'z.dat',
auxfilename = self.mapnumstr + 'cn.dat',
extended = self.maptype == MapTypeStreetRoute)
## Create marine table
if self.has_marine:
buildmarinerecord(self._db,
filenameprefix = self.mapnumstr)
## Create basic groups
if self.maptype == MapTypeStreetRoute:
roads = GroupStreet(self, name=self.mapnumstr + "_Roads")
else:
roads = GroupNormal(self, name=self.mapnumstr + "_Roads")
roads.searchable = True
self.addGroup(roads)
self.addGroup(GroupNormal(self, name=self.mapnumstr + "_Railroads"))
self.addGroup(GroupNormal(self, name=self.mapnumstr + "_Hydrography"))
self.addGroup(GroupNormal(self, name=self.mapnumstr + "_Parks"))
else:
if self._inifile == None:
self._inifile = 'map.ini'
elif mode in ('r','a'):
## Find ini file
if self._inifile == None:
filelist = self.mapdir.listdir()
possibleinifiles = ('map.ini', self.mapnumstr + 'map.ini', 'lay_info.ini')
found = False
for filename in possibleinifiles:
if filename in filelist:
self._inifile = filename
found = True
break
if not found:
raise ValueError('Could not find ini-file')
self._cfg.readfp(IniFileFilter(self.mapdir.open(self._inifile)))
# Get map type
if self._cfg.has_option('MAP_INFO', 'MAPTYPE'):
self.maptype = self._cfg.get("MAP_INFO", "MAPTYPE")
# Get bounding box
if self._cfg.has_option('MAP_INFO', 'BND_BOX'):
bbox = map(float, self._cfg.get("MAP_INFO", "BND_BOX").split(" "))
self._bboxrec = Rec([bbox[0],bbox[2]], [bbox[1], bbox[3]])
# Get map name
self.name = self._cfg.get('MAP_INFO', 'MAP_NAME')
# self.date = self._cfg.get('MAP_INFO', 'MAP_DATE')
self._laycfg.setupfromcfg(self._cfg, self)
# Find database path
dbname = self._cfg.get("LAYERS","DB_NAME")
dbname = re.sub('\\\\', os.sep, dbname)
# Since Windows is case insensitive, try to match the path case insensitive
plist=dbname.split(os.sep)
for i in range(0,len(plist)-2):
path=os.sep.join(plist[0:i+1])
if len(path)>0:
hits=[d for d in self.mapdir.listdir(path) if d.lower() == plist[i+1].lower()]
if len(hits)==0:
raise ValueError("Couldnt find database")
plist[i+1]=hits[0]
dbname = os.sep.join(plist)
if dbname:
self._db = Database(self.mapdir, dbname, self.mode, self.bigendian)
# Read groups
if self.debug:
print "Groups:"
for i in range(0,self._cfg.getint("GROUPS","NUMBER")):
thegroup = groupFactory(self, i, self._cfg, self._db)
self.groups.append(thegroup)
thegroup.initFromIni(self._cfg)
# Read POI file and POI layers
if self._cfg.has_section("POI"):
poi_ini = self._cfg.get("POI","POI_CONFIG")
self.poicfg = ConfigParserUpper()
if self.mapdir.isfile(poi_ini):
self.poicfg.readfp(IniFileFilter(self.mapdir.open(poi_ini)))
if self.poicfg.has_section("LAYERS"):
self._poigroup = POIGroup(self)
self._poiconfig.setupfromcfg(self.poicfg, self)
# Read routing info
if self.maptype == MapTypeStreetRoute:
self.routingcfg = routing.RoutingConfig()
self.routingcfg.setupfromcfg(self._cfg, self)
# Read unpack tables
if self._cfg.has_section('PACK_LAYS'):
i = 0
while self._cfg.has_option('PACK_LAYS', str(i)):
fields = self._cfg.get('PACK_LAYS', str(i)).split(' ')
filename = fields[0]
n = int(fields[1])
layernumbers = map(int, fields[2:])
assert len(layernumbers) == n
for layernumber in layernumbers:
self.getLayerByIndex(layernumber).setUnpackTable(filename)
i += 1
def testListFiles(self):
db = Database(MapDirectory(self.testdatadir), "db00", 'a')
def testCreateDatabase(self):
mapdir = MapDirectory()
db = Database(mapdir, "db00", 'w')
