MapReader.java

/*
 * Copyright (C) 2009.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 or
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
package uk.me.parabola.imgfmt.app.map;

import java.io.Closeable;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;

import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.app.Area;
import uk.me.parabola.imgfmt.app.lbl.City;
import uk.me.parabola.imgfmt.app.lbl.Country;
import uk.me.parabola.imgfmt.app.lbl.LBLFileReader;
import uk.me.parabola.imgfmt.app.lbl.Region;
import uk.me.parabola.imgfmt.app.lbl.Zip;
import uk.me.parabola.imgfmt.app.net.NETFileReader;
import uk.me.parabola.imgfmt.app.net.RoadDef;
import uk.me.parabola.imgfmt.app.trergn.Point;
import uk.me.parabola.imgfmt.app.trergn.Polygon;
import uk.me.parabola.imgfmt.app.trergn.Polyline;
import uk.me.parabola.imgfmt.app.trergn.RGNFileReader;
import uk.me.parabola.imgfmt.app.trergn.Subdivision;
import uk.me.parabola.imgfmt.app.trergn.TREFileReader;
import uk.me.parabola.imgfmt.app.trergn.Zoom;
import uk.me.parabola.imgfmt.fs.DirectoryEntry;
import uk.me.parabola.imgfmt.fs.FileSystem;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.imgfmt.sys.ImgFS;

/**
 * This is a view of a .img file when we are reading it.  The {@link Map}
 * class is the equivalent for writing.
 * 
 * @author Steve Ratcliffe
 */
public class MapReader implements Closeable {
	private final TREFileReader treFile;
	private final RGNFileReader rgnFile;
	private final LBLFileReader lblFile;
	private final NETFileReader netFile;
	
	public static final boolean WITH_EXT_TYPE_DATA = true;
	public static final boolean WITHOUT_EXT_TYPE_DATA = false;
	
	private final Deque<Closeable> toClose = new ArrayDeque<Closeable>();

	public MapReader(String filename) throws FileNotFoundException {
		FileSystem fs = ImgFS.openFs(filename);
		saveForClose(fs);

		List<DirectoryEntry> entries = fs.list();

		// Find the TRE entry
		String mapname = null;
		for (DirectoryEntry ent : entries) {
			if ("TRE".equals(ent.getExt())) {
				mapname = ent.getName();
				break;
			}
		}

		if (mapname == null)
			throw new FileNotFoundException("No TRE entry in img file");

		ImgChannel chan = fs.open(mapname + ".TRE", "r");
		treFile = new TREFileReader(chan);
		saveForClose(treFile, chan);

		chan = fs.open(mapname + ".RGN", "r");
		rgnFile = new RGNFileReader(chan);
		saveForClose(rgnFile, chan);

		chan = fs.open(mapname + ".LBL", "r");
		lblFile = new LBLFileReader(chan);
		saveForClose(lblFile, chan);

		// The NET file is optional
		NETFileReader nr;
		try {
			chan = fs.open(mapname + ".NET", "r");
			nr = new NETFileReader(chan);
			nr.setLabels(lblFile);
			nr.setCities(lblFile.getCities());
			nr.setZips(lblFile.getZips());
			saveForClose(nr);
		} catch (FileNotFoundException e) {
			nr = null;
		}
		netFile = nr;

		rgnFile.setNetFile(netFile);
		rgnFile.setLblFile(lblFile);
	}

	/**
	 * Get a list of all the points for a given level.
	 * @param level The level, lower numbers are the most detailed.
	 */
	public List<Point> pointsForLevel(int level, boolean withExtType) {
		List<Point> points = new ArrayList<Point>();

		Subdivision[] subdivisions = treFile.subdivForLevel(level);
		for (Subdivision sd : subdivisions) {
			List<Point> subdivPoints = rgnFile.pointsForSubdiv(sd, withExtType);
			points.addAll(subdivPoints);
		}

		return points;
	}

	public Zoom[] getLevels() {
		return treFile.getMapLevels();
	}

	public String[] getCopyrights(){
		return treFile.getCopyrights(lblFile);
	}
	/**
	 * Get a list of all the lines for a given level.
	 * @param level The level, lower numbers are the most detailed.
	 */
	public List<Polyline> linesForLevel(int level) {
		ArrayList<Polyline> lines = new ArrayList<Polyline>();

		Subdivision[] subdivisions = treFile.subdivForLevel(level);
		for (Subdivision div : subdivisions) {
			List<Polyline> subdivLines = rgnFile.linesForSubdiv(div);
			lines.addAll(subdivLines);
		}

		return lines;
	}


	public List<Polygon> shapesForLevel(int level) {
		ArrayList<Polygon> shapes = new ArrayList<Polygon>();

		Subdivision[] subdivisions = treFile.subdivForLevel(level);
		for (Subdivision div : subdivisions) {
			List<Polygon> subdivShapes = rgnFile.shapesForSubdiv(div);
			shapes.addAll(subdivShapes);
		}

		return shapes;
	}

	public void close() throws IOException {
		for (Closeable c : toClose)
			Utils.closeFile(c);
	}

	private void saveForClose(Closeable c1, Closeable c2) {
		saveForClose(c1);
		saveForClose(c2);
	}

	private void saveForClose(Closeable c) {
		toClose.push(c);
	}

	public List<City> getCities() {
		return lblFile.getCities();
	}

	public List<Country> getCountries() {
		return lblFile.getCountries();
	}

	public List<Region> getRegions() {
		return lblFile.getRegions();
	}
	
	public List<Zip> getZips() {
		// need to be joined with zip information from the addresses
		// where are the addresses stored?
		return lblFile.getZips();
	}

	public Area getTreBounds() {
		return treFile.getBounds();
	}

	public java.util.Map<Integer, String> getLabels() {
		return lblFile.getLabels();
	}

	public List<RoadDef> getRoads() {
		if (netFile == null)
			return Collections.emptyList();
		return netFile.getRoads();
	}
	
	public int getEncodingType(){
		return lblFile.getEncodingType();
	}
}