ShortestPathCalc.scala

/**
  *
  * @param edgeTo a sequence which represents the last edge 
  *               on the shortest path from 'sourceV' to vertex i.
  *               None means there is no path to vertex i
  * @param distTo a sequence of distances from source vertex to a specific i vertex
  */
class ShortestPathCalc(edgeTo: Seq[Option[DirectedEdge]], distTo: Seq[Double]) {
  /**
    *
    * @param v vertex to get the path for
    * @return returns error when v is invalid or sequence of edges 
    * which form the path from source vertex to v vertex
    */
  def pathTo(v: Int): Either[String, Seq[DirectedEdge]] = {

    @tailrec
    def go(list: List[DirectedEdge], vv: Int): List[DirectedEdge] =
      edgeTo(vv) match {
        case Some(e) => go(e +: list, e.from)
        case None => list
      }

    hasPath(v).map(b => if (!b) Seq() else go(List(), v))
  }

  /**
    *
    * @param v vertex to check whether path from source vertex to v vertex exists
    * @return returns error when v is invalid or Boolean 
    * when some path from source vertex to vertex v exists
    */
  def hasPath(v: Int): Either[String, Boolean] =
    distTo.lift(v).map(_ < Double.PositiveInfinity).toRight(s"Vertex $v does not exist")

  /**
    *
    * @param v vertex to get the distance for
    * @return returns error when v is invalid or 
    * the Double distance which is a sum of weights
    */
  def distToV(v: Int): Either[String, Double] =
    distTo.lift(v).toRight(s"Vertex $v does not exist")
}