system_assignation/city_model_structure/traffic_network.py

"""
Traffic network module
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2020 Project Author Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
Contributor Milad milad.aghamohamadnia@concordia.ca
"""

from typing import List
from city_model_structure.city_object import CityObject
from city_model_structure.transport.road_type import RoadType
from city_model_structure.transport.node import Node
from city_model_structure.transport.join import Join
from city_model_structure.transport.join_exclude import JoinExclude
from city_model_structure.transport.edge import Edge
from city_model_structure.transport.roundabout import Roundabout
from city_model_structure.transport.connection import Connection
from city_model_structure.transport.prohibition import Prohibition
from city_model_structure.transport.crossing import Crossing
from city_model_structure.transport.walking_area import WalkingArea
from city_model_structure.transport.traffic_light_logic import TrafficLightLogic


class TrafficNetwork(CityObject):
  """
  TrafficNetwork(CityObject) class
  """
  def __init__(self, name, lod, surfaces, city_lower_corner):
    super().__init__(name, lod, surfaces, city_lower_corner)
    self._types = None
    self._nodes = None
    self._joins = None
    self._join_excludes = None
    self._edges = None
    self._roundabouts = None
    self._connections = None
    self._prohibitions = None
    self._crossings = None
    self._walking_areas = None
    self._traffic_light_logics = None

  @property
  def types(self) -> List[RoadType]:
    return self._types

  @types.setter
  def types(self, value):
    """
    :param value: [RoadType]
    """
    self._types = value

  @property
  def nodes(self) -> List[Node]:
    return self._nodes

  @nodes.setter
  def nodes(self, value):
    """
    :param value: [Node]
    """
    self._nodes = value

  @property
  def joins(self) -> List[Join]:
    return self._joins

  @joins.setter
  def joins(self, value):
    """
    :param value: [Join]
    """
    self._joins = value

  @property
  def join_excludes(self) -> List[JoinExclude]:
    return self._join_excludes

  @join_excludes.setter
  def join_excludes(self, value):
    """
    :param value: [JoinExclude]
    """
    self._join_excludes = value

  @property
  def edges(self) -> List[Edge]:
    return self._edges

  @edges.setter
  def edges(self, value):
    """
    :param value: [Edge]
    """
    self._edges = value

  @property
  def roundabouts(self) -> List[Roundabout]:
    return self._roundabouts

  @roundabouts.setter
  def roundabouts(self, value):
    """
    :param value: [Roundabout]
    """
    self._roundabouts = value

  @property
  def connections(self) -> List[Connection]:
    return self._connections

  @connections.setter
  def connections(self, value):
    """
    :param value: [Connection]
    """
    self._connections = value

  @property
  def prohibitions(self) -> List[Prohibition]:
    return self._prohibitions

  @prohibitions.setter
  def prohibitions(self, value):
    """
    :param value: [Prohibition]
    """
    self._prohibitions = value

  @property
  def crossings(self) -> List[Crossing]:
    return self._crossings

  @crossings.setter
  def crossings(self, value):
    """
    :param value: [Crossing]
    """
    self._crossings = value

  @property
  def walking_areas(self) -> List[WalkingArea]:
    return self._walking_areas

  @walking_areas.setter
  def walking_areas(self, value):
    """
    :param value: [WalkingArea]
    """
    self._walking_areas = value

  @property
  def traffic_light_logics(self) -> List[TrafficLightLogic]:
    return self._traffic_light_logics

  @traffic_light_logics.setter
  def traffic_light_logics(self, value):
    """
    :param value: [TrafficLightLogic]
    """
    self._traffic_light_logics = value