FunnelVertex.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2022 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.web.funnel.graph;
 
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import org.jgrapht.Graphs;
import org.turro.collections.CollectionUtil;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.entities.web.WebItem;
import org.turro.elephant.web.ElContext;
import org.turro.elephant.web.ElContextMap;
import org.turro.elephant.entities.web.WebItemType;
import org.turro.elephant.web.tags.TagsServlet;
import org.turro.graph.GraphUtil;
import org.turro.util.Comparison;
 
public class FunnelVertex implements Comparable<FunnelVertex> {
  
  private final FunnelGraph graph;
  private final WebItem item;
 
  public FunnelVertex(FunnelGraph graph, WebItem item) {
    this.graph = graph;
    this.item = item;
  }
 
  public boolean isActor() {
    return !(isChain() || isWrong());
  }
  
  public boolean isTarget() {
    return WebItemType.TARGET.equals(item.getType());
  }
  
  public boolean isSolution() {
    return WebItemType.SOLUTION.equals(item.getType());
  }
  
  public boolean isService() {
    return WebItemType.SERVICE.equals(item.getType());
  }
  
  public boolean isChain() {
    return WebItemType.CHAIN.equals(item.getType());
  }
  
  public boolean isWrong() {
    return item.getType() == null;
  }
  
  public String getWebTag() {
    return item.getWebTag();
  }
  
  public WebItemType getActingType() {
    if(isActor()) return item.getType();
    Set<WebItemType> types = GraphUtil.deepPredecessorListOf(graph, this, (v) -> v.isActor(), (v) -> v.isActor())
            .stream().map(v -> v.getItem().getType())
            .collect(Collectors.toSet());
    if(types.isEmpty() || types.size() > 1) return null;
    WebItemType type = CollectionUtil.from(types).first();
    if(WebItemType.CHAIN.equals(type)) return null;
    return type;
  }
  
  public Set<FunnelVertex> getNexts() {
    return Graphs.successorListOf(graph, this).stream().collect(Collectors.toCollection(TreeSet::new));
  }
  
  public Set<FunnelVertex> getTargets() {
    return switch(getActingType()) {
      case SOLUTION, SERVICE -> GraphUtil.deepPredecessorListOf(graph, this, (v) -> v.isTarget());
      default -> Collections.EMPTY_SET;
    };
  }
 
  public Set<FunnelVertex> getSolutions() {
    return switch(getActingType()) {
      case TARGET -> GraphUtil.deepSuccessorListOf(graph, this, (v) -> v.isSolution());
      case SERVICE -> GraphUtil.deepPredecessorListOf(graph, this, (v) -> v.isSolution());
      default -> Collections.EMPTY_SET;
    };
  }
 
  public Set<FunnelVertex> getServices() {
    return switch(getActingType()) {
      case TARGET, SOLUTION -> GraphUtil.deepSuccessorListOf(graph, this, (v) -> v.isService());
      default -> Collections.EMPTY_SET;
    };
  }
  
  public Set<FunnelVertex> getNeighborOf() {
    return Graphs.neighborSetOf(graph, this).stream()
            .filter(vertex -> !vertex.equals(this))
            .collect(Collectors.toSet());
  }
 
  public Set<FunnelVertex> getSiblings() {
    return switch(getActingType()) {
      case TARGET -> graph.getTargets().stream()
              .filter(v -> !v.equals(FunnelVertex.this))
              .collect(Collectors.toCollection(TreeSet::new));
      case SOLUTION -> getTargets().stream()
              .flatMap(v -> v.getSolutions().stream())
              .filter(v -> !v.equals(FunnelVertex.this))
              .collect(Collectors.toCollection(TreeSet::new));
      case SERVICE -> getSolutions().stream()
              .flatMap(v -> v.getServices().stream())
              .filter(v -> !v.equals(FunnelVertex.this))
              .collect(Collectors.toCollection(TreeSet::new));
      default -> Collections.EMPTY_SET;
    };
  }
 
  public WebItem getItem() {
    return item;
  }
  
  public List<String> getGoalActions() {
    return item.getGoals().stream().map(g -> g.getGoalAction()).toList();
  }
  
  public String getWebPath(IConstructor constructor) {
    ElContext context = ElContextMap.getContextFromWebTag(item.getWebTag());
    if(context != null) {
      return context.getFullPath();
    } else {
      return TagsServlet.navigateAndSet(item.getWebTag(), constructor.getCurrentContext().getPath());
    }
  }
 
  /* Utils */
 
  @Override
  public int hashCode() {
    int hash = 7;
    hash = 97 * hash + Objects.hashCode(this.item);
    return hash;
  }
 
  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final FunnelVertex other = (FunnelVertex) obj;
    return Objects.equals(this.item, other.item);
  }
 
  /* Comparable */
  
  @Override
  public int compareTo(FunnelVertex o) {
    return Comparison.ascendant()
            .compare(item.getOrdering(), o.getItem().getOrdering())
            .compare(item.getWebTag(), o.getItem().getWebTag())
            .get();
  }
 
}