SYMBOL INDEX (868 symbols across 112 files)

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/ADStarForward.java
  class ADStarForward (line 58) | public class ADStarForward<A,S,C extends Comparable<C>, N extends es.usc...
    method ADStarForward (line 72) | public ADStarForward(S begin, S goal, ADStarNodeExpander<A, S, C, N> e...
    method ADStarForward (line 84) | public ADStarForward(S begin, Collection<S> goals, ADStarNodeExpander<...
    method iterator (line 90) | @Override
    class Iterator (line 98) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 109) | protected Iterator() {
      method insertOpen (line 145) | protected void insertOpen(N node) {
      method takePromising (line 156) | protected N takePromising() {
      method updateQueues (line 173) | protected void updateQueues(N node) {
      method hasNext (line 200) | @Override
      method remove (line 210) | @Override
      method next (line 215) | @Override
      method getOpen (line 278) | public Map<S, N> getOpen() { return open; }
      method getClosed (line 287) | public Map<S, N> getClosed() { return closed; }
      method getIncons (line 289) | public Map<S, N> getIncons() { return incons; }
      method getGoalNodes (line 296) | public Collection<N> getGoalNodes() {
      method setEpsilon (line 310) | public void setEpsilon(double epsilon){
      method getEpsilon (line 320) | public double getEpsilon(){
      method addTransitionsChanged (line 329) | public void addTransitionsChanged(Collection<Transition<A, S>> trans...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/AStar.java
  class AStar (line 44) | public class AStar<A,S,C extends Comparable<C>,N extends HeuristicNode<A...
    method AStar (line 56) | public AStar(N initialNode, NodeExpander<A,S,N> expander) {
    method iterator (line 61) | @Override
    class Iterator (line 69) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 74) | protected Iterator() {
      method hasNext (line 85) | public boolean hasNext() {
      method takePromising (line 89) | protected N takePromising() {
      method next (line 105) | public N next() {
      method remove (line 142) | public void remove() {
      method getOpen (line 153) | public Map<S, N> getOpen() {
      method setOpen (line 157) | public void setOpen(Map<S, N> open) {
      method getClosed (line 168) | public Map<S, N> getClosed() {
      method setClosed (line 178) | public void setClosed(Map<S, N> closed) {
      method getQueue (line 190) | public Queue<N> getQueue() {
      method setQueue (line 200) | public void setQueue(Queue<N> queue) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/Algorithm.java
  class Algorithm (line 35) | public abstract class Algorithm<A,S,N extends Node<A,S,N>> implements It...
    class SearchResult (line 41) | public final class SearchResult {
      method SearchResult (line 47) | public SearchResult(N goalNode, int iterations, long elapsed) {
      method SearchResult (line 53) | public SearchResult(Collection<N> goalNodes, int iterations, long el...
      method getElapsed (line 63) | public long getElapsed() {
      method getIterations (line 71) | public int getIterations() {
      method getGoalNode (line 78) | public N getGoalNode() {
      method getGoalNodes (line 82) | public Collection<N> getGoalNodes() {
      method getOptimalPaths (line 86) | public List<List<S>> getOptimalPaths() {
      method toString (line 95) | @Override
    type SearchListener (line 118) | public interface SearchListener<N> {
      method handle (line 119) | void handle(N node);
    method search (line 127) | public SearchResult search(final S goalState){
    method search (line 147) | public SearchResult search(Predicate<N> condition){
    method search (line 183) | public void search(SearchListener<N> listener){
    method recoverStatePath (line 198) | public static <S, N extends Node<?,S,N>>  List<S> recoverStatePath(N n...
    method recoverActionPath (line 214) | public static <A, N extends Node<A,?,N>>  List<A> recoverActionPath(N ...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/BellmanFord.java
  class BellmanFord (line 47) | public class BellmanFord<A,S,C extends Comparable<C>,N extends CostNode<...
    method BellmanFord (line 52) | public BellmanFord(N initialNode, NodeExpander<A, S, N> nodeExpander) {
    class Iterator (line 62) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 66) | protected Iterator(){
      method enqueue (line 79) | protected void enqueue(N node) {
      method dequeue (line 93) | protected N dequeue() {
      method hasNext (line 99) | @Override
      method next (line 104) | @Override
      method remove (line 129) | @Override
    method search (line 135) | @Override
    method iterator (line 158) | @Override
    method getInitialNode (line 163) | public N getInitialNode() {
    method setInitialNode (line 167) | public void setInitialNode(N initialNode) {
    method getNodeExpander (line 171) | public NodeExpander<A, S, N> getNodeExpander() {
    method setNodeExpander (line 175) | public void setNodeExpander(NodeExpander<A, S, N> nodeExpander) {
    method isCheckNegativeCycles (line 179) | public boolean isCheckNegativeCycles() {
    method setCheckNegativeCycles (line 183) | public void setCheckNegativeCycles(boolean checkNegativeCycles) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/BreadthFirstSearch.java
  class BreadthFirstSearch (line 41) | public class BreadthFirstSearch<A,S,N extends Node<A,S,N>> extends Algor...
    method BreadthFirstSearch (line 45) | public BreadthFirstSearch(N initialNode, NodeExpander<A, S, N> expande...
    class Iterator (line 53) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 61) | protected Iterator(){
      method hasNext (line 66) | @Override
      method next (line 71) | @Override
      method remove (line 84) | @Override
      method getQueue (line 91) | public Queue<N> getQueue() {
      method setQueue (line 95) | public void setQueue(Queue<N> queue) {
      method getVisited (line 99) | public Map<S, N> getVisited() {
      method setVisited (line 103) | public void setVisited(Map<S, N> visited) {
    method iterator (line 108) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/DepthFirstSearch.java
  class DepthFirstSearch (line 37) | public class DepthFirstSearch<A,S,N extends Node<A,S,N>> extends Algorit...
    method DepthFirstSearch (line 43) | public DepthFirstSearch(N initialNode, NodeExpander<A, S, N> expander) {
    class StackFrameNode (line 48) | public class StackFrameNode {
      method StackFrameNode (line 59) | StackFrameNode(java.util.Iterator successors, N node) {
      method StackFrameNode (line 64) | StackFrameNode(N node) {
      method getNode (line 69) | public N getNode() {
      method getSuccessors (line 73) | public java.util.Iterator<N> getSuccessors() {
      method isVisited (line 77) | public boolean isVisited() {
      method isProcessed (line 81) | public boolean isProcessed() {
    class Iterator (line 89) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 95) | protected Iterator(){
      method hasNext (line 100) | @Override
      method next (line 110) | @Override
      method remove (line 128) | @Override
      method nextUnvisited (line 134) | protected StackFrameNode nextUnvisited(){
      method processNextNode (line 151) | protected StackFrameNode processNextNode(){
      method getStack (line 174) | public Deque<StackFrameNode> getStack() {
      method setStack (line 178) | public void setStack(Deque<StackFrameNode> stack) {
      method getNext (line 182) | public StackFrameNode getNext() {
      method setNext (line 186) | public void setNext(StackFrameNode next) {
      method getClosed (line 190) | public Set<S> getClosed() {
      method setClosed (line 194) | public void setClosed(Set<S> closed) {
      method isGraphSupport (line 198) | public boolean isGraphSupport() {
      method setGraphSupport (line 202) | public void setGraphSupport(boolean graphSupport) {
    method iterator (line 206) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/DepthLimitedSearch.java
  class DepthLimitedSearch (line 36) | public class DepthLimitedSearch <A,S,N extends Node<A,S,N>> extends Algo...
    method DepthLimitedSearch (line 44) | public DepthLimitedSearch(N initialNode, N finalNode, NodeExpander nod...
    method getMaximumDepth (line 53) | public int getMaximumDepth() {
    method getCurrentDepth (line 57) | public int getCurrentDepth() {
    method getPath (line 61) | public ArrayList<S> getPath() {
    method incrementCurrentDepth (line 65) | public void incrementCurrentDepth() {
    method execute (line 69) | public boolean execute() {
    class StackNode (line 96) | private class StackNode {
      method StackNode (line 100) | public StackNode(N node) {
      method getNode (line 105) | public N getNode() {
      method setNode (line 109) | public void setNode(N node) {
      method getChildren (line 113) | public List<StackNode> getChildren() {
      method setChildren (line 122) | public void setChildren(java.util.Iterator<N> children) {
    method iterator (line 127) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/Hipster.java
  class Hipster (line 50) | public final class Hipster {
    method Hipster (line 52) | private Hipster() {
    method createAStar (line 72) | public static <A, S, C extends Comparable<C>, N extends HeuristicNode<...
    method createDijkstra (line 94) | public static <A, S, C extends Comparable<C>, N extends HeuristicNode<...
    method createBellmanFord (line 118) | public static <A, S, C extends Comparable<C>, N extends CostNode<A, S,...
    method createBreadthFirstSearch (line 138) | public static <A, S, N extends Node<A, S, N>> BreadthFirstSearch<A, S,...
    method createDepthFirstSearch (line 158) | public static <A, S, N extends Node<A, S, N>> DepthFirstSearch<A, S, N...
    method createDepthLimitedSearch (line 178) | public static <A, S, N extends Node<A, S, N>> DepthLimitedSearch<A, S,...
    method createIDAStar (line 200) | public static <A, S, C extends Comparable<C>, N extends HeuristicNode<...
    method createHillClimbing (line 225) | public static <A, S, C extends Comparable<C>, N extends HeuristicNode<...
    method createAnnealingSearch (line 249) | public static <A, S, N extends HeuristicNode<A, S, Double, N>> Anneali...
    method createMultiobjectiveLS (line 274) | public static <A, S, C extends Comparable<C>, N extends HeuristicNode<...
    method createADStar (line 295) | public static <A, S, C extends Comparable<C>> ADStarForward<A, S, C, A...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/IDAStar.java
  class IDAStar (line 44) | public class IDAStar<A,S,C extends Comparable<C>,N extends HeuristicNode...
    method IDAStar (line 51) | public IDAStar(N initialNode, NodeExpander<A,S,N> expander) {
    class Iterator (line 62) | public class Iterator extends DepthFirstSearch.Iterator {
      method Iterator (line 67) | protected Iterator(){
      method updateMinFLimit (line 74) | protected void updateMinFLimit(C currentFLimit){
      method nextUnvisited (line 84) | @Override
      method processNextNode (line 108) | @Override
      method getfLimit (line 152) | public C getfLimit() {
      method setfLimit (line 156) | public void setfLimit(C fLimit) {
      method getMinfLimit (line 160) | public C getMinfLimit() {
      method setMinfLimit (line 164) | public void setMinfLimit(C minfLimit) {
      method getReinitialization (line 168) | public int getReinitialization() {
      method setReinitialization (line 172) | public void setReinitialization(int reinitialization) {
    method iterator (line 177) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/MultiobjectiveLS.java
  class MultiobjectiveLS (line 39) | public class MultiobjectiveLS<A,S,C extends Comparable<C>,N extends Heur...
    method MultiobjectiveLS (line 44) | public MultiobjectiveLS(N initialNode, NodeExpander<A, S, N> nodeExpan...
    class Iterator (line 56) | public class Iterator implements java.util.Iterator<N> {
      method Iterator (line 62) | protected Iterator(){
      method hasNext (line 68) | public boolean hasNext() {
      method next (line 72) | @Override
      method remove (line 112) | @Override
      method dominatedBy (line 117) | protected Collection<N> dominatedBy(N node, Iterable<N> nonDominated) {
      method isDominated (line 127) | protected boolean isDominated(N node, Iterable<N> nonDominated) {
      method getQueue (line 137) | public Queue<N> getQueue() {
      method getNonDominated (line 141) | public Map<S, Collection<N>> getNonDominated() {
    method search (line 146) | @Override
    method iterator (line 168) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/NegativeCycleException.java
  class NegativeCycleException (line 4) | public class NegativeCycleException extends RuntimeException {
    method NegativeCycleException (line 7) | public NegativeCycleException() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/localsearch/AnnealingSearch.java
  class AnnealingSearch (line 56) | public class AnnealingSearch<A, S, N extends HeuristicNode<A, S, Double,...
    method AnnealingSearch (line 70) | public AnnealingSearch(N initialNode, NodeExpander<A, S, N> nodeExpand...
    method iterator (line 126) | @Override
    class ASIterator (line 132) | public class ASIterator implements Iterator<N> {
      method ASIterator (line 138) | private ASIterator() {
      method hasNext (line 143) | @Override
      method next (line 148) | @Override
      method remove (line 172) | @Override
    type AcceptanceProbability (line 187) | public interface AcceptanceProbability {
      method compute (line 188) | Double compute(Double oldScore, Double newScore, Double temp);
    type SuccessorFinder (line 196) | public interface SuccessorFinder<A, S, N extends Node<A, S, N>> {
      method estimate (line 201) | N estimate(N node, NodeExpander<A, S, N> nodeExpander);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/algorithm/localsearch/HillClimbing.java
  class HillClimbing (line 52) | public class HillClimbing<A,S,C extends Comparable<C>,N extends Heuristi...
    method HillClimbing (line 58) | public HillClimbing(N initialNode, NodeExpander<A, S, N> nodeExpander) {
    method HillClimbing (line 70) | public HillClimbing(N initialNode, NodeExpander<A, S, N> nodeExpander,...
    class EHCIterator (line 76) | public class EHCIterator implements Iterator<N> {
      method EHCIterator (line 80) | private EHCIterator() {
      method hasNext (line 85) | @Override
      method next (line 90) | @Override
      method remove (line 126) | @Override
      method getQueue (line 134) | public Queue<N> getQueue() {
      method setQueue (line 141) | public void setQueue(Queue<N> queue) {
      method getBestScore (line 148) | public C getBestScore() {
      method setBestScore (line 155) | public void setBestScore(C bestScore) {
    method iterator (line 161) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/DirectedEdge.java
  class DirectedEdge (line 3) | public class DirectedEdge<V,E> implements GraphEdge<V,E> {
    method DirectedEdge (line 8) | public DirectedEdge(V vertex1, V vertex2, E value) {
    method getVertex1 (line 13) | @Override
    method getVertex2 (line 18) | @Override
    method getEdgeValue (line 23) | @Override
    method getType (line 28) | @Override
    method equals (line 33) | @Override
    method hashCode (line 45) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphBuilder.java
  class GraphBuilder (line 35) | public class GraphBuilder<V, E> {
    class Connection (line 37) | private class Connection {
      method Connection (line 42) | private Connection(V vertex1, V vertex2, E edge) {
      method Connection (line 48) | private Connection(V vertex1, V vertex2) {
      method getVertex1 (line 54) | public V getVertex1() {
      method setVertex1 (line 58) | public void setVertex1(V vertex1) {
      method getVertex2 (line 62) | public V getVertex2() {
      method setVertex2 (line 66) | public void setVertex2(V vertex2) {
      method getEdge (line 70) | public E getEdge() {
      method setEdge (line 74) | public void setEdge(E edge) {
      method equals (line 78) | @Override
    method GraphBuilder (line 93) | private GraphBuilder() {}
    method create (line 95) | public static <V, E> GraphBuilder<V,E> create() {
    method connect (line 99) | public Vertex1 connect(V vertex) {
    method connect (line 103) | public GraphBuilder<V, E> connect(V vertex1, V vertex2) {
    method createDirectedGraph (line 109) | public HipsterDirectedGraph<V,E> createDirectedGraph() {
    method createUndirectedGraph (line 119) | public HipsterGraph<V,E> createUndirectedGraph() {
    method buildDirectedGraph (line 133) | @Deprecated
    method buildUndirectedGraph (line 142) | @Deprecated
    class Vertex1 (line 148) | public final class Vertex1 {
      method Vertex1 (line 151) | private Vertex1(V vertex) {
      method to (line 155) | public Vertex2 to(V vertex) {
      class Vertex2 (line 159) | public class Vertex2 {
        method Vertex2 (line 162) | private Vertex2(V vertex) {
        method withEdge (line 167) | public GraphBuilder<V, E> withEdge(E edge) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphEdge.java
  type GraphEdge (line 27) | public interface GraphEdge<V,E> {
    type Type (line 28) | enum Type { DIRECTED, UNDIRECTED }
    method getVertex1 (line 30) | V getVertex1();
    method getVertex2 (line 31) | V getVertex2();
    method getEdgeValue (line 32) | E getEdgeValue();
    method getType (line 33) | Type getType();

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/GraphSearchProblem.java
  class GraphSearchProblem (line 43) | public final class GraphSearchProblem {
    method startingFrom (line 45) | public static <V> FromVertex<V> startingFrom(V vertex) {
    class FromVertex (line 49) | public static class FromVertex<V> {
      method goalAt (line 53) | public FromVertex<V> goalAt(V vertex) {
      method FromVertex (line 58) | private FromVertex(V fromVertex) {
      method in (line 62) | public <E> CostType<E> in(final HipsterGraph<V, E> graph) {
      method inGraphWithLexicographicalOrder (line 92) | public <E> CostType<E> inGraphWithLexicographicalOrder(final Hipster...
      class CostType (line 133) | public class CostType<E> {
        method CostType (line 136) | private CostType(TransitionFunction<E, V> tf) {
        method takeCostsFromEdges (line 140) | public HeuristicType<Double> takeCostsFromEdges() {
        method extractCostFromEdges (line 174) | public HeuristicType<Double> extractCostFromEdges(final Function<E...
        method useGenericCosts (line 184) | public <C extends Comparable<C>> HeuristicType<C> useGenericCosts(...
        method build (line 194) | public SearchProblem<E, V, UnweightedNode<E, V>> build() {
        class HeuristicType (line 202) | public class HeuristicType<C extends Comparable<C>> {
          method HeuristicType (line 207) | private HeuristicType(CostFunction<E, V, C> cf, BinaryOperation<...
          method useScaleAlgebra (line 212) | public HeuristicType<C> useScaleAlgebra(ScalarOperation<C> scale...
          method useHeuristicFunction (line 217) | public Final useHeuristicFunction(HeuristicFunction<V, C> hf) {
          method build (line 221) | public SearchProblem<E, V, WeightedNode<E, V, C>> build() {
          class Final (line 230) | public class Final {
            method Final (line 233) | private Final(HeuristicFunction<V, C> hf) {
            method components (line 237) | public SearchComponents<E, V, C> components(){
            method build (line 241) | public SearchProblem<E, V, WeightedNode<E, V, C>> build() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/HashBasedHipsterDirectedGraph.java
  class HashBasedHipsterDirectedGraph (line 29) | public class HashBasedHipsterDirectedGraph<V, E> extends HashBasedHipste...
    method buildEdge (line 32) | @Override
    method outgoingEdgesOf (line 37) | @Override
    method incomingEdgesOf (line 47) | @Override
    method edges (line 57) | @Override
    method create (line 76) | public static <V, E> HashBasedHipsterDirectedGraph<V, E> create() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/HashBasedHipsterGraph.java
  class HashBasedHipsterGraph (line 29) | public class HashBasedHipsterGraph<V,E> implements HipsterMutableGraph<V...
    method HashBasedHipsterGraph (line 32) | public HashBasedHipsterGraph(){
    method add (line 36) | @Override
    method add (line 46) | @Override
    method remove (line 55) | @Override
    method remove (line 78) | @Override
    method connect (line 87) | @Override
    method buildEdge (line 101) | public GraphEdge<V,E> buildEdge(V v1, V v2, E value){
    method createEntry (line 105) | private Map.Entry<V, GraphEdge<V,E>> createEntry(final V vertex, final...
    method vedges (line 124) | protected Iterable<Map.Entry<V, GraphEdge<V,E>>> vedges(){
    method edges (line 142) | @Override
    method vertices (line 157) | @Override
    method edgesOf (line 162) | @Override
    method getConnected (line 173) | public HashMap<V, Set<GraphEdge<V, E>>> getConnected() {
    method setConnected (line 177) | public void setConnected(HashMap<V, Set<GraphEdge<V, E>>> connected) {
    method create (line 181) | public static <V,E> HashBasedHipsterGraph<V, E> create() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/HipsterDirectedGraph.java
  type HipsterDirectedGraph (line 25) | public interface HipsterDirectedGraph<V,E> extends HipsterGraph<V,E> {
    method outgoingEdgesOf (line 26) | Iterable<GraphEdge<V,E>> outgoingEdgesOf(V vertex);
    method incomingEdgesOf (line 27) | Iterable<GraphEdge<V,E>> incomingEdgesOf(V vertex);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/HipsterGraph.java
  type HipsterGraph (line 24) | public interface HipsterGraph<V,E> {
    method edges (line 29) | Iterable<GraphEdge<V,E>> edges();
    method vertices (line 35) | Iterable<V> vertices();
    method edgesOf (line 42) | Iterable<GraphEdge<V,E>> edgesOf(V vertex);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/HipsterMutableGraph.java
  type HipsterMutableGraph (line 11) | public interface HipsterMutableGraph<V,E> extends HipsterGraph<V,E> {
    method add (line 17) | boolean add(V vertex);
    method add (line 24) | Set<V> add(V... vertices);
    method remove (line 31) | boolean remove(V vertex);
    method remove (line 38) | Set<V> remove(V... vertices);
    method connect (line 47) | GraphEdge<V,E> connect(V vertex1, V vertex2, E edgeValue);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/Pair.java
  class Pair (line 4) | public class Pair<E> {
    method Pair (line 7) | public Pair(E e1, E e2) {
    method _1 (line 14) | public E _1() {
    method _2 (line 18) | public E _2() {
    method getE1 (line 22) | public E getE1() {
    method setE1 (line 26) | public void setE1(E e1) {
    method getE2 (line 30) | public E getE2() {
    method setE2 (line 34) | public void setE2(E e2) {
    method equals (line 38) | @Override
    method hashCode (line 50) | @Override
    method toString (line 57) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/UndirectedEdge.java
  class UndirectedEdge (line 4) | public class UndirectedEdge<V,E> implements GraphEdge<V,E> {
    method UndirectedEdge (line 9) | public UndirectedEdge(V vertex1, V vertex2, E value) {
    method getVertex1 (line 14) | @Override
    method getVertex2 (line 19) | @Override
    method getEdgeValue (line 24) | @Override
    method getType (line 29) | @Override
    method equals (line 34) | @Override
    method hashCode (line 46) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/UniqueEdge.java
  class UniqueEdge (line 28) | public class UniqueEdge<V> {
    method UniqueEdge (line 33) | public UniqueEdge(V value) {
    method getValue (line 38) | public V getValue() {
    method setValue (line 42) | public void setValue(V value) {
    method getEdgeId (line 46) | public String getEdgeId() {
    method create (line 50) | public static <V> UniqueEdge<V> create(V value){
    method equals (line 54) | @Override
    method hashCode (line 67) | @Override
    method toString (line 74) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/graph/UnorderedPair.java
  class UnorderedPair (line 3) | public class UnorderedPair<E> {
    method UnorderedPair (line 6) | public UnorderedPair(E e1, E e2) {
    method contains (line 13) | public boolean contains(Object vertex){
    method getE1 (line 17) | public E getE1() {
    method setE1 (line 21) | public void setE1(E e1) {
    method getE2 (line 25) | public E getE2() {
    method setE2 (line 29) | public void setE2(E e2) {
    method equals (line 33) | @Override
    method hashCode (line 42) | @Override
    method toString (line 47) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/ADStarNode.java
  type ADStarNode (line 19) | public interface ADStarNode<A, S, C extends Comparable<C>, N extends ADS...
    method getG (line 24) | public C getG();
    method getV (line 29) | public C getV();
    method isDoUpdate (line 34) | public boolean isDoUpdate();
    method isConsistent (line 39) | public boolean isConsistent();
    method setG (line 44) | public void setG(C g);
    method setV (line 49) | public void setV(C v);
    method setDoUpdate (line 54) | public void setDoUpdate(boolean update);
    method setKey (line 59) | public void setKey(Key<C> key);
    method getKey (line 64) | public Key<C> getKey();
    method setPreviousNode (line 69) | public void setPreviousNode(N parent);
    method setState (line 74) | public void setState(S state);
    method setAction (line 79) | public void setAction(A action);
    class Key (line 86) | public static class Key<C extends Comparable<C>> implements Comparable...
      method Key (line 100) | public Key(C g, C v, C h, double e, BinaryOperation<C> add, ScalarFu...
      method update (line 108) | public void update(C g, C v, C h, double e, BinaryOperation<C> add, ...
      method calculate (line 115) | private void calculate(C g, C v, C h, double e, BinaryOperation<C> a...
      method Key (line 132) | public Key(C first, C second){
      method compareTo (line 143) | public int compareTo(Key<C> o) {
      method getFirst (line 155) | public C getFirst() {
      method getSecond (line 162) | public C getSecond() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/AbstractNode.java
  class AbstractNode (line 35) | public class AbstractNode<A,S,N extends AbstractNode<A,S,N>> implements ...
    method AbstractNode (line 48) | public AbstractNode(N previousNode, S state, A action) {
    method path (line 55) | @Override
    method pathSize (line 66) | @Override
    method previousNode (line 71) | @Override
    method state (line 76) | @Override
    method action (line 81) | @Override
    method toString (line 86) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/CostNode.java
  type CostNode (line 34) | public interface CostNode<A,S,C extends Comparable<C>,N extends CostNode...
    method getCost (line 39) | C getCost();

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/HeuristicNode.java
  type HeuristicNode (line 34) | public interface HeuristicNode<A,S,C extends Comparable<C>, N extends He...
    method getScore (line 43) | C getScore();
    method getEstimation (line 49) | C getEstimation();

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/Node.java
  type Node (line 34) | public interface Node<A,S,N extends Node<A,S,N>> {
    method path (line 42) | List<N> path();
    method pathSize (line 49) | int pathSize();
    method previousNode (line 56) | N previousNode();
    method state (line 62) | S state();
    method action (line 68) | A action();

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/SimpleTransition.java
  class SimpleTransition (line 28) | public class SimpleTransition<S> extends Transition<Void, S> {
    method SimpleTransition (line 36) | public SimpleTransition(S state) {
    method SimpleTransition (line 47) | public SimpleTransition(S fromState, S toState) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/Transition.java
  class Transition (line 34) | public class Transition<A,S> {
    method Transition (line 49) | public Transition(A action, S state) {
    method Transition (line 64) | public Transition(S fromState, A action, S toState) {
    method create (line 81) | public static <A,S> Transition<A,S> create(S fromState, A action, S to...
    method create (line 94) | public static <S> Transition<Void,S> create(S fromState, S toState){
    method getAction (line 101) | public A getAction() {
    method setAction (line 108) | public void setAction(A action) {
    method getState (line 115) | public S getState() {
    method setState (line 122) | public void setState(S state) {
    method getFromState (line 129) | public S getFromState() {
    method toString (line 133) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/ActionFunction.java
  type ActionFunction (line 28) | public interface ActionFunction<A,S> {
    method actionsFor (line 34) | Iterable<A> actionsFor(S state);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/ActionStateTransitionFunction.java
  type ActionStateTransitionFunction (line 29) | public interface ActionStateTransitionFunction<A,S> {
    method apply (line 36) | S apply(A action, S state);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/BinaryFunction.java
  type BinaryFunction (line 46) | public interface BinaryFunction<T> {
    method apply (line 56) | T apply(T a, T b);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/CostFunction.java
  type CostFunction (line 30) | public interface CostFunction<A, S, C extends Comparable<C>> {
    method evaluate (line 32) | public C evaluate(Transition<A,S> transition);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/HeuristicFunction.java
  type HeuristicFunction (line 27) | public interface HeuristicFunction<S,C> {
    method estimate (line 28) | C estimate(S state);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/NodeExpander.java
  type NodeExpander (line 29) | public interface NodeExpander<A,S,N extends Node<A,S,N>> {
    method expand (line 31) | Iterable<N> expand(N node);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/NodeFactory.java
  type NodeFactory (line 29) | public interface NodeFactory<A,S,N> {
    method makeNode (line 30) | N makeNode(N fromNode, Transition<A,S> transition);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/ScalarFunction.java
  type ScalarFunction (line 47) | public interface ScalarFunction<T> {
    method scale (line 56) | T scale(T a, double b);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/TransitionFunction.java
  type TransitionFunction (line 33) | public interface TransitionFunction<A,S> {
    method transitionsFrom (line 41) | Iterable<Transition<A,S>> transitionsFrom(S state);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/ADStarNodeExpander.java
  class ADStarNodeExpander (line 35) | public class ADStarNodeExpander<A, S, C extends Comparable<C>, N extends...
    method ADStarNodeExpander (line 58) | public ADStarNodeExpander(SearchComponents<A, S, C> components, NodeFa...
    method ADStarNodeExpander (line 76) | public ADStarNodeExpander(TransitionFunction<A, S> successorFunction, ...
    method setNodeConsistent (line 91) | public void setNodeConsistent(boolean nodeConsistent) {
    method expand (line 95) | @Override
    method expandTransitionsChanged (line 135) | public Iterable<N> expandTransitionsChanged(N begin, Iterable<Transiti...
    method updateConsistent (line 165) | private boolean updateConsistent(N node, N parent, Transition<A, S> tr...
    method updateInconsistent (line 190) | private boolean updateInconsistent(N node, Map<Transition<A, S>, N> pr...
    method predecessorsMap (line 221) | private Map<Transition<A, S>, N> predecessorsMap(S current){
    method setMaxV (line 239) | public void setMaxV(N node) {
    method setMaxG (line 248) | public void setMaxG(N node)  {
    method setEpsilon (line 257) | public void setEpsilon(double epsilon) {
    method getEpsilon (line 266) | public double getEpsilon() {
    method getVisited (line 273) | public Map<S, N> getVisited() { return visited; }
    method clearVisited (line 278) | public void clearVisited() { this.visited = new HashMap<S, N>(); }
    method makeNode (line 287) | public N makeNode(N from, Transition<A, S> transition){
    method updateKey (line 294) | public void updateKey(N node){
    method setMaxKey (line 298) | public void setMaxKey(N node){

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/ADStarNodeFactory.java
  class ADStarNodeFactory (line 33) | public class ADStarNodeFactory<A, S, C extends Comparable<C>> implements...
    method ADStarNodeFactory (line 50) | public ADStarNodeFactory(BinaryOperation<C> addOp, ScalarOperation<C> ...
    method ADStarNodeFactory (line 64) | public ADStarNodeFactory(SearchComponents<A, S, C> components){
    method makeNode (line 68) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/ADStarNodeUpdater.java
  class ADStarNodeUpdater (line 48) | public class ADStarNodeUpdater<A, S, C extends Comparable<C>> {
    method ADStarNodeUpdater (line 67) | public ADStarNodeUpdater(CostFunction<A, S, C> costFunction,

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/BinaryOperation.java
  class BinaryOperation (line 33) | public class BinaryOperation<E extends Comparable<E>> implements BinaryF...
    method BinaryOperation (line 46) | public BinaryOperation(BinaryFunction<E> operation, E identityElem, E ...
    method apply (line 59) | @Override
    method getMaxElem (line 67) | public E getMaxElem() {
    method getIdentityElem (line 74) | public E getIdentityElem() {
    method doubleAdditionOp (line 82) | public static BinaryOperation<Double> doubleAdditionOp() {
    method doubleMultiplicationOp (line 94) | public static BinaryOperation<Double> doubleMultiplicationOp() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/LazyActionStateTransitionFunction.java
  class LazyActionStateTransitionFunction (line 40) | public class LazyActionStateTransitionFunction<A,S> implements Transitio...
    method LazyActionStateTransitionFunction (line 50) | public LazyActionStateTransitionFunction(ActionFunction<A, S> af, Acti...
    method transitionsFrom (line 55) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/LazyNodeExpander.java
  class LazyNodeExpander (line 40) | public class LazyNodeExpander<A,S,N extends Node<A,S,N>> implements Node...
    method LazyNodeExpander (line 51) | public LazyNodeExpander(TransitionFunction<A, S> tf, NodeFactory<A, S,...
    method expand (line 56) | @Override
    method getTransitionFunction (line 72) | public TransitionFunction<A, S> getTransitionFunction() {
    method getNodeFactory (line 79) | public NodeFactory<A, S, N> getNodeFactory() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/Product.java
  class Product (line 29) | public class Product implements ScalarFunction<Double> {
    method scale (line 38) | public Double scale(Double a, double b) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/ScalarOperation.java
  class ScalarOperation (line 18) | public class ScalarOperation<E extends Comparable<E>> implements ScalarF...
    method ScalarOperation (line 30) | public ScalarOperation(ScalarFunction<E> operation, double identityEle...
    method scale (line 35) | @Override
    method getIdentityElem (line 43) | public double getIdentityElem() {
    method doubleMultiplicationOp (line 53) | public static ScalarOperation<Double> doubleMultiplicationOp() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/StateTransitionFunction.java
  class StateTransitionFunction (line 38) | public abstract class StateTransitionFunction<S> implements TransitionFu...
    method transitionsFrom (line 40) | @Override
    method successorsOf (line 57) | public abstract Iterable<S> successorsOf(S state);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/function/impl/WeightedNodeFactory.java
  class WeightedNodeFactory (line 42) | public class WeightedNodeFactory<A,S,C extends Comparable<C>> implements...
    method WeightedNodeFactory (line 56) | public WeightedNodeFactory(CostFunction<A, S, C> costFunction, Heurist...
    method WeightedNodeFactory (line 69) | public WeightedNodeFactory(CostFunction<A, S, C> costFunction, BinaryO...
    method makeNode (line 79) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/impl/ADStarNodeImpl.java
  class ADStarNodeImpl (line 19) | public class ADStarNodeImpl<A, S, C extends Comparable<C>>
    method ADStarNodeImpl (line 39) | public ADStarNodeImpl(Transition<A, S> transition, ADStarNodeImpl<A, S...
    method getG (line 51) | @Override
    method getV (line 61) | @Override
    method isDoUpdate (line 66) | @Override
    method setG (line 71) | @Override
    method setV (line 76) | @Override
    method setKey (line 81) | @Override
    method getKey (line 86) | @Override
    method setPreviousNode (line 91) | @Override
    method setState (line 96) | @Override
    method setAction (line 101) | @Override
    method setDoUpdate (line 106) | @Override
    method isConsistent (line 115) | public boolean isConsistent(){ return v.compareTo(g) > 0; }
    method getEstimation (line 117) | @Override
    method getScore (line 122) | @Override
    method getCost (line 127) | @Override
    method previousNode (line 138) | @SuppressWarnings("unchecked") //suppress warnings to return an ADStar...
    method compareTo (line 151) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/impl/UnweightedNode.java
  class UnweightedNode (line 32) | public class UnweightedNode<A,S> extends AbstractNode<A,S,UnweightedNode...
    method UnweightedNode (line 41) | public UnweightedNode(UnweightedNode<A, S> previousNode, S state, A ac...
    method UnweightedNode (line 52) | public UnweightedNode(UnweightedNode<A, S> previousNode, Transition<A,...
    method newNodeWithoutAction (line 65) | public static <S> UnweightedNode<Void,S> newNodeWithoutAction(Unweight...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/impl/WeightedNode.java
  class WeightedNode (line 32) | public class WeightedNode<A,S,C extends Comparable<C>>
    method WeightedNode (line 50) | public WeightedNode(WeightedNode<A, S, C> previousNode, S state, A act...
    method getScore (line 57) | @Override
    method getEstimation (line 62) | @Override
    method getCost (line 67) | @Override
    method compareTo (line 72) | @Override
    method toString (line 77) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/problem/ProblemBuilder.java
  class ProblemBuilder (line 31) | public final class ProblemBuilder {
    method ProblemBuilder (line 33) | private ProblemBuilder(){
    class Wizard (line 40) | public static final class Wizard {
      method Wizard (line 41) | private Wizard(){}
      class ActionState (line 46) | public static final class ActionState<S> {
        method ActionState (line 50) | public ActionState(S initialState) {
        method ActionState (line 55) | public ActionState(S initialState, S finalState) {
        method defineProblemWithExplicitActions (line 71) | public WithAction defineProblemWithExplicitActions(){
        method defineProblemWithoutActions (line 81) | public WithoutAction defineProblemWithoutActions(){
        class WithoutAction (line 88) | public final class WithoutAction {
          method WithoutAction (line 89) | private WithoutAction(){}
          method useTransitionFunction (line 109) | public Uninformed<Void> useTransitionFunction(TransitionFunction...
        class WithAction (line 117) | public final class WithAction {
          method WithAction (line 118) | private WithAction(){}
          method useActionFunction (line 125) | public <A> Action<A> useActionFunction(ActionFunction<A, S> acti...
          class Action (line 132) | public final class Action<A> {
            method Action (line 135) | public Action(ActionFunction<A, S> af) {
            method useTransitionFunction (line 146) | public Uninformed<A> useTransitionFunction(ActionStateTransiti...
          method useTransitionFunction (line 159) | public <A> Uninformed<A> useTransitionFunction(TransitionFunctio...
        class Uninformed (line 170) | public final class Uninformed<A> {
          method Uninformed (line 173) | private Uninformed(TransitionFunction<A, S> tf){
          method build (line 177) | public SearchProblem<A, S, UnweightedNode<A, S>> build(){
          method useCostFunction (line 195) | public Informed<Double> useCostFunction(CostFunction<A, S, Doubl...
          method useGenericCostFunction (line 200) | public <C extends Comparable<C>> Informed<C> useGenericCostFunct...
          class Informed (line 207) | public final class Informed<C extends Comparable<C>> {
            method Informed (line 211) | public Informed(CostFunction<A, S, C> cf, BinaryOperation<C> c...
            method build (line 216) | public SearchProblem<A, S, WeightedNode<A, S, C>> build(){
            method useHeuristicFunction (line 234) | public Heuristic useHeuristicFunction(HeuristicFunction<S, C> ...
            class Heuristic (line 241) | public final class Heuristic {
              method Heuristic (line 244) | public Heuristic(HeuristicFunction<S, C> hf) {
              method build (line 248) | public SearchProblem<A, S, WeightedNode<A, S, C>> build(){
      method initialState (line 262) | public <S> ActionState<S> initialState(S initialState){
      method initialState (line 266) | public <S> ActionState<S> initialState(S initialState, S finalState){
    method create (line 291) | public static Wizard create(){

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/problem/SearchComponents.java
  class SearchComponents (line 15) | public class SearchComponents<A, S, C extends Comparable<C>> {
    method SearchComponents (line 29) | public SearchComponents(S begin, S goal, CostFunction<A, S, C> cf, Heu...
    method SearchComponents (line 41) | public SearchComponents(S begin, S goal, CostFunction<A, S, C> cf, Heu...
    method SearchComponents (line 46) | public SearchComponents(S begin, S goal, CostFunction<A, S, C> cf, Heu...
    method costFunction (line 51) | public CostFunction<A, S, C> costFunction() {
    method heuristicFunction (line 55) | public HeuristicFunction<S, C> heuristicFunction() {
    method successorFunction (line 59) | public TransitionFunction<A, S> successorFunction() {
    method predecessorFunction (line 63) | public TransitionFunction<A, S> predecessorFunction() {
    method costAlgebra (line 67) | public BinaryOperation<C> costAlgebra() {
    method scaleAlgebra (line 71) | public ScalarOperation<C> scaleAlgebra() {
    method getBegin (line 75) | public S getBegin() {
    method getGoal (line 79) | public S getGoal() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/model/problem/SearchProblem.java
  class SearchProblem (line 13) | public class SearchProblem<A,S,N extends Node<A,S,N>> {
    method SearchProblem (line 18) | public SearchProblem(N initialNode, NodeExpander<A, S, N> expander) {
    method SearchProblem (line 24) | public SearchProblem(N initialNode, N finalNode, NodeExpander<A, S, N>...
    method getInitialNode (line 30) | public N getInitialNode() {
    method getExpander (line 34) | public NodeExpander<A, S, N> getExpander() {
    method getFinalNode (line 38) | public N getFinalNode() {
    method setFinalNode (line 42) | public void setFinalNode(N finalNode) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/F.java
  class F (line 17) | public final class F {
    method F (line 19) | private F() {}
    method map (line 21) | public static <T,E> Iterable<E> map(final Iterable<T> it, final Functi...
    method map (line 30) | public static <T,E> Iterator<E> map(final Iterator<T> it, final Functi...
    method filter (line 42) | public static <T> Iterable<T> filter(final Iterable<T> it, final Funct...
    method filter (line 51) | public static <T> Iterator<T> filter(final Iterator<T> it, final Funct...
    method flatMap (line 66) | public static <E,T> Iterable<T> flatMap(final Iterable<E> it, final Fu...
    method flatMap (line 80) | public static <E,T> Iterator<T> flatMap(final Iterator<E> it, final Fu...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/Function.java
  type Function (line 8) | public interface Function<E, V> {
    method apply (line 10) | public V apply(E input);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/Iterators.java
  class Iterators (line 7) | public final class Iterators {
    class AbstractIterator (line 9) | public static abstract class AbstractIterator<E> implements Iterator<E> {
      method AbstractIterator (line 12) | protected AbstractIterator(){}
      method computeNext (line 14) | protected abstract E computeNext();
      method hasNext (line 16) | @Override
      method next (line 24) | @Override
      method remove (line 38) | @Override
    method empty (line 44) | public static <E> Iterator<E> empty() {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/Predicate.java
  type Predicate (line 11) | public interface Predicate<T extends Object> {
    method apply (line 13) | public boolean apply(T input);

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/examples/RomanianProblem.java
  class RomanianProblem (line 21) | public class RomanianProblem {
    type City (line 26) | public enum City{
    method graph (line 93) | public static HipsterGraph<City, Double> graph(){
    method heuristics (line 101) | public static Map<City, Double> heuristics(){
    method heuristicFunction (line 110) | public static HeuristicFunction<City, Double> heuristicFunction(){

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/examples/maze/Maze2D.java
  class Maze2D (line 70) | public class Maze2D {
    type Symbol (line 82) | public static enum Symbol {
      method Symbol (line 90) | Symbol(char symbol) {
      method value (line 94) | public char value() {
      method parse (line 98) | public static Symbol parse(char c) {
    method Maze2D (line 114) | public Maze2D(char maze[][]) {
    method charToPoint (line 122) | private Point charToPoint(char c){
    method Maze2D (line 136) | public Maze2D(String[] maze2D) throws IllegalFormatException {
    method findMaxRowLength (line 180) | private int findMaxRowLength(String maze[]){
    method findMaxRowLength (line 194) | private int findMaxRowLength(char maze[][]){
    method read (line 209) | public static Maze2D read(File file) throws IOException {
    method isFree (line 226) | public boolean isFree(Point p) {
    method getMazePoints (line 235) | public List<Point> getMazePoints() {
    method updateLocation (line 251) | public void updateLocation(Point p, Symbol symbol) {
    method updateRectangle (line 263) | public void updateRectangle(Point a, Point b, Symbol symbol) {
    method putObstacle (line 279) | public void putObstacle(Point p) {
    method removeObstacle (line 287) | public void removeObstacle(Point p) {
    method putObstacleRectangle (line 296) | public void putObstacleRectangle(Point a, Point b) {
    method removeObstacleRectangle (line 305) | public void removeObstacleRectangle(Point a, Point b) {
    method getReplacedMazeString (line 315) | public String getReplacedMazeString(List<Map<Point, Character>> replac...
    method getStringMazeFilled (line 341) | public String getStringMazeFilled(Collection<Point> points, char symbo...
    method replaceChar (line 349) | private static String replaceChar(String line, int position, char c) {
    method validLocation (line 360) | public boolean validLocation(Point loc) {
    method pointInBounds (line 373) | public boolean pointInBounds(Point loc) {
    method validLocationsFrom (line 382) | public Collection<Point> validLocationsFrom(Point loc) {
    method getMazeCharArray (line 401) | public char[][] getMazeCharArray() {
    method toStringArray (line 405) | public String[] toStringArray() {
    method toString (line 414) | @Override
    method diff (line 430) | public Set<Point> diff(Maze2D to) {
    method getMaze (line 448) | public char[][] getMaze() {
    method getInitialLoc (line 456) | public Point getInitialLoc() {
    method getGoalLoc (line 464) | public Point getGoalLoc() {
    method empty (line 473) | public static Maze2D empty(int size) {

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/examples/maze/MazeSearch.java
  class MazeSearch (line 34) | public final class MazeSearch {
    method MazeSearch (line 37) | private MazeSearch() {
    class Result (line 44) | public static final class Result {
      method Result (line 50) | public Result(List<Point> path, Double cost) {
      method getCost (line 55) | public Double getCost() {
      method getPath (line 59) | public List<Point> getPath() {
      method hashCode (line 63) | @Override
      method equals (line 71) | @Override
    method printSearch (line 94) | public static void printSearch(Iterator<? extends Node<?,Point,?>> it,...
    method clearOutput (line 119) | public static void clearOutput(int newlines) {
    method getMazeStringSolution (line 134) | public static String getMazeStringSolution(Maze2D maze, Collection<Poi...

FILE: hipster-core/src/main/java/es/usc/citius/hipster/util/examples/maze/Mazes.java
  class Mazes (line 10) | public final class Mazes {
    method Mazes (line 12) | private Mazes(){
    type TestMaze (line 133) | public enum TestMaze {
      method TestMaze (line 144) | TestMaze(Maze2D maze, double minimalPathCost){
      method getMinimalPathCost (line 149) | public double getMinimalPathCost() {
      method getMaze (line 153) | public Maze2D getMaze() {

FILE: hipster-core/src/main/java/es/usc/citius/lab/hipster/collections/FibonacciHeap.java
  class FibonacciHeap (line 82) | public final class FibonacciHeap<T> {
    class Entry (line 90) | public static final class Entry<T> {
      method getValue (line 109) | public T getValue() {
      method setValue (line 118) | public void setValue(T value) {
      method getPriority (line 127) | public double getPriority() {
      method Entry (line 138) | private Entry(T elem, double priority) {
    method enqueue (line 160) | public Entry<T> enqueue(T value, double priority) {
    method min (line 186) | public Entry<T> min() {
    method isEmpty (line 197) | public boolean isEmpty() {
    method size (line 206) | public int size() {
    method merge (line 222) | public static <T> FibonacciHeap<T> merge(FibonacciHeap<T> one, Fibonac...
    method dequeueMin (line 251) | public Entry<T> dequeueMin() {
    method decreaseKey (line 405) | public void decreaseKey(Entry<T> entry, double newPriority) {
    method delete (line 422) | public void delete(Entry<T> entry) {
    method checkPriority (line 439) | private void checkPriority(double priority) {
    method mergeLists (line 460) | private static <T> Entry<T> mergeLists(Entry<T> one, Entry<T> two) {
    method decreaseKeyUnchecked (line 520) | private void decreaseKeyUnchecked(Entry<T> entry, double priority) {
    method cutNode (line 546) | private void cutNode(Entry<T> entry) {

FILE: hipster-core/src/main/java/es/usc/citius/lab/hipster/collections/HashQueue.java
  class HashQueue (line 13) | public class HashQueue<S> extends AbstractQueue<S> {
    method offer (line 18) | @Override
    method poll (line 27) | @Override
    method peek (line 37) | @Override
    method iterator (line 42) | @Override
    method size (line 47) | @Override
    method contains (line 52) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/lab/hipster/collections/adapter/HeuristicNodePriorityEvaluator.java
  class HeuristicNodePriorityEvaluator (line 33) | public class HeuristicNodePriorityEvaluator<A, S, C extends Comparable<C...
    method getPriority (line 34) | @Override

FILE: hipster-core/src/main/java/es/usc/citius/lab/hipster/collections/adapter/PriorityEvaluator.java
  type PriorityEvaluator (line 30) | public interface PriorityEvaluator<N> {
    method getPriority (line 38) | double getPriority(N n);

FILE: hipster-core/src/main/java/es/usc/citius/lab/hipster/collections/adapter/PriorityFibonacciQueue.java
  class PriorityFibonacciQueue (line 32) | public class PriorityFibonacciQueue<N> extends AbstractQueue<N> {
    method PriorityFibonacciQueue (line 36) | public PriorityFibonacciQueue(PriorityEvaluator<N> evaluator) {
    method iterator (line 40) | @Override
    method size (line 60) | @Override
    method offer (line 65) | @Override
    method poll (line 71) | @Override
    method peek (line 76) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/ADStarRomaniaProblemOptimalSearchTest.java
  class ADStarRomaniaProblemOptimalSearchTest (line 20) | public class ADStarRomaniaProblemOptimalSearchTest extends RomaniaProble...
    method createAlgorithm (line 22) | @Override
    method iterativeSearch (line 36) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/AStarRomaniaProblemOptimalSearchTest.java
  class AStarRomaniaProblemOptimalSearchTest (line 20) | public class AStarRomaniaProblemOptimalSearchTest extends RomaniaProblem...
    method createAlgorithm (line 22) | @Override
    method iterativeSearch (line 36) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/BellmanFordRomaniaProblemOptimalSearchTest.java
  class BellmanFordRomaniaProblemOptimalSearchTest (line 20) | public class BellmanFordRomaniaProblemOptimalSearchTest extends RomaniaP...
    method createAlgorithm (line 22) | @Override
    method iterativeSearch (line 34) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/DijkstraRomaniaProblemOptimalSearchTest.java
  class DijkstraRomaniaProblemOptimalSearchTest (line 22) | public class DijkstraRomaniaProblemOptimalSearchTest extends RomaniaProb...
    method createAlgorithm (line 24) | @Override
    method iterativeSearch (line 36) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/IDAStarRomaniaProblemOptimalSearchTest.java
  class IDAStarRomaniaProblemOptimalSearchTest (line 20) | public class IDAStarRomaniaProblemOptimalSearchTest extends RomaniaProbl...
    method createAlgorithm (line 22) | @Override
    method iterativeSearch (line 36) | @Override

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/RomaniaProblemOptimalHeuristicSearchTest.java
  class RomaniaProblemOptimalHeuristicSearchTest (line 15) | public abstract class RomaniaProblemOptimalHeuristicSearchTest extends R...
    method RomaniaProblemOptimalHeuristicSearchTest (line 19) | public RomaniaProblemOptimalHeuristicSearchTest(){
    method scoresFromAradToBucharest (line 41) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/hipster/algorithm/problem/romanian/RomaniaProblemOptimalSearchTest.java
  class RomaniaProblemOptimalSearchTest (line 30) | public abstract class RomaniaProblemOptimalSearchTest {
    method RomaniaProblemOptimalSearchTest (line 40) | public RomaniaProblemOptimalSearchTest(){
    method optimalPathFromAradToBucharest (line 76) | @Test
    method optimalPathFromAradToBucharestSearchMethod (line 94) | @Test
    method costsFromAradToBucharest (line 112) | @Test
    method doSearch (line 132) | @Before
    method iterativeSearch (line 146) | public abstract List<? extends Node<Void, RomanianProblem.City, ?>> it...
    method createAlgorithm (line 153) | public abstract Algorithm<Void, RomanianProblem.City, ? extends Node<V...

FILE: hipster-core/src/test/java/es/usc/citius/hipster/graph/HashBasedHipsterDirectedGraphTest.java
  class HashBasedHipsterDirectedGraphTest (line 12) | public class HashBasedHipsterDirectedGraphTest {
    method setUp (line 17) | @Before
    method createStarGraph (line 22) | protected HashBasedHipsterDirectedGraph createStarGraph(int vertices){
    method testOutgoingEdgesOf (line 33) | @Test
    method testIncomingEdgesOf (line 41) | @Test
    method testEdges (line 49) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/hipster/graph/HashBasedHipsterGraphTest.java
  class HashBasedHipsterGraphTest (line 12) | public class HashBasedHipsterGraphTest {
    method createStarGraph (line 16) | protected HashBasedHipsterGraph createStarGraph(int vertices){
    method setUp (line 27) | @Before
    method testGraphEdges (line 32) | private void testGraphEdges(){
    method testEdges (line 44) | @Test
    method testEdgesWithDisconnectedVertices (line 49) | @Test
    method testAdd (line 56) | @Test
    method testRemove (line 64) | @Test
    method testRemoveAndCheckEdges (line 70) | @Test
    method testConnect (line 83) | @Test
    method testVertices (line 93) | @Test
    method testEdgesOf (line 99) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/hipster/graph/UndirectedEdgeTest.java
  class UndirectedEdgeTest (line 7) | public class UndirectedEdgeTest {
    method testEqualsWithUndirectedEdgeSwapped (line 9) | @Test
    method testEqualsWithUndirectedEdge (line 16) | @Test
    method testNotEqualsWithUndirectedEdge (line 23) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/hipster/util/graph/GraphBuilderTest.java
  class GraphBuilderTest (line 33) | public class GraphBuilderTest {
    method setUp (line 37) | @BeforeClass
    method testVertices (line 61) | @Test
    method testEdges (line 68) | @Test
    method testIncomingEdges (line 90) | @Test
    method testOutgoingEdges (line 109) | @Test
    method testEdgeSetter (line 128) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/hipster/util/graph/RomanianProblemGraph.java
  class RomanianProblemGraph (line 33) | public class RomanianProblemGraph {
    method setUp (line 36) | @Before
    method testAradRoads (line 41) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/algorithm/BellmanFordTest.java
  class BellmanFordTest (line 37) | public class BellmanFordTest {
    method negativeCycleTest (line 39) | @Test(expected = NegativeCycleException.class)
    method negativeWeightedGraphTest (line 54) | @Test
    method completeRandomGraph (line 82) | public static HashBasedHipsterGraph<Integer, Integer> completeRandomGr...

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/algorithm/DepthFirstSearchTest.java
  class DepthFirstSearchTest (line 34) | public class DepthFirstSearchTest {
    method testTree (line 36) | @Test
    method testGraphWithoutCycles (line 62) | @Test
    method testGraph (line 79) | @Test
    method verify (line 97) | private void verify(Iterator<UnweightedNode<String, String>> iterator,...

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/algorithm/DepthLimitedSearchTest.java
  class DepthLimitedSearchTest (line 35) | public class DepthLimitedSearchTest {
    method testTreeStructureNotFound (line 36) | @Test
    method testTreeStructureFound (line 64) | @Test
    method testGraphFound (line 118) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/algorithm/MultiobjectiveShortestPathTest.java
  class MultiobjectiveShortestPathTest (line 30) | public class MultiobjectiveShortestPathTest {
    class Cost (line 32) | public static class Cost implements Comparable<Cost> {
      method Cost (line 36) | public Cost(double c1, double c2) {
      method toString (line 41) | @Override
      method compareTo (line 49) | @Override
      method equals (line 61) | @Override
      method hashCode (line 74) | @Override
    method test (line 85) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/collection/HashQueueTest.java
  class HashQueueTest (line 28) | public class HashQueueTest {
    method testOffer (line 29) | @Test
    method testPoll (line 36) | @Test
    method testPeek (line 44) | @Test
    method testIterator (line 52) | @Test
    method testContains (line 68) | @Test

FILE: hipster-core/src/test/java/es/usc/citius/lab/hipster/maze/Maze2DTest.java
  class Maze2DTest (line 34) | public class Maze2DTest {
    method testDiff (line 99) | @Ignore("To be fixed")
    method testPoints (line 113) | @Test
    method testObstacles (line 129) | @Ignore("To be fixed")
    method testPointInBounds (line 141) | @Test
    method testCharToPoint (line 158) | @Test

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/ASCIIMazeVisualizer.java
  class ASCIIMazeVisualizer (line 35) | public class ASCIIMazeVisualizer {
    method $$$setupUI$$$ (line 74) | private void $$$setupUI$$$() {
    method $$$getRootComponent$$$ (line 154) | public JComponent $$$getRootComponent$$$() {
    type State (line 158) | private enum State {STOPPED, STARTED, PAUSED}
    method main (line 172) | public static void main(String[] args) {
    method ASCIIMazeVisualizer (line 187) | public ASCIIMazeVisualizer(final JFrame frame) {
    method continueExecution (line 259) | private void continueExecution() {
    method executeSearchStep (line 266) | private synchronized Node<?, Point, ?> executeSearchStep() {
    method start (line 284) | private void start() {
    method stop (line 301) | private void stop() {
    method pause (line 306) | private void pause() {
    method updateVisualizer (line 311) | private synchronized void updateVisualizer(final Node<?, Point, ?> nod...
    class ExecutionHandler (line 337) | private class ExecutionHandler implements ActionListener, Runnable {
      method ExecutionHandler (line 339) | private ExecutionHandler() {
      method actionPerformed (line 342) | @Override
      method run (line 349) | @Override
    method createAlgorithm (line 366) | private Iterator<? extends Node<?, Point, ?>> createAlgorithm(Maze2D m...
    method loadSelectedMaze (line 394) | private void loadSelectedMaze() {
    method getMazeStringSolution (line 414) | private String getMazeStringSolution(Maze2D maze, Collection<Point> ex...
    method buildProblem (line 429) | private SearchProblem<Void, Point, WeightedNode<Void, Point, Double>> ...

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/BlueprintsGraphMultiobjectiveSearch.java
  class BlueprintsGraphMultiobjectiveSearch (line 31) | public class BlueprintsGraphMultiobjectiveSearch {
    method main (line 33) | public static void main(String[] args) throws IOException {
    method buildGraph (line 98) | private static Graph buildGraph() {
    class Cost (line 151) | static class Cost implements Comparable<Cost> {
      method Cost (line 161) | public Cost(double c1, double c2) {
      method toString (line 166) | @Override
      method compareTo (line 182) | @Override
      method equals (line 199) | @Override
      method hashCode (line 212) | @Override

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/DirectedGraphSearchExample.java
  class DirectedGraphSearchExample (line 22) | public class DirectedGraphSearchExample {
    method main (line 24) | public static void main(String[] args){

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/EightPuzzleProblemExample.java
  class EightPuzzleProblemExample (line 57) | public class EightPuzzleProblemExample {
    method main (line 59) | public static void main(String[] args){

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/EightQueensProblemExample.java
  class EightQueensProblemExample (line 61) | public class EightQueensProblemExample {
    method main (line 63) | public static void main(String[] args) {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/EightQueensProblemExampleWithAnnealingSearch.java
  class EightQueensProblemExampleWithAnnealingSearch (line 51) | public class EightQueensProblemExampleWithAnnealingSearch {
    method main (line 53) | public static void main(String[] args) {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/MazeShortestPathExample.java
  class MazeShortestPathExample (line 48) | public class MazeShortestPathExample {
    method main (line 50) | public static void main(String[] args) throws InterruptedException {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/RomanianProblemDFSExample.java
  class RomanianProblemDFSExample (line 26) | public class RomanianProblemDFSExample {
    method main (line 28) | public static void main(String[] args) throws InterruptedException {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/RomanianProblemExample.java
  class RomanianProblemExample (line 31) | public class RomanianProblemExample {
    method main (line 33) | public static void main(String[] args) throws InterruptedException {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/SimpleEightPuzzleExample.java
  class SimpleEightPuzzleExample (line 57) | public class SimpleEightPuzzleExample {
    type Action (line 59) | enum Action { UP, DOWN, LEFT, RIGHT }
    method main (line 61) | public static void main(String[] args){
    method applyActionToState (line 157) | private static List<Integer> applyActionToState(Action action, List<In...
    method validMovementsFor (line 196) | private static Iterable<Action> validMovementsFor(List<Integer> state) {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/UndirectedGraphSearchExample.java
  class UndirectedGraphSearchExample (line 31) | public class UndirectedGraphSearchExample {
    method main (line 33) | public static void main(String args[]) {

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/problem/NPuzzle.java
  class NPuzzle (line 29) | public final class NPuzzle {
    method NPuzzle (line 31) | private NPuzzle(){}
    method getPrettyPath (line 40) | public static String getPrettyPath(List<Puzzle> path, int size) {
    type PuzzleMove (line 69) | public enum PuzzleMove {
    class Puzzle (line 85) | public static final class Puzzle {
      method Puzzle (line 96) | public Puzzle(int[][] board) {
      method Puzzle (line 112) | public Puzzle(int[] plainBoard) {
      method matrixBoard (line 116) | int[][] matrixBoard(int[] plainBoard) {
      method copyBoard (line 129) | public int[][] copyBoard() {
      method getMatrixBoard (line 133) | public int[][] getMatrixBoard() {
      method isSquare (line 140) | boolean isSquare(int[][] board) {
      method getTile (line 150) | public Point getTile(int number) {
      method getPreviousBoard (line 163) | public Puzzle getPreviousBoard() {
      method setPreviousBoard (line 167) | public void setPreviousBoard(Puzzle previousBoard) {
      method toString (line 171) | @Override
      method equals (line 180) | @Override
      method hashCode (line 192) | @Override

FILE: hipster-examples/src/main/java/es/usc/citius/hipster/examples/problem/NQueens.java
  class NQueens (line 32) | public class NQueens {
    method NQueens (line 49) | public NQueens(int size) {
    method NQueens (line 58) | public NQueens(int queens[]) {
    method toString (line 62) | @Override
    method isAttacked (line 77) | public boolean isAttacked(int row, int column) {
    method isAttacked (line 91) | public boolean isAttacked(int row) {
    method attackedQueens (line 95) | public int attackedQueens() {
    method equals (line 108) | @Override
    method hashCode (line 120) | @Override
    method getQueens (line 125) | public int[] getQueens() {

FILE: hipster-examples/src/test/java/es/usc/citius/lab/hipster/examples/NQueensTest.java
  class NQueensTest (line 28) | public class NQueensTest {
    method test8QueenZeroAttacked (line 30) | @Test
    method test8QueenSameColumnDiagonalAttacked (line 36) | @Test
    method test8QueenSameColumnAttacked (line 42) | @Test
    method test8QueenEqualsHashCode (line 48) | @Test

FILE: hipster-extensions/src/main/java/es/usc/citius/hipster/extensions/graph/HashTableHipsterDirectedGraph.java
  class HashTableHipsterDirectedGraph (line 28) | public class HashTableHipsterDirectedGraph<V,E> extends HashTableHipster...
    method connect (line 30) | @Override
    method outgoingEdgesOf (line 40) | @Override
    method incomingEdgesOf (line 45) | @Override
    method create (line 50) | public static <V,E> HashTableHipsterDirectedGraph<V, E> create() {

FILE: hipster-extensions/src/main/java/es/usc/citius/hipster/extensions/graph/HashTableHipsterGraph.java
  class HashTableHipsterGraph (line 33) | public class HashTableHipsterGraph<V,E> implements HipsterGraph<V,E> {
    method add (line 38) | public void add(V v){
    method greaterThan (line 44) | private <T> boolean greaterThan(int size, Iterable<T> iterable){
    method remove (line 55) | public void remove(V v){
    method remove (line 75) | public void remove(V v, GraphEdge<V,E> edge){
    method connect (line 82) | public GraphEdge<V,E> connect(V v1, V v2, E value){
    method edges (line 92) | @Override
    method vertices (line 97) | @Override
    method edgesOf (line 102) | @Override
    method create (line 107) | public static <V,E> HashTableHipsterGraph<V, E> create() {

FILE: hipster-extensions/src/test/java/es/usc/citius/hipster/extensions/graph/HashTableHipsterDirectedGraphTest.java
  class HashTableHipsterDirectedGraphTest (line 30) | public class HashTableHipsterDirectedGraphTest extends HashTableHipsterG...
    method setUp (line 33) | @Before
    method testConnect (line 47) | @Test
    method testOutgoingEdgesOf (line 53) | @Test
    method testIncomingEdgesOf (line 61) | @Test
    method testEdges (line 69) | @Test
    method testEdgesOf (line 83) | @Test

FILE: hipster-extensions/src/test/java/es/usc/citius/hipster/extensions/graph/HashTableHipsterGraphTest.java
  class HashTableHipsterGraphTest (line 33) | public class HashTableHipsterGraphTest {
    method setUp (line 36) | @Before
    method testAdd (line 48) | @Test
    method testRemove (line 54) | @Test
    method testRemoveEdge (line 60) | @Test
    method testConnect (line 65) | @Test
    method testEdges (line 72) | @Test
    method testVertices (line 85) | @Test
    method testEdgesOf (line 91) | @Test
    method testDisconnectedVertices (line 100) | @Test

FILE: hipster-third-party-graphs/src/main/java/es/usc/citius/hipster/thirdparty/graphs/blueprints/BlueprintsHipsterDirectedGraphAdapter.java
  class BlueprintsHipsterDirectedGraphAdapter (line 30) | public class BlueprintsHipsterDirectedGraphAdapter extends BlueprintsHip...
    method BlueprintsHipsterDirectedGraphAdapter (line 32) | public BlueprintsHipsterDirectedGraphAdapter(Graph graph) {
    method outgoingEdgesOf (line 36) | @Override
    method incomingEdgesOf (line 41) | @Override

FILE: hipster-third-party-graphs/src/main/java/es/usc/citius/hipster/thirdparty/graphs/blueprints/BlueprintsHipsterGraphAdapter.java
  class BlueprintsHipsterGraphAdapter (line 35) | public class BlueprintsHipsterGraphAdapter implements HipsterGraph<Verte...
    method BlueprintsHipsterGraphAdapter (line 38) | public BlueprintsHipsterGraphAdapter(Graph graph) {
    method edges (line 42) | @Override
    method vertices (line 47) | @Override
    method edgesOf (line 52) | @Override
    method convertEdges (line 57) | protected static Iterable<GraphEdge<Vertex,Edge>> convertEdges(final I...

FILE: hipster-third-party-graphs/src/main/java/es/usc/citius/hipster/thirdparty/graphs/jung/JUNGHipsterDirectedGraphAdapter.java
  class JUNGHipsterDirectedGraphAdapter (line 33) | public class JUNGHipsterDirectedGraphAdapter<V,E> extends JUNGHipsterGra...
    method JUNGHipsterDirectedGraphAdapter (line 35) | public JUNGHipsterDirectedGraphAdapter(Graph<V, E> graph) {
    method outgoingEdgesOf (line 39) | @Override
    method incomingEdgesOf (line 53) | @Override

FILE: hipster-third-party-graphs/src/main/java/es/usc/citius/hipster/thirdparty/graphs/jung/JUNGHipsterGraphAdapter.java
  class JUNGHipsterGraphAdapter (line 37) | public class JUNGHipsterGraphAdapter<V,E> implements HipsterGraph<V,E> {
    method JUNGHipsterGraphAdapter (line 40) | public JUNGHipsterGraphAdapter(Graph<V, E> graph) {
    method adapt (line 44) | protected Iterable<GraphEdge<V,E>> adapt(final Iterable<E> iterable){
    method edges (line 60) | @Override
    method vertices (line 69) | @Override
    method edgesOf (line 74) | @Override

FILE: hipster-third-party-graphs/src/test/java/es/usc/citius/hipster/thirdparty/graphs/JUNGHipsterGraphAdapterTest.java
  class JUNGHipsterGraphAdapterTest (line 43) | public class JUNGHipsterGraphAdapterTest {
    method setUp (line 50) | @BeforeClass
    method testUniformShortestPathSearch (line 68) | @Test
    method testWeightedShortestPathSearch (line 85) | @Test