AssureRequirementMetricsProcessor.java

/**
 * Copyright (c) 2004-2025 Carnegie Mellon University and others. (see Contributors file).
 * All Rights Reserved.
 * 
 * NO WARRANTY. ALL MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY
 * KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE
 * OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT
 * MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
 * 
 * This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 * SPDX-License-Identifier: EPL-2.0
 * 
 * Created, in part, with funding and support from the United States Government. (see Acknowledgments file).
 * 
 * This program includes and/or can make use of certain third party source code, object code, documentation and other
 * files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system
 * configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and
 * conditions contained in any such Third Party Software or separate license file distributed with such Third Party
 * Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party benefici-
 * aries to this license with respect to the terms applicable to their Third Party Software. Third Party Software li-
 * censes only apply to the Third Party Software and not any other portion of this program or this program as a whole.
 */
package org.osate.assure.evaluator;

import com.google.common.collect.Iterables;
import com.google.inject.Inject;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xtext.EcoreUtil2;
import org.eclipse.xtext.resource.IEObjectDescription;
import org.eclipse.xtext.resource.IResourceDescriptions;
import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ListExtensions;
import org.osate.aadl2.BusAccess;
import org.osate.aadl2.BusFeatureClassifier;
import org.osate.aadl2.ClassifierFeature;
import org.osate.aadl2.ComponentImplementation;
import org.osate.aadl2.DataAccess;
import org.osate.aadl2.DataPort;
import org.osate.aadl2.DataSubcomponentType;
import org.osate.aadl2.EventDataPort;
import org.osate.aadl2.Feature;
import org.osate.aadl2.NamedElement;
import org.osate.aadl2.Subcomponent;
import org.osate.alisa.workbench.alisa.AssurancePlan;
import org.osate.assure.assure.AssuranceCaseResult;
import org.osate.assure.assure.AssureResult;
import org.osate.assure.assure.ClaimResult;
import org.osate.assure.assure.Metrics;
import org.osate.assure.assure.ModelResult;
import org.osate.assure.assure.SubsystemResult;
import org.osate.categories.categories.Categories;
import org.osate.categories.categories.CategoriesPackage;
import org.osate.categories.categories.Category;
import org.osate.categories.categories.CategoryFilter;
import org.osate.reqspec.reqSpec.Requirement;
import org.osate.reqspec.reqSpec.SystemRequirementSet;
import org.osate.reqspec.util.IReqspecGlobalReferenceFinder;
import org.osate.verify.verify.Claim;
import org.osate.verify.verify.VerificationPlan;

@SuppressWarnings("all")
public class AssureRequirementMetricsProcessor implements IAssureRequirementMetricsProcessor {
  private final ResourceDescriptionsProvider rdp;

  private CategoryFilter myFilter;

  @Inject
  private IReqspecGlobalReferenceFinder reqSpecrefFinder;

  @Inject
  public AssureRequirementMetricsProcessor(final ResourceDescriptionsProvider rdp) {
    this.rdp = rdp;
  }

  @Inject
  protected IResourceDescriptions rds;

  @Override
  public void processCase(final AssuranceCaseResult assureResult, final CategoryFilter filter, final IProgressMonitor monitor) {
    this.myFilter = filter;
    this.process(assureResult);
  }

  protected void _process(final AssuranceCaseResult caseResult) {
    final Consumer<ModelResult> _function = (ModelResult modelResult) -> {
      this.process(modelResult);
    };
    caseResult.getModelResult().forEach(_function);
  }

  public int getTotalQualityCategoriesCount(final EObject ele) {
    int _xblockexpression = (int) 0;
    {
      EcoreUtil.resolveAll(ele);
      final IResourceDescriptions rds = this.rdp.getResourceDescriptions(ele.eResource());
      final Iterable<IEObjectDescription> categoriesDescriptions = rds.getExportedObjectsByType(CategoriesPackage.eINSTANCE.getCategories());
      final Function1<IEObjectDescription, Categories> _function = (IEObjectDescription it) -> {
        EObject _resolve = EcoreUtil.resolve(it.getEObjectOrProxy(), ele);
        return ((Categories) _resolve);
      };
      final Iterable<Categories> categories = IterableExtensions.<IEObjectDescription, Categories>map(categoriesDescriptions, _function);
      final Function1<Categories, Boolean> _function_1 = (Categories it) -> {
        return Boolean.valueOf(it.getName().equalsIgnoreCase("quality"));
      };
      final Function1<Categories, EList<Category>> _function_2 = (Categories it) -> {
        return it.getCategory();
      };
      _xblockexpression = IterableExtensions.<Category>toSet(Iterables.<Category>concat(IterableExtensions.<Categories, EList<Category>>map(IterableExtensions.<Categories>filter(categories, _function_1), _function_2))).size();
    }
    return _xblockexpression;
  }

  protected void _process(final ModelResult modelResult) {
    final ComponentImplementation targetComponent = modelResult.getTarget();
    final CategoryFilter categoryFilter = this.myFilter;
    Metrics _metrics = modelResult.getMetrics();
    _metrics.setFeaturesCount(targetComponent.getAllFeatures().size());
    final AssurancePlan plan = modelResult.getPlan();
    EcoreUtil.resolveAll(plan);
    final EList<VerificationPlan> verificationPlans = plan.getAssure();
    final Function1<VerificationPlan, List<Requirement>> _function = (VerificationPlan it) -> {
      final Function1<Claim, Requirement> _function_1 = (Claim it_1) -> {
        return it_1.getRequirement();
      };
      return ListExtensions.<Claim, Requirement>map(it.getClaim(), _function_1);
    };
    final Function1<Requirement, Boolean> _function_1 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Set<Requirement> claimReqs = IterableExtensions.<Requirement>toSet(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(ListExtensions.<VerificationPlan, List<Requirement>>map(verificationPlans, _function)), _function_1));
    final Iterable<SystemRequirementSet> targetReqs = this.reqSpecrefFinder.getSystemRequirementSets(targetComponent);
    final Function1<SystemRequirementSet, EList<Requirement>> _function_2 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_3 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, EList<Category>> _function_4 = (Requirement it) -> {
      return it.getCategory();
    };
    final Function1<Category, Boolean> _function_5 = (Category it) -> {
      return Boolean.valueOf(EcoreUtil2.<Categories>getContainerOfType(it, Categories.class).getName().equalsIgnoreCase("exception"));
    };
    final int exceptionReqCount = IterableExtensions.<Category>toSet(IterableExtensions.<Category>filter(Iterables.<Category>concat(IterableExtensions.<Requirement, EList<Category>>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(targetReqs, _function_2)), _function_3), _function_4)), _function_5)).size();
    final Function1<SystemRequirementSet, Iterable<Requirement>> _function_6 = (SystemRequirementSet it) -> {
      final Function1<Requirement, Boolean> _function_7 = (Requirement it_1) -> {
        EObject _exception = it_1.getException();
        return Boolean.valueOf((_exception != null));
      };
      return IterableExtensions.<Requirement>filter(it.getRequirements(), _function_7);
    };
    final Function1<Requirement, Boolean> _function_7 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final int mitigatesReqCount = IterableExtensions.size(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, Iterable<Requirement>>map(targetReqs, _function_6)), _function_7));
    final Function1<SystemRequirementSet, EList<Requirement>> _function_8 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_9 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, NamedElement> _function_10 = (Requirement it) -> {
      return it.getTargetElement();
    };
    final Function1<ClassifierFeature, Boolean> _function_11 = (ClassifierFeature it) -> {
      boolean _switchResult = false;
      boolean _matched = false;
      if (it instanceof BusAccess) {
        _matched=true;
        _switchResult = true;
      }
      if (!_matched) {
        if (it instanceof DataPort) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        if (it instanceof EventDataPort) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        if (it instanceof DataAccess) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        _switchResult = false;
      }
      return Boolean.valueOf(_switchResult);
    };
    final Iterable<ClassifierFeature> featuresRequiringClassifiers = IterableExtensions.<ClassifierFeature>filter(Iterables.<ClassifierFeature>filter(IterableExtensions.<Requirement, NamedElement>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(targetReqs, _function_8)), _function_9), _function_10), ClassifierFeature.class), _function_11);
    final Consumer<ClassifierFeature> _function_12 = (ClassifierFeature it) -> {
      EcoreUtil.resolveAll(it);
    };
    featuresRequiringClassifiers.forEach(_function_12);
    final Function1<ClassifierFeature, Boolean> _function_13 = (ClassifierFeature it) -> {
      boolean _switchResult = false;
      boolean _matched = false;
      if (it instanceof BusAccess) {
        _matched=true;
        BusFeatureClassifier _busFeatureClassifier = ((BusAccess)it).getBusFeatureClassifier();
        _switchResult = (_busFeatureClassifier != null);
      }
      if (!_matched) {
        if (it instanceof DataPort) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((DataPort)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        if (it instanceof EventDataPort) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((EventDataPort)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        if (it instanceof DataAccess) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((DataAccess)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        _switchResult = false;
      }
      return Boolean.valueOf(_switchResult);
    };
    final Iterable<ClassifierFeature> featuresWithRequiredClassifier = IterableExtensions.<ClassifierFeature>filter(featuresRequiringClassifiers, _function_13);
    Metrics _metrics_1 = modelResult.getMetrics();
    _metrics_1.setFeaturesRequiringClassifierCount(IterableExtensions.size(featuresRequiringClassifiers));
    Metrics _metrics_2 = modelResult.getMetrics();
    _metrics_2.setFeaturesWithRequiredClassifierCount(IterableExtensions.size(featuresWithRequiredClassifier));
    Metrics _metrics_3 = modelResult.getMetrics();
    _metrics_3.setTotalQualityCategoryCount(this.getTotalQualityCategoriesCount(modelResult));
    Metrics _metrics_4 = modelResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_14 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_15 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    _metrics_4.setRequirementsCount(IterableExtensions.size(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>toSet(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(targetReqs, _function_14))), _function_15)));
    Metrics _metrics_5 = modelResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_16 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_17 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, Boolean> _function_18 = (Requirement sysReq) -> {
      boolean _contains = claimReqs.contains(sysReq);
      return Boolean.valueOf((!_contains));
    };
    _metrics_5.setRequirementsWithoutPlanClaimCount(IterableExtensions.size(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>toSet(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(targetReqs, _function_16))), _function_17), _function_18)));
    Metrics _metrics_6 = modelResult.getMetrics();
    final Function1<SystemRequirementSet, Iterable<Requirement>> _function_19 = (SystemRequirementSet it) -> {
      final Function1<Requirement, Boolean> _function_20 = (Requirement it_1) -> {
        NamedElement _targetElement = it_1.getTargetElement();
        return Boolean.valueOf((!(_targetElement instanceof Feature)));
      };
      return IterableExtensions.<Requirement>filter(it.getRequirements(), _function_20);
    };
    final Function1<Requirement, Boolean> _function_20 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, EList<Category>> _function_21 = (Requirement it) -> {
      return it.getCategory();
    };
    final Function1<Category, Boolean> _function_22 = (Category it) -> {
      return Boolean.valueOf(EcoreUtil2.<Categories>getContainerOfType(it, Categories.class).getName().equalsIgnoreCase("quality"));
    };
    _metrics_6.setQualityCategoryRequirementsCount(IterableExtensions.<Category>toSet(IterableExtensions.<Category>filter(Iterables.<Category>concat(IterableExtensions.<Requirement, EList<Category>>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, Iterable<Requirement>>map(targetReqs, _function_19)), _function_20), _function_21)), _function_22)).size());
    Metrics _metrics_7 = modelResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_23 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, NamedElement> _function_24 = (Requirement it) -> {
      return it.getTargetElement();
    };
    _metrics_7.setFeaturesRequirementsCount(IterableExtensions.<Feature>toSet(Iterables.<Feature>filter(IterableExtensions.<Requirement, NamedElement>map(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(targetReqs, _function_23)), _function_24), Feature.class)).size());
    Metrics _metrics_8 = modelResult.getMetrics();
    final Function1<VerificationPlan, Boolean> _function_25 = (VerificationPlan vp) -> {
      return Boolean.valueOf(IterableExtensions.isNullOrEmpty(vp.getClaim()));
    };
    _metrics_8.setNoVerificationPlansCount(IterableExtensions.size(IterableExtensions.<VerificationPlan>filter(verificationPlans, _function_25)));
    Metrics _metrics_9 = modelResult.getMetrics();
    _metrics_9.setExceptionsCount((exceptionReqCount + mitigatesReqCount));
    final Consumer<SubsystemResult> _function_26 = (SubsystemResult subsystemResult) -> {
      this.process(subsystemResult);
    };
    modelResult.getSubsystemResult().forEach(_function_26);
  }

  protected void _process(final SubsystemResult caseResult) {
    final Subcomponent targetSystem = caseResult.getTargetSystem();
    final CategoryFilter categoryFilter = this.myFilter;
    Metrics _metrics = caseResult.getMetrics();
    _metrics.setFeaturesCount(targetSystem.getAllFeatures().size());
    final EList<ClaimResult> claimResults = caseResult.getClaimResult();
    final Function1<ClaimResult, VerificationPlan> _function = (ClaimResult it) -> {
      return it.getTargetReference().getVerificationPlan();
    };
    final List<VerificationPlan> verificationPlans = ListExtensions.<ClaimResult, VerificationPlan>map(claimResults, _function);
    final Function1<ClaimResult, EList<Claim>> _function_1 = (ClaimResult it) -> {
      return it.getTargetReference().getVerificationPlan().getClaim();
    };
    final Function1<Claim, Requirement> _function_2 = (Claim it) -> {
      return it.getRequirement();
    };
    final Function1<Requirement, Boolean> _function_3 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Set<Requirement> claimReqs = IterableExtensions.<Requirement>toSet(IterableExtensions.<Requirement>filter(IterableExtensions.<Claim, Requirement>map(Iterables.<Claim>concat(ListExtensions.<ClaimResult, EList<Claim>>map(claimResults, _function_1)), _function_2), _function_3));
    final Iterable<SystemRequirementSet> sysReqs = this.reqSpecrefFinder.getSystemRequirementSets(targetSystem.getComponentType());
    final Function1<SystemRequirementSet, EList<Requirement>> _function_4 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_5 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, EList<Category>> _function_6 = (Requirement it) -> {
      return it.getCategory();
    };
    final Function1<Category, Boolean> _function_7 = (Category it) -> {
      return Boolean.valueOf(EcoreUtil2.<Categories>getContainerOfType(it, Categories.class).getName().equalsIgnoreCase("exception"));
    };
    final int exceptionReqCount = IterableExtensions.<Category>toSet(IterableExtensions.<Category>filter(Iterables.<Category>concat(IterableExtensions.<Requirement, EList<Category>>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(sysReqs, _function_4)), _function_5), _function_6)), _function_7)).size();
    final Function1<SystemRequirementSet, Iterable<Requirement>> _function_8 = (SystemRequirementSet it) -> {
      final Function1<Requirement, Boolean> _function_9 = (Requirement it_1) -> {
        EObject _exception = it_1.getException();
        return Boolean.valueOf((_exception != null));
      };
      return IterableExtensions.<Requirement>filter(it.getRequirements(), _function_9);
    };
    final Function1<Requirement, Boolean> _function_9 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final int mitigatesReqCount = IterableExtensions.size(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, Iterable<Requirement>>map(sysReqs, _function_8)), _function_9));
    final Function1<SystemRequirementSet, EList<Requirement>> _function_10 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_11 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, NamedElement> _function_12 = (Requirement it) -> {
      return it.getTargetElement();
    };
    final Function1<ClassifierFeature, Boolean> _function_13 = (ClassifierFeature it) -> {
      boolean _switchResult = false;
      boolean _matched = false;
      if (it instanceof BusAccess) {
        _matched=true;
        _switchResult = true;
      }
      if (!_matched) {
        if (it instanceof DataPort) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        if (it instanceof EventDataPort) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        if (it instanceof DataAccess) {
          _matched=true;
          _switchResult = true;
        }
      }
      if (!_matched) {
        _switchResult = false;
      }
      return Boolean.valueOf(_switchResult);
    };
    final Iterable<ClassifierFeature> featuresRequiringClassifiers = IterableExtensions.<ClassifierFeature>filter(Iterables.<ClassifierFeature>filter(IterableExtensions.<Requirement, NamedElement>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(sysReqs, _function_10)), _function_11), _function_12), ClassifierFeature.class), _function_13);
    final Consumer<ClassifierFeature> _function_14 = (ClassifierFeature it) -> {
      EcoreUtil.resolveAll(it);
    };
    featuresRequiringClassifiers.forEach(_function_14);
    final Function1<ClassifierFeature, Boolean> _function_15 = (ClassifierFeature it) -> {
      boolean _switchResult = false;
      boolean _matched = false;
      if (it instanceof BusAccess) {
        _matched=true;
        BusFeatureClassifier _busFeatureClassifier = ((BusAccess)it).getBusFeatureClassifier();
        _switchResult = (_busFeatureClassifier != null);
      }
      if (!_matched) {
        if (it instanceof DataPort) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((DataPort)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        if (it instanceof EventDataPort) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((EventDataPort)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        if (it instanceof DataAccess) {
          _matched=true;
          DataSubcomponentType _dataFeatureClassifier = ((DataAccess)it).getDataFeatureClassifier();
          _switchResult = (_dataFeatureClassifier != null);
        }
      }
      if (!_matched) {
        _switchResult = false;
      }
      return Boolean.valueOf(_switchResult);
    };
    final Iterable<ClassifierFeature> featuresWithRequiredClassifier = IterableExtensions.<ClassifierFeature>filter(featuresRequiringClassifiers, _function_15);
    Metrics _metrics_1 = caseResult.getMetrics();
    _metrics_1.setFeaturesRequiringClassifierCount(IterableExtensions.size(featuresRequiringClassifiers));
    Metrics _metrics_2 = caseResult.getMetrics();
    _metrics_2.setFeaturesWithRequiredClassifierCount(IterableExtensions.size(featuresWithRequiredClassifier));
    Metrics _metrics_3 = caseResult.getMetrics();
    _metrics_3.setTotalQualityCategoryCount(this.getTotalQualityCategoriesCount(caseResult));
    Metrics _metrics_4 = caseResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_16 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_17 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    _metrics_4.setRequirementsCount(IterableExtensions.size(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>toSet(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(sysReqs, _function_16))), _function_17)));
    Metrics _metrics_5 = caseResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_18 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_19 = (Requirement sysReq) -> {
      boolean _contains = claimReqs.contains(sysReq);
      return Boolean.valueOf((!_contains));
    };
    final Function1<Requirement, Boolean> _function_20 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    _metrics_5.setRequirementsWithoutPlanClaimCount(IterableExtensions.size(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>filter(IterableExtensions.<Requirement>toSet(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(sysReqs, _function_18))), _function_19), _function_20)));
    Metrics _metrics_6 = caseResult.getMetrics();
    final Function1<SystemRequirementSet, Iterable<Requirement>> _function_21 = (SystemRequirementSet it) -> {
      final Function1<Requirement, Boolean> _function_22 = (Requirement it_1) -> {
        NamedElement _targetElement = it_1.getTargetElement();
        return Boolean.valueOf((!(_targetElement instanceof ClassifierFeature)));
      };
      return IterableExtensions.<Requirement>filter(it.getRequirements(), _function_22);
    };
    final Function1<Requirement, Boolean> _function_22 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, EList<Category>> _function_23 = (Requirement it) -> {
      return it.getCategory();
    };
    _metrics_6.setQualityCategoryRequirementsCount(IterableExtensions.<Category>toSet(Iterables.<Category>concat(IterableExtensions.<Requirement, EList<Category>>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, Iterable<Requirement>>map(sysReqs, _function_21)), _function_22), _function_23))).size());
    Metrics _metrics_7 = caseResult.getMetrics();
    final Function1<SystemRequirementSet, EList<Requirement>> _function_24 = (SystemRequirementSet it) -> {
      return it.getRequirements();
    };
    final Function1<Requirement, Boolean> _function_25 = (Requirement it) -> {
      return Boolean.valueOf(this.filterRequirement(it, categoryFilter));
    };
    final Function1<Requirement, NamedElement> _function_26 = (Requirement it) -> {
      return it.getTargetElement();
    };
    _metrics_7.setFeaturesRequirementsCount(IterableExtensions.<ClassifierFeature>toSet(Iterables.<ClassifierFeature>filter(IterableExtensions.<Requirement, NamedElement>map(IterableExtensions.<Requirement>filter(Iterables.<Requirement>concat(IterableExtensions.<SystemRequirementSet, EList<Requirement>>map(sysReqs, _function_24)), _function_25), _function_26), ClassifierFeature.class)).size());
    Metrics _metrics_8 = caseResult.getMetrics();
    final Function1<VerificationPlan, Boolean> _function_27 = (VerificationPlan vp) -> {
      return Boolean.valueOf(IterableExtensions.isNullOrEmpty(vp.getClaim()));
    };
    _metrics_8.setNoVerificationPlansCount(IterableExtensions.size(IterableExtensions.<VerificationPlan>filter(verificationPlans, _function_27)));
    Metrics _metrics_9 = caseResult.getMetrics();
    _metrics_9.setExceptionsCount((exceptionReqCount + mitigatesReqCount));
    final Consumer<SubsystemResult> _function_28 = (SubsystemResult subcaseResult) -> {
      this.process(subcaseResult);
    };
    caseResult.getSubsystemResult().forEach(_function_28);
  }

  public boolean filterRequirement(final Requirement requirement, final CategoryFilter filter) {
    boolean _xifexpression = false;
    if ((filter != null)) {
      boolean _xifexpression_1 = false;
      boolean _isAnyCategory = filter.isAnyCategory();
      if (_isAnyCategory) {
        boolean _disjoint = Collections.disjoint(requirement.getCategory(), filter.getCategory());
        _xifexpression_1 = (!_disjoint);
      } else {
        _xifexpression_1 = requirement.getCategory().containsAll(filter.getCategory());
      }
      _xifexpression = _xifexpression_1;
    } else {
      _xifexpression = true;
    }
    return _xifexpression;
  }

  public void process(final AssureResult caseResult) {
    if (caseResult instanceof AssuranceCaseResult) {
      _process((AssuranceCaseResult)caseResult);
      return;
    } else if (caseResult instanceof ModelResult) {
      _process((ModelResult)caseResult);
      return;
    } else if (caseResult instanceof SubsystemResult) {
      _process((SubsystemResult)caseResult);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(caseResult).toString());
    }
  }
}