protected ISchedulingRule computeCommitRule(IFileBuffer[] fileBuffers) { ArrayList list= new ArrayList(); for (int i= 0; i < fileBuffers.length; i++) { ISchedulingRule rule= fileBuffers[i].computeCommitRule(); if (rule != null) list.add(rule); } ISchedulingRule[] rules= new ISchedulingRule[list.size()]; list.toArray(rules); return new MultiRule(rules); }
/** * Returns a scheduling rule that encompasses all provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If all * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param ruleArray An array of scheduling rules, some of which may be <code>null</code> * @return a combined scheduling rule, or <code>null</code> * @since 3.1 */ public static ISchedulingRule combine(ISchedulingRule[] ruleArray) { ISchedulingRule result = null; for (int i = 0; i < ruleArray.length; i++) { if (ruleArray[i] == null) continue; if (result == null) { result = ruleArray[i]; continue; } result = combine(result, ruleArray[i]); } return result; }
private static ISchedulingRule[] flatten(ISchedulingRule[] nestedRules) { ArrayList myRules = new ArrayList(nestedRules.length); for (int i = 0; i < nestedRules.length; i++) { if (nestedRules[i] instanceof MultiRule) { ISchedulingRule[] children = ((MultiRule) nestedRules[i]).getChildren(); for (int j = 0; j < children.length; j++) myRules.add(children[j]); } else { myRules.add(nestedRules[i]); } } return (ISchedulingRule[]) myRules.toArray(new ISchedulingRule[myRules.size()]); }
/** * Returns a scheduling rule that encompasses both provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If both * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param rule1 a scheduling rule, or <code>null</code> * @param rule2 another scheduling rule, or <code>null</code> * @return a combined scheduling rule, or <code>null</code> */ public static ISchedulingRule combine(ISchedulingRule rule1, ISchedulingRule rule2) { if (rule1 == rule2) return rule1; if (rule1 == null) return rule2; if (rule2 == null) return rule1; if (rule1.contains(rule2)) return rule1; if (rule2.contains(rule1)) return rule2; MultiRule result = new MultiRule(); result.rules = new ISchedulingRule[] {rule1, rule2}; //make sure we don't end up with nested multi-rules if (rule1 instanceof MultiRule || rule2 instanceof MultiRule) result.rules = flatten(result.rules); return result; }
ISchedulingRule[] rules = ((MultiRule)resourceRule).getChildren(); Set<ISchedulingRule> projects = new HashSet<>(); for (int i = 0; i < rules.length; i++) { rule = projects.iterator().next(); } else { rule = new MultiRule(projects.toArray(new ISchedulingRule[projects.size()]));
/** * Creates a new scheduling rule that composes a set of nested rules. * * @param nestedRules the nested rules for this compound rule. */ public MultiRule(ISchedulingRule[] nestedRules) { this.rules = flatten(nestedRules); }
/** * Returns a scheduling rule that encompasses both provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If both * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param rule1 a scheduling rule, or <code>null</code> * @param rule2 another scheduling rule, or <code>null</code> * @return a combined scheduling rule, or <code>null</code> */ public static ISchedulingRule combine(ISchedulingRule rule1, ISchedulingRule rule2) { if (rule1 == rule2) return rule1; if (rule1 == null) return rule2; if (rule2 == null) return rule1; if (rule1.contains(rule2)) return rule1; if (rule2.contains(rule1)) return rule2; MultiRule result = new MultiRule(); result.rules = new ISchedulingRule[] {rule1, rule2}; //make sure we don't end up with nested multi-rules if (rule1 instanceof MultiRule || rule2 instanceof MultiRule) result.rules = flatten(result.rules); return result; }
/** * Creates a new scheduling rule that composes a set of nested rules. * * @param nestedRules the nested rules for this compound rule. */ public MultiRule(ISchedulingRule[] nestedRules) { this.rules = flatten(nestedRules); }
protected ISchedulingRule computeCommitRule(IFileBuffer[] fileBuffers) { ArrayList<ISchedulingRule> list= new ArrayList<>(); for (IFileBuffer fileBuffer : fileBuffers) { ISchedulingRule rule= fileBuffer.computeCommitRule(); if (rule != null) list.add(rule); } ISchedulingRule[] rules= new ISchedulingRule[list.size()]; list.toArray(rules); return new MultiRule(rules); }
/** * Returns a scheduling rule that encompasses all provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If all * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param ruleArray An array of scheduling rules, some of which may be <code>null</code> * @return a combined scheduling rule, or <code>null</code> * @since 3.1 */ public static ISchedulingRule combine(ISchedulingRule[] ruleArray) { ISchedulingRule result = null; for (int i = 0; i < ruleArray.length; i++) { if (ruleArray[i] == null) continue; if (result == null) { result = ruleArray[i]; continue; } result = combine(result, ruleArray[i]); } return result; }
/** * Returns a scheduling rule that encompasses both provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If both * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param rule1 a scheduling rule, or <code>null</code> * @param rule2 another scheduling rule, or <code>null</code> * @return a combined scheduling rule, or <code>null</code> */ public static ISchedulingRule combine(ISchedulingRule rule1, ISchedulingRule rule2) { if (rule1 == rule2) return rule1; if (rule1 == null) return rule2; if (rule2 == null) return rule1; if (rule1.contains(rule2)) return rule1; if (rule2.contains(rule1)) return rule2; MultiRule result = new MultiRule(); result.rules = new ISchedulingRule[] {rule1, rule2}; //make sure we don't end up with nested multi-rules if (rule1 instanceof MultiRule || rule2 instanceof MultiRule) result.rules = flatten(result.rules); return result; }
private static ISchedulingRule[] flatten(ISchedulingRule[] nestedRules) { ArrayList<ISchedulingRule> myRules = new ArrayList<>(nestedRules.length); for (int i = 0; i < nestedRules.length; i++) { if (nestedRules[i] instanceof MultiRule) { ISchedulingRule[] children = ((MultiRule) nestedRules[i]).getChildren(); for (int j = 0; j < children.length; j++) myRules.add(children[j]); } else { myRules.add(nestedRules[i]); } } return myRules.toArray(new ISchedulingRule[myRules.size()]); }
/** * Creates a new scheduling rule that composes a set of nested rules. * * @param nestedRules the nested rules for this compound rule. */ public MultiRule(ISchedulingRule[] nestedRules) { this.rules = flatten(nestedRules); }
@Override public ISchedulingRule getRule() { ISchedulingRule rule1 = op1.getRule(); ISchedulingRule rule2 = op2.getRule(); if (rule1 == null) { return rule2; } if (rule2 == null) { return rule1; } return new MultiRule(new ISchedulingRule[]{ rule1, rule2 }); } };
/** * Returns a scheduling rule that encompasses all provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If all * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param ruleArray An array of scheduling rules, some of which may be <code>null</code> * @return a combined scheduling rule, or <code>null</code> * @since 3.1 */ public static ISchedulingRule combine(ISchedulingRule[] ruleArray) { ISchedulingRule result = null; for (int i = 0; i < ruleArray.length; i++) { if (ruleArray[i] == null) continue; if (result == null) { result = ruleArray[i]; continue; } result = combine(result, ruleArray[i]); } return result; }
/** * Returns a scheduling rule that encompasses both provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If both * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param rule1 a scheduling rule, or <code>null</code> * @param rule2 another scheduling rule, or <code>null</code> * @return a combined scheduling rule, or <code>null</code> */ public static ISchedulingRule combine(ISchedulingRule rule1, ISchedulingRule rule2) { if (rule1 == rule2) return rule1; if (rule1 == null) return rule2; if (rule2 == null) return rule1; if (rule1.contains(rule2)) return rule1; if (rule2.contains(rule1)) return rule2; MultiRule result = new MultiRule(); result.rules = new ISchedulingRule[] {rule1, rule2}; //make sure we don't end up with nested multi-rules if (rule1 instanceof MultiRule || rule2 instanceof MultiRule) result.rules = flatten(result.rules); return result; }
private static ISchedulingRule[] flatten(ISchedulingRule[] nestedRules) { ArrayList<ISchedulingRule> myRules = new ArrayList<ISchedulingRule>(nestedRules.length); for (int i = 0; i < nestedRules.length; i++) { if (nestedRules[i] instanceof MultiRule) { ISchedulingRule[] children = ((MultiRule) nestedRules[i]).getChildren(); for (int j = 0; j < children.length; j++) myRules.add(children[j]); } else { myRules.add(nestedRules[i]); } } return myRules.toArray(new ISchedulingRule[myRules.size()]); }
/** * Creates a new scheduling rule that composes a set of nested rules. * * @param nestedRules the nested rules for this compound rule. */ public MultiRule(ISchedulingRule[] nestedRules) { this.rules = flatten(nestedRules); }
protected ISchedulingRule getSchedulingRule() { if (this.elementsToProcess == null) return null; int length = this.elementsToProcess.length; if (length == 1) return getSchedulingRule(this.elementsToProcess[0]); ISchedulingRule[] rules = new ISchedulingRule[length]; int index = 0; for (int i = 0; i < length; i++) { ISchedulingRule rule = getSchedulingRule(this.elementsToProcess[i]); if (rule != null) { rules[index++] = rule; } } if (index != length) System.arraycopy(rules, 0, rules = new ISchedulingRule[index], 0, index); return new MultiRule(rules); } private ISchedulingRule getSchedulingRule(IJavaElement element) {
/** * Returns a scheduling rule that encompasses all provided rules. The resulting * rule may or may not be an instance of <code>MultiRule</code>. If all * provided rules are <code>null</code> then the result will be * <code>null</code>. * * @param ruleArray An array of scheduling rules, some of which may be <code>null</code> * @return a combined scheduling rule, or <code>null</code> * @since 3.1 */ public static ISchedulingRule combine(ISchedulingRule[] ruleArray) { ISchedulingRule result = null; for (int i = 0; i < ruleArray.length; i++) { if (ruleArray[i] == null) continue; if (result == null) { result = ruleArray[i]; continue; } result = combine(result, ruleArray[i]); } return result; }