TransitScheduleReaderV1.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*
 * TransitScheduleReader.java
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2009 by the members listed in the COPYING,        *
 *                   LICENSE and WARRANTY file.                            *
 * email           : info at matsim dot org                                *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *   See also COPYING, LICENSE and WARRANTY file                           *
 *                                                                         *
 * *********************************************************************** */

package org.matsim.pt.transitSchedule;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.ConcurrentHashMap;

import org.matsim.api.core.v01.Coord;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.core.population.routes.NetworkRoute;
import org.matsim.core.population.routes.RouteFactories;
import org.matsim.core.utils.geometry.CoordinateTransformation;
import org.matsim.core.utils.geometry.transformations.IdentityTransformation;
import org.matsim.core.utils.io.MatsimXmlParser;
import org.matsim.core.utils.misc.Time;
import org.matsim.pt.transitSchedule.api.Departure;
import org.matsim.pt.transitSchedule.api.TransitLine;
import org.matsim.pt.transitSchedule.api.TransitRoute;
import org.matsim.pt.transitSchedule.api.TransitRouteStop;
import org.matsim.pt.transitSchedule.api.TransitSchedule;
import org.matsim.pt.transitSchedule.api.TransitStopFacility;
import org.matsim.vehicles.Vehicle;
import org.xml.sax.Attributes;

public class TransitScheduleReaderV1 extends MatsimXmlParser {

    private final TransitSchedule schedule;
    private final RouteFactories routeFactory;

    private TransitLine currentTransitLine = null;
    private TempTransitRoute currentTransitRoute = null;
    private TempRoute currentRouteProfile = null;

    private final CoordinateTransformation coordinateTransformation;
    private final StringCache cache = new StringCache();

    public TransitScheduleReaderV1(final TransitSchedule schedule, final RouteFactories routeFactory) {
        this( new IdentityTransformation() , schedule , routeFactory );
    }

    public TransitScheduleReaderV1(final Scenario scenario) {
        this( scenario.getTransitSchedule(),
                scenario.getPopulation().getFactory().getRouteFactories() );
    }

    public TransitScheduleReaderV1(
            final CoordinateTransformation coordinateTransformation,
            final Scenario scenario) {
        this( coordinateTransformation,
                scenario.getTransitSchedule(),
                scenario.getPopulation().getFactory().getRouteFactories() );
    }

    public TransitScheduleReaderV1(
            CoordinateTransformation coordinateTransformation,
            TransitSchedule schedule,
            RouteFactories routeFactory) {
        super(ValidationType.DTD_ONLY);
        this.coordinateTransformation = coordinateTransformation;
        this.schedule = schedule;
        this.routeFactory = routeFactory;
    }

    @Override
    public void startTag(final String name, final Attributes atts, final Stack<String> context) {
        if (Constants.STOP_FACILITY.equals(name)) {
            boolean isBlocking = Boolean.parseBoolean(atts.getValue(Constants.IS_BLOCKING));
            TransitStopFacility stop =
                    schedule.getFactory().createTransitStopFacility(
                            Id.create(
                                    atts.getValue(Constants.ID),
                                    TransitStopFacility.class),
                            coordinateTransformation.transform(
                                    new Coord(
                                            Double.parseDouble(atts.getValue("x")),
                                            Double.parseDouble(atts.getValue("y")))),
                            isBlocking);
            if (atts.getValue(Constants.LINK_REF_ID) != null) {
                Id<Link> linkId = Id.create(atts.getValue(Constants.LINK_REF_ID), Link.class);
                stop.setLinkId(linkId);
            }
            if (atts.getValue(Constants.NAME) != null) {
                stop.setName(this.cache.get(atts.getValue(Constants.NAME)));
            }
            this.schedule.addStopFacility(stop);
        } else if (Constants.TRANSIT_LINE.equals(name)) {
            Id<TransitLine> id = Id.create(atts.getValue(Constants.ID), TransitLine.class);
            this.currentTransitLine = schedule.getFactory().createTransitLine(id);
            if (atts.getValue(Constants.NAME) != null) {
                this.currentTransitLine.setName(atts.getValue(Constants.NAME));
            }
            this.schedule.addTransitLine(this.currentTransitLine);
        } else if (Constants.TRANSIT_ROUTE.equals(name)) {
            Id<TransitRoute> id = Id.create(atts.getValue(Constants.ID), TransitRoute.class);
            this.currentTransitRoute = new TempTransitRoute(id);
        } else if (Constants.DEPARTURE.equals(name)) {
            Id<Departure> id = Id.create(atts.getValue(Constants.ID), Departure.class);
            Departure departure = new DepartureImpl(id, Time.parseTime(atts.getValue("departureTime")));
            String vehicleRefId = atts.getValue(Constants.VEHICLE_REF_ID);
            if (vehicleRefId != null) {
                departure.setVehicleId(Id.create(vehicleRefId, Vehicle.class));
            }
            this.currentTransitRoute.departures.put(id, departure);
        } else if (Constants.ROUTE_PROFILE.equals(name)) {
            this.currentRouteProfile = new TempRoute();
        } else if (Constants.LINK.equals(name)) {
            String linkStr = atts.getValue(Constants.REF_ID);
            if (!linkStr.contains(" ")) {
                this.currentRouteProfile.addLink(Id.create(linkStr, Link.class));
            } else {
                String[] links = linkStr.split(" ");
                for (int i = 0; i < links.length; i++) {
                    this.currentRouteProfile.addLink(Id.create(links[i], Link.class));
                }
            }
        } else if (Constants.STOP.equals(name)) {
            Id<TransitStopFacility> id = Id.create(atts.getValue(Constants.REF_ID), TransitStopFacility.class);
            TransitStopFacility facility = this.schedule.getFacilities().get(id);
            if (facility == null) {
                throw new RuntimeException("no stop/facility with id " + atts.getValue(Constants.REF_ID));
            }
            TransitRouteStopImpl.Builder stopBuilder = new TransitRouteStopImpl.Builder().stop(facility);
            String arrival = atts.getValue(Constants.ARRIVAL_OFFSET);
            String departure = atts.getValue(Constants.DEPARTURE_OFFSET);
            if (arrival != null) {
                Time.parseOptionalTime(arrival).ifDefined(stopBuilder::arrivalOffset);
            }
            if (departure != null) {
                Time.parseOptionalTime(departure).ifDefined(stopBuilder::departureOffset);
            }
            stopBuilder.awaitDepartureTime(Boolean.parseBoolean(atts.getValue(Constants.AWAIT_DEPARTURE)));
            this.currentTransitRoute.stopBuilders.add(stopBuilder);
        }
    }

    @Override
    public void endTag(final String name, final String content, final Stack<String> context) {
        if (Constants.DESCRIPTION.equals(name) && Constants.TRANSIT_ROUTE.equals(context.peek())) {
            this.currentTransitRoute.description = content;
        } else if (Constants.TRANSPORT_MODE.equals(name)) {
            this.currentTransitRoute.mode = content.intern();
        } else if (Constants.TRANSIT_ROUTE.equals(name)) {
            List<TransitRouteStop> stops = new ArrayList<>(this.currentTransitRoute.stopBuilders.size());
            this.currentTransitRoute.stopBuilders.forEach(stopBuilder -> stops.add(stopBuilder.build()));
            NetworkRoute route = null;
            if (this.currentRouteProfile.firstLinkId != null) {
                if (this.currentRouteProfile.lastLinkId == null) {
                    this.currentRouteProfile.lastLinkId = this.currentRouteProfile.firstLinkId;
                }
                route = this.routeFactory.createRoute(NetworkRoute.class, this.currentRouteProfile.firstLinkId, this.currentRouteProfile.lastLinkId);
                route.setLinkIds(this.currentRouteProfile.firstLinkId, this.currentRouteProfile.linkIds, this.currentRouteProfile.lastLinkId);
            }
            TransitRoute transitRoute = this.schedule.getFactory().createTransitRoute(this.currentTransitRoute.id, route, stops, this.currentTransitRoute.mode);
            transitRoute.setDescription(this.currentTransitRoute.description);
            for (Departure departure : this.currentTransitRoute.departures.values()) {
                transitRoute.addDeparture(departure);
            }
            this.currentTransitLine.addRoute(transitRoute);
        }
    }

    private static class TempTransitRoute {
        protected final Id<TransitRoute> id;
        protected String description = null;
        protected Map<Id<Departure>, Departure> departures = new LinkedHashMap<>();
        /*package*/ List<TransitRouteStopImpl.Builder> stopBuilders = new ArrayList<>();
        /*package*/ String mode = null;

        protected TempTransitRoute(final Id<TransitRoute> id) {
            this.id = id;
        }
    }

    private static class TempRoute {
        /*package*/ List<Id<Link>> linkIds = new ArrayList<Id<Link>>();
        /*package*/ Id<Link> firstLinkId = null;
        /*package*/ Id<Link> lastLinkId = null;

        protected TempRoute() {
            // public constructor for private inner class
        }

        protected void addLink(final Id<Link> linkId) {
            if (this.firstLinkId == null) {
                this.firstLinkId = linkId;
            } else if (this.lastLinkId == null) {
                this.lastLinkId = linkId;
            } else {
                this.linkIds.add(this.lastLinkId);
                this.lastLinkId = linkId;
            }
        }

    }

    private static class StringCache {

        private ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<String, String>(10000);

        public String get(final String string) {
            if (string == null) {
                return null;
            }
            String s = cache.putIfAbsent(string, string);
            if (s == null) {
                return string;
            }
            return s;
        }
    }

}