praktikum-holons/src/holeg/ui/view/information/FilterableGroupNode.java

package holeg.ui.view.information;

import holeg.model.*;

public class FilterableGroupNode extends GroupNode {
    public FilterableGroupNode() {
        super("temp");
    }

    public void add(AbstractCanvasObject object) {
        if (object instanceof HolonObject hObject) {
            objectList.add(hObject);
        }else if(object instanceof HolonSwitch hSwitch) {
            switchList.add(hSwitch);
        }else if(object instanceof Node node) {
            nodeList.add(node);
        }else if(object instanceof GroupNode groupNode) {
            groupNodeList.add(groupNode);
        }
    }

    public void remove(AbstractCanvasObject object) {
        if (object instanceof HolonObject hObject) {
            objectList.remove(hObject);
        }else if(object instanceof HolonSwitch hSwitch) {
            switchList.remove(hSwitch);
        }else if(object instanceof Node node) {
            nodeList.remove(node);
        }else if(object instanceof GroupNode groupNode) {
            groupNodeList.remove(groupNode);
        }
    }


//
//	// Returns the amount of holons and count himself
//	public int getAmountOfGroupNodes() {
//		return groupNodeList.stream().map(groupNode -> groupNode.getAmountOfGroupNodes()).reduce(1, Integer::sum);
//	}
//
//	public Stream<Flexibility> getFlexibilitiesStream(Predicate<DecoratedHolonObject> stateFilter,
//			Predicate<HolonElement> priorityFilter) {
//
//		Stream<Flexibility> flexInChildGorupNode = this.groupNodeList.stream()
//				.flatMap(groupNode -> groupNode.getFlexibilitiesStream(stateFilter, priorityFilter));
//
//		Stream<Flexibility> flexInThisGorupNode = objectStream().filter(stateFilter).flatMap(object -> object.getModel()
//				.getElements().filter(priorityFilter).flatMap(ele -> ele.flexList.stream()));
//
//		return Stream.concat(flexInChildGorupNode, flexInThisGorupNode);
//	}
//
//	public Stream<DecoratedHolonObject> objectStream() {
//		return Stream.concat(Stream.concat(this.consumerList.stream(), this.supplierList.stream()),
//				this.passivList.stream());
//	}
//
//	// Gather Informations:
//	public int getAmountOfSupplier(Predicate<DecoratedHolonObject> stateFilter) {
//		return (int) supplierList.stream().filter(stateFilter).count() + groupNodeList.stream()
//				.map(groupNode -> groupNode.getAmountOfSupplier(stateFilter)).reduce(0, Integer::sum);
//	}
//
//	public int getAmountOfConsumer(Predicate<DecoratedHolonObject> stateFilter) {
//		return (int) consumerList.stream().filter(stateFilter).count() + groupNodeList.stream()
//				.map(groupNode -> groupNode.getAmountOfConsumer(stateFilter)).reduce(0, Integer::sum);
//	}
//
//	public int getAmountOfPassiv(Predicate<DecoratedHolonObject> stateFilter) {
//		return (int) passivList.stream().filter(stateFilter).count() + groupNodeList.stream()
//				.map(groupNode -> groupNode.getAmountOfPassiv(stateFilter)).reduce(0, Integer::sum);
//	}
//
//	public int getAmountOfConsumerWithState(Predicate<DecoratedHolonObject> stateFilter, HolonObjectState state) {
//		return ((int) consumerList.stream().filter(stateFilter).map(con -> con.getState())
//				.filter(rightState -> (rightState == state)).count())
//				+ groupNodeList.stream().map(groupNode -> groupNode.getAmountOfConsumerWithState(stateFilter, state))
//						.reduce(0, Integer::sum);
//	}
//
//	public PriorityCounts getPriorityCounts(Predicate<DecoratedHolonObject> stateFilter) {
//		PriorityCounts priority = new PriorityCounts();
//		objectStream().filter(stateFilter)
//				.forEach(object -> object.getModel().getElements().forEach(ele -> priority.count(ele)));
//		groupNodeList.stream().forEach(groupNode -> priority.add(groupNode.getPriorityCounts(stateFilter)));
//		return priority;
//	}
//
//	public int getAmountOfElementsFromHolonObjects(Predicate<DecoratedHolonObject> stateFilter,
//			Predicate<HolonElement> priorityFilter) {
//		return objectStream().filter(stateFilter)
//				.map(object -> (int) object.getModel().getElements().filter(priorityFilter).count())
//				.reduce(0, Integer::sum)
//				+ groupNodeList.stream()
//						.map(groupNode -> groupNode.getAmountOfElementsFromHolonObjects(stateFilter, priorityFilter))
//						.reduce(0, Integer::sum);
//	}
//
//	public int getAmountOfAktiveElementsFromHolonObjects(Predicate<DecoratedHolonObject> stateFilter,
//			Predicate<HolonElement> priorityFilter) {
//		return objectStream().filter(stateFilter)
//				.map(object -> (int) object.getModel().getElements().filter(priorityFilter).count())
//				.reduce(0, Integer::sum)
//				+ groupNodeList.stream().map(
//						groupNode -> groupNode.getAmountOfAktiveElementsFromHolonObjects(stateFilter, priorityFilter))
//						.reduce(0, Integer::sum);
//	}
//
//	public float getConsumption(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
//		return ((Stream<DecoratedHolonObject>) Stream.concat(this.consumerList.stream(), supplierList.stream()))
//				.filter(stateFilter)
//				.map(con -> con.getModel().getElements()
//						.filter(priorityFilter.and(ele -> ele.getActualEnergy() < 0))
//						.map(ele -> -ele.getActualEnergy()).reduce(0.0f, Float::sum))
//				.reduce(0.f, Float::sum)
//				+ groupNodeList.stream().map(groupNode -> groupNode.getConsumption(stateFilter, priorityFilter))
//						.reduce(0.f, Float::sum);
//	}
//
//	public float getProduction(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
//		return ((Stream<DecoratedHolonObject>) Stream.concat(this.consumerList.stream(), supplierList.stream()))
//				.filter(stateFilter)
//				.map(con -> con.getModel().getElements()
//						.filter(priorityFilter.and(ele -> ele.getActualEnergy() > 0))
//						.map(ele -> ele.getActualEnergy()).reduce(0.0f, Float::sum))
//				.reduce(0.f, Float::sum)
//				+ groupNodeList.stream().map(groupNode -> groupNode.getProduction(stateFilter, priorityFilter))
//						.reduce(0.f, Float::sum);
//	}

}