Return OE in the list that are fulfilled the indicated decision.

@param oes
@param decision
@return
540071
private List<ObligationExpression> getFulfilledObligationExpressions(
            List<ObligationExpression> oes,
            DecisionType decision) {

        List<ObligationExpression> fulfilledOEs = new ArrayList<ObligationExpression>();

        if (oes != null && oes.size() > 0) {
            for (ObligationExpression oe : oes) {
                if (oe.isFulfilled(decision)) {
                    fulfilledOEs.add(oe);
                }
            }
        }
        return fulfilledOEs;
    }
105680
public boolean equalsTo(Object o)
    {
        if(o == null || !(o instanceof Reference))
        {
            return false;
        }
        
        Reference refCompared = (Reference)o;
        if(!StringUtil.isEquals(sections, refCompared.sections)) return false;
        if(systemUnderTest == null || !systemUnderTest.equalsTo(refCompared.systemUnderTest)) return false;
        if(requirement == null || !requirement.equalsTo(refCompared.requirement)) return false;
        if(specification == null || !specification.equalsTo(refCompared.specification)) return false;
        
        return true;
    }
88998
public static OClass getDeepestOClass(Iterable<OClass> classes) {
		if(classes==null) return null;
		OClass ret=null;
		for(OClass oClass: classes) {
			if(ret==null) ret = oClass;
			else {
				if(!ret.equals(oClass) && oClass.isSubClassOf(ret)) ret = oClass;
			}
		}
		return ret;
	}
423381
private void getMatchingEECerts(ForwardState currentState,
                                    List<CertStore> certStores,
                                    Collection<X509Certificate> eeCerts)
        throws IOException
    {
        if (debug != null) {
            debug.println("ForwardBuilder.getMatchingEECerts()...");
        }
        /*
         * Compose a certificate matching rule to filter out
         * certs which don't satisfy constraints
         *
         * First, retrieve clone of current target cert constraints,
         * and then add more selection criteria based on current validation
         * state. Since selector never changes, cache local copy & reuse.
         */
        if (eeSelector == null) {
            eeSelector = (X509CertSelector) targetCertConstraints.clone();

            /*
             * Match on certificate validity date
             */
            eeSelector.setCertificateValid(buildParams.date());

            /*
             * Policy processing optimizations
             */
            if (buildParams.explicitPolicyRequired()) {
                eeSelector.setPolicy(getMatchingPolicies());
            }
            /*
             * Require EE certs
             */
            eeSelector.setBasicConstraints(-2);
        }

        /* Retrieve matching EE certs from CertStores */
        addMatchingCerts(eeSelector, certStores, eeCerts, searchAllCertStores);
    }
3349
private String getStatusCode(DecisionType decision) {
        if (fXACMLParsingError) {
            return STATUS_CODE_SYNTAX_ERROR;
        } else if (fProcessingError) {
            return STATUS_CODE_PROCESSING_ERROR;
        } else if (decision == DecisionType.Deny ||
                decision == DecisionType.Permit) {
            return STATUS_CODE_OK;
        } else if (decision == DecisionType.Indeterminate ||
                decision == DecisionType.Indeterminate_D ||
                decision == DecisionType.Indeterminate_P ||
                decision == DecisionType.Indeterminate_DP) {
            return STATUS_CODE_MISSING_ATTRIBUTE;
        } else {
            logger.debug("Unknown status code decision");
            return STATUS_CODE_PROCESSING_ERROR;
        }
    }
1121021
public static MOAObject fromOption(ClassOption option) {
  	return MOAUtils.fromCommandLine(option.getRequiredType(), option.getValueAsCLIString());
  }
809016
public List<Decision<Flow<T>>> getAllDecision()
   {
      List<Decision<Flow<T>>> list = new ArrayList<Decision<Flow<T>>>();
      List<Node> nodeList = childNode.get("decision");
      for(Node node: nodeList)
      {
         Decision<Flow<T>>  type = new DecisionImpl<Flow<T>>(this, "decision", childNode, node);
         list.add(type);
      }
      return list;
   }
224600
public java.util.List<String> getOperations() {
        if (operations == null) {
            operations = new com.ibm.cloud.objectstorage.internal.SdkInternalList<String>();
        }
        return operations;
    }
895104
public List<Object> getOptional(Object locator) {
		try {
			return find(Object.class, locator, false);
		} catch (Exception ex) {
			return new ArrayList<Object>();
		}
	}
834898
public static AGeneralOperation getOperation(OperationType operationType){
		switch(operationType){
			case BASIC_INSTRUCTION:			   return new BasicOperation();			
			case BASIC_CONVERSION:             return new BasicConversion();			
			case OBJECT:					   return new ObjectOperation();			
			case ARRAY: 					   return new ArrayOperation();			
			case ARRAY_LIST:				   return new ArrayListOperation();		
			case LIST_ARRAY:			       return new ListArrayOperation();		
			case ARRAY_WITH_MAPPED_ITEMS:	   return new MappedArrayOperation();		
			case ARRAY_LIST_WITH_MAPPED_ITEMS: return new MappedArrayListOperation();	
			case LIST_ARRAY_WITH_MAPPED_ITEMS: return new MappedListArrayOperation();	
			case COLLECTION: 				   return new CollectionOperation();		
			case COLLECTION_WITH_MAPPED_ITEMS: return new MappedCollectionOperation();	
			case MAP:	     				   return new MapOperation();				
			case MAP_WITH_MAPPED_ITEMS: 	   return new MappedMapOperation();		
			case CONVERSION: 				   return new ConversionOperation();
			case DATE_CALENDAR:				   return new DateCalendarOperation();
			case STRING_ENUM: 				   return new StringEnumOperation();
			case STRING_STRINGBUFFER:		   return new StringStringBufferOperation();
			case STRING_STRINGBUILDER:		   return new StringStringBuilderOperation();
			case CALENDAR_DATE:				   return new CalendarDateOperation();
			case ENUM_STRING:				   return new EnumStringOperation();
			case STRINGBUILDER_STRING:         return new StringBuilderStringOperation();
			case STRINGBUFFER_STRING:		   return new StringBufferStringOperation();
			case ENUM_ENUM: 				   return new EnumEnumOperation();
			default: return null;
		}
		
	}
649200
public DmnDecisionResult evaluateDecision(DmnDecision decision, VariableContext variableContext) {

    if(decision.getKey() == null) {
      throw LOG.unableToFindAnyDecisionTable();
    }
    VariableMap variableMap = buildVariableMapFromVariableContext(variableContext);

    List<DmnDecision> requiredDecisions = new ArrayList<DmnDecision>();
    buildDecisionTree(decision, requiredDecisions);

    List<DmnDecisionLogicEvaluationEvent> evaluatedEvents = new ArrayList<DmnDecisionLogicEvaluationEvent>();
    DmnDecisionResult evaluatedResult = null;

    for (DmnDecision evaluateDecision : requiredDecisions) {
      DmnDecisionLogicEvaluationHandler handler = getDecisionEvaluationHandler(evaluateDecision);
      DmnDecisionLogicEvaluationEvent evaluatedEvent = handler.evaluate(evaluateDecision, variableMap.asVariableContext());
      evaluatedEvents.add(evaluatedEvent);

      evaluatedResult = handler.generateDecisionResult(evaluatedEvent);
      if(decision != evaluateDecision) {
        addResultToVariableContext(evaluatedResult, variableMap, evaluateDecision);
      }
    }

    generateDecisionEvaluationEvent(evaluatedEvents);
    return evaluatedResult;
  }
785776
def get_decider_result(rule, original_subtarget, record)
        # must test first
        decider = rule.decider
        case decider.arity
        when 0
          if rule.decider_type == :if
            return decider.() ? BALI_TRUE : BALI_FALSE
          elsif rule.decider_type == :unless
            unless decider.()
              return BALI_TRUE
            else
              return BALI_FALSE
            end
          end
        when 1
          if rule.decider_type == :if
            return decider.(record) ? BALI_TRUE : BALI_FALSE
          elsif rule.decider_type == :unless
            unless decider.(record)
              return BALI_TRUE
            else
              return BALI_FALSE
            end
          end
        when 2
          if rule.decider_type == :if
            return decider.(record, original_subtarget) ? BALI_TRUE : BALI_FALSE
          elsif rule.decider_type == :unless
            unless decider.(record, original_subtarget)
              return BALI_TRUE
            else
              return BALI_FALSE
            end
          end
        end
      end
64518
private boolean checkIfActiveOidExisting(String oid) {
        try {
            JPAObject obj = dao.getJPAObject(oid);
            if (!obj.isDeleted()) {
                return true;
            }
        } catch (EDBException e) {
            // nothing to do here
        }
        return false;
    }
816023
public static boolean equalsAny(final Object o1, final Object... o2s) {
        if (o2s != null) {
            for (final Object o2 : o2s) {
                if (o1 == null) {
                    if (o2 == null) {
                        return true;
                    }
                    continue;
                }
                // o1 != null
                if (o1.equals(o2)) {
                    return true;
                }
            }
        } else {
            return o1 == null;
        }
        return false;
    }
1135707
public java.util.List<String> getOperations() {
        if (operations == null) {
            operations = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return operations;
    }
1139280
public <K, V> Reflecter<T> keyValLoop(final Decision<Triple<K, Field, V>> decision) {
		fieldLoop(new Decisional<Field>() {

			@SuppressWarnings("unchecked") @Override protected void decision(Field input) {
				decision.apply((Triple<K, Field, V>) Triple.of(input.getName(), input, getPropVal(input, input.getName())));
			}
		});
		return this;
	}
1158358
public static Object toGUId(Object o, Object defaultValue) {
	String str = toString(o, null);
	if (str == null) return defaultValue;

	if (!Decision.isGUId(str)) return defaultValue;
	return str;
    }