Indicators.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 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.indicator;
 
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.turro.string.Strings;
import org.turro.annotation.ElephantIndicator;
import org.turro.reflection.Instances;
import org.turro.string.Words;
 
public class Indicators {
  
  /* Elephant Indicator */
  
  public static boolean hasDirectProcess(List<IndicatorVariable> variables) {
    return variables.stream().anyMatch(v -> !v.isPreprocess());
  }
 
  public static List<IndicatorVariable> getRankingVariables(String root) {
    IElephantIndicator ei = getIndicator(root);
    return ei != null ? ei.getAllRankingVariables(root): Collections.EMPTY_LIST;
  }
 
  public static List<IndicatorVariable> getMatchingVariables(String root) {
    IElephantIndicator ei = getIndicator(root);
    return ei != null ? ei.getAllMatchingVariables(root): Collections.EMPTY_LIST;
  }
 
  public static List<IndicatorVariable> getRankingVariablesFinal(String root) {
    List<IndicatorVariable> variables = getRankingVariables(root);
    variables.add(0, IndicatorVariable.result(root, VariableType.RANKING_VARIABLE));
    return variables;
  }
 
  public static List<IndicatorVariable> getMatchingVariablesFinal(String root) {
    List<IndicatorVariable> variables = getMatchingVariables(root);
    variables.add(0, IndicatorVariable.result(root, VariableType.MATCHING_VARIABLE));
    return variables;
  }
 
  public static IndicatorVariable getVariable(String root, String name) {
    IElephantIndicator ei = getIndicator(root);
    return ei != null ? ei.getVariable(name) : null;
  }
  
  public static IElephantIndicator getIndicator(String root) {
    for(IElephantIndicator iIndicator : getIndicators()) {
      if(iIndicator.itsMine(root)) {
        return iIndicator;
      }
    }
    return null;
  }
 
  public static IElephantIndicator getIndicator(IndicatorVariable variable) {
    for(IElephantIndicator iIndicator : getIndicators()) {
      if(iIndicator.itsMine(variable)) {
        return iIndicator;
      }
    }
    return null;
  }
 
  public static double getValue(Object entity, IndicatorVariable variable) {
    IElephantIndicator ei = getIndicator(variable);
    return ei != null ? ei.getValue(variable, entity) : 0.0;
  }
 
  public static double getValue(Object entity, String relatedPath, IndicatorVariable variable) {
    IElephantIndicator ei = getIndicator(variable);
    return ei != null ? ei.getValue(variable, entity, relatedPath) : 0.0;
  }
 
  /* Reading indicators */
  
  public static IndicatorResult readIndicator(String indicator) {
    if(!Strings.isBlank(indicator) && indicator.contains(":")) {
      String v[] = indicator.split("\\s*:\\s*");
      if(!Strings.isBlank(v[0]) && !Strings.isBlank(v[1]) && !Strings.isBlank(v[2])) {
        for(IElephantIndicator iIndicator : getIndicators()) {
          if(iIndicator.getClass().getSimpleName().equals(v[1])) {
            return iIndicator.readIndicator(v[0], v[2]);
          }
        }
      }
    }
    return new IndicatorResult(0, 0);
  }
 
  public static IndicatorResult readIndicator(String jpaClass, String indicatorClass, 
          String entityPath, String relatedPath, String indicator) {
    for(IElephantIndicator iIndicator : getIndicators()) {
      if(iIndicator.getClass().getSimpleName().equals(indicatorClass)) {
        return iIndicator.readIndicator(jpaClass, 
                Words.instance(".", entityPath, relatedPath, indicator).toString());
      }
    }
    return new IndicatorResult(0, 0);
  }
 
  public static List<IndicatorVariable> getVariables(String indicatorClass) {
    for(IElephantIndicator iIndicator : getIndicators()) {
      if(iIndicator.getClass().getSimpleName().equals(indicatorClass)) {
        return iIndicator.getAllVariables();
      }
    }
    return Collections.EMPTY_LIST;
  }
 
  /* Initiated indicators */
 
  private static List<IElephantIndicator> _indicators;
  private static final Lock indicatorLock = new ReentrantLock();
  
  public static List<IElephantIndicator> getIndicators() {
    if(_indicators == null) {
      indicatorLock.lock();
      try {
        if(_indicators == null) {
          _indicators = Instances.cached().byAnnotation(ElephantIndicator.class, IElephantIndicator.class);
          _indicators.stream().forEach(i -> i.initIndicator());
          _indicators.stream().forEach(i -> i.prepareIndicator());
        }
      } finally {
        indicatorLock.unlock();
      }
    }
    return _indicators;
  }
 
  private Indicators() {
  }
  
}