Returns a newly created {@link DnsTextEndpointGroup}.
491415
public DnsTextEndpointGroup build() {
        return new DnsTextEndpointGroup(eventLoop(), minTtl(), maxTtl(),
                                        serverAddressStreamProvider(),
                                        backoff(), hostname(), mapping);
    }
195842
@Pure
	public Iterable<PointGroup> groups() {
		return new Iterable<PointGroup>() {
			@Override
			public Iterator<PointGroup> iterator() {
				return MapComposedElement.this.groupIterator();
			}
		};
	}
973388
public DefaultExpander getDslExpander() {
        DefaultExpander expander = new DefaultExpander();
        if (this.dslFiles == null || this.dslFiles.isEmpty()) {
            return null;
        }
        for (DSLMappingFile file : this.dslFiles) {
            expander.addDSLMapping(file.getMapping());
        }
        return expander;
    }
392214
public static IEntityGroup newGroup(Class<?> type) throws GroupsException {
        LOGGER.trace("Invoking newGroup for type='{}'", type);
        return instance().inewGroup(type);
    }
1163473
@Pure
	public PointGroup getGroupAt(int index) {
		final int count = getGroupCount();
		if (index < 0) {
			throw new IndexOutOfBoundsException(index + "<0"); //$NON-NLS-1$
		}
		if (index >= count) {
			throw new IndexOutOfBoundsException(index + ">=" + count); //$NON-NLS-1$
		}
		return new PointGroup(index);
	}
540172
public Identifier extractPartAfterLastDot() {
    String part = BaseUtils.extractPartAfterLastDot(identifier());
    return Identifier.create(
        part, location().offsetStartCol(identifier().length() - part.length()));
  }
1046874
public Exclude<ExceptionClassFilter<T>> getOrCreateExclude()
   {
      List<Node> nodeList = childNode.get("exclude");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ExcludeImpl<ExceptionClassFilter<T>>(this, "exclude", childNode, nodeList.get(0));
      }
      return createExclude();
   }
368650
File getNextDataDir() {
    File latest = getLatestDataDir();
    long newID;
    if (latest == null) {
      newID = 0;
    } else {
      newID = Long.parseLong(latest.getName().substring(4)) + 1;
    }
    String suffix = String.format("%015d", newID);
    return new File(this.rootDir, "data" + suffix);
  }
332992
@Indexable(type = IndexableType.REINDEX)
	@Override
	public CPDefinitionGroupedEntry addCPDefinitionGroupedEntry(
		CPDefinitionGroupedEntry cpDefinitionGroupedEntry) {
		cpDefinitionGroupedEntry.setNew(true);

		return cpDefinitionGroupedEntryPersistence.update(cpDefinitionGroupedEntry);
	}
555132
protected void createExtendedMetaDataAnnotations() {
		String source = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";		
		addAnnotation
		  (betaDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BetaDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBetaDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getBetaDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });		
		addAnnotation
		  (binomialDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BinomialDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBinomialDistributionType_Probability(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "probability"
		   });		
		addAnnotation
		  (getBinomialDistributionType_Trials(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "trials"
		   });		
		addAnnotation
		  (booleanParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BooleanParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getBooleanParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (bpSimDataTypeEClass, 
		   source, 
		   new String[] {
			 "name", "BPSimData_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getBPSimDataType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:0"
		   });		
		addAnnotation
		  (getBPSimDataType_Scenario(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Scenario",
			 "namespace", "##targetNamespace",
			 "group", "#group:0"
		   });		
		addAnnotation
		  (calendarEClass, 
		   source, 
		   new String[] {
			 "name", "Calendar",
			 "kind", "simple"
		   });		
		addAnnotation
		  (getCalendar_Value(), 
		   source, 
		   new String[] {
			 "name", ":0",
			 "kind", "simple"
		   });		
		addAnnotation
		  (getCalendar_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (getCalendar_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (constantParameterEClass, 
		   source, 
		   new String[] {
			 "name", "ConstantParameter",
			 "kind", "empty"
		   });		
		addAnnotation
		  (controlParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ControlParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getControlParameters_Probability(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Probability",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_Condition(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Condition",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_InterTriggerTimer(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "InterTriggerTimer",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getControlParameters_TriggerCount(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TriggerCount",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (costParametersEClass, 
		   source, 
		   new String[] {
			 "name", "CostParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getCostParameters_FixedCost(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "FixedCost",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getCostParameters_UnitCost(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UnitCost",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (dateTimeParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "DateTimeParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDateTimeParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (distributionParameterEClass, 
		   source, 
		   new String[] {
			 "name", "DistributionParameter",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDistributionParameter_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getDistributionParameter_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (documentRootEClass, 
		   source, 
		   new String[] {
			 "name", "",
			 "kind", "mixed"
		   });		
		addAnnotation
		  (getDocumentRoot_Mixed(), 
		   source, 
		   new String[] {
			 "kind", "elementWildcard",
			 "name", ":mixed"
		   });		
		addAnnotation
		  (getDocumentRoot_XMLNSPrefixMap(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "xmlns:prefix"
		   });		
		addAnnotation
		  (getDocumentRoot_XSISchemaLocation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "xsi:schemaLocation"
		   });		
		addAnnotation
		  (getDocumentRoot_BetaDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BetaDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_BinomialDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BinomialDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_BooleanParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BooleanParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_BPSimData(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "BPSimData",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_DateTimeParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "DateTimeParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_DurationParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "DurationParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_EnumParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "EnumParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ErlangDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ErlangDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_ExpressionParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ExpressionParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_FloatingParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "FloatingParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_GammaDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "GammaDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_LogNormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "LogNormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NegativeExponentialDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NegativeExponentialDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_NumericParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "NumericParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_PoissonDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PoissonDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_StringParameter(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "StringParameter",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_TriangularDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TriangularDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_TruncatedNormalDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TruncatedNormalDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UniformDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UniformDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UserDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (getDocumentRoot_UserDistributionDataPoint(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistributionDataPoint",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getDocumentRoot_WeibullDistribution(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "WeibullDistribution",
			 "namespace", "##targetNamespace",
			 "affiliation", "ParameterValue"
		   });		
		addAnnotation
		  (durationParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "DurationParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getDurationParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (elementParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ElementParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getElementParameters_TimeParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TimeParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ControlParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ControlParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ResourceParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ResourceParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_PriorityParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PriorityParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_CostParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "CostParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_PropertyParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PropertyParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_VendorExtension(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "VendorExtension",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getElementParameters_ElementRef(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "elementRef"
		   });		
		addAnnotation
		  (getElementParameters_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (elementParametersTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ElementParametersType",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (enumParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "EnumParameter_._type",
			 "kind", "elementOnly"
		   });			
		addAnnotation
		  (getEnumParameterType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:3"
		   });		
		addAnnotation
		  (getEnumParameterType_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace",
			 "group", "#group:3"
		   });		
		addAnnotation
		  (getEnumParameterType_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (erlangDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ErlangDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getErlangDistributionType_K(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "k"
		   });		
		addAnnotation
		  (getErlangDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (expressionParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ExpressionParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getExpressionParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (floatingParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "FloatingParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getFloatingParameterType_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getFloatingParameterType_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (getFloatingParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (gammaDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "GammaDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getGammaDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getGammaDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });		
		addAnnotation
		  (logNormalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "LogNormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getLogNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getLogNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (negativeExponentialDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NegativeExponentialDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNegativeExponentialDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (normalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (numericParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "NumericParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getNumericParameterType_CurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "currencyUnit"
		   });		
		addAnnotation
		  (getNumericParameterType_TimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "timeUnit"
		   });		
		addAnnotation
		  (getNumericParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (parameterEClass, 
		   source, 
		   new String[] {
			 "name", "Parameter",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getParameter_ResultRequest(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ResultRequest",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getParameter_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getParameter_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (getParameter_Kpi(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "kpi"
		   });		
		addAnnotation
		  (getParameter_Sla(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "sla"
		   });		
		addAnnotation
		  (parameterValueEClass, 
		   source, 
		   new String[] {
			 "name", "ParameterValue",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getParameterValue_Instance(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "instance"
		   });		
		addAnnotation
		  (getParameterValue_Result(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "result"
		   });		
		addAnnotation
		  (getParameterValue_ValidFor(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "validFor"
		   });		
		addAnnotation
		  (poissonDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "PoissonDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getPoissonDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (priorityParametersEClass, 
		   source, 
		   new String[] {
			 "name", "PriorityParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPriorityParameters_Interruptible(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Interruptible",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getPriorityParameters_Priority(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Priority",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (propertyParametersEClass, 
		   source, 
		   new String[] {
			 "name", "PropertyParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPropertyParameters_Property(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Property",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (propertyTypeEClass, 
		   source, 
		   new String[] {
			 "name", "Property_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getPropertyType_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (resourceParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ResourceParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getResourceParameters_Selection(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Selection",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Availability(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Availability",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Quantity(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Quantity",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getResourceParameters_Role(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Role",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (resultTypeEEnum, 
		   source, 
		   new String[] {
			 "name", "ResultType"
		   });		
		addAnnotation
		  (resultTypeObjectEDataType, 
		   source, 
		   new String[] {
			 "name", "ResultType:Object",
			 "baseType", "ResultType"
		   });		
		addAnnotation
		  (scenarioEClass, 
		   source, 
		   new String[] {
			 "name", "Scenario",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getScenario_ScenarioParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ScenarioParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_ElementParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ElementParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_Calendar(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Calendar",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_VendorExtension(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "VendorExtension",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenario_Author(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "author"
		   });		
		addAnnotation
		  (getScenario_Created(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "created"
		   });		
		addAnnotation
		  (getScenario_Description(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "description"
		   });		
		addAnnotation
		  (getScenario_Id(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "id"
		   });		
		addAnnotation
		  (getScenario_Inherits(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "inherits"
		   });		
		addAnnotation
		  (getScenario_Modified(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "modified"
		   });		
		addAnnotation
		  (getScenario_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (getScenario_Result(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "result"
		   });		
		addAnnotation
		  (getScenario_Vendor(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "vendor"
		   });		
		addAnnotation
		  (getScenario_Version(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "version"
		   });		
		addAnnotation
		  (scenarioParametersEClass, 
		   source, 
		   new String[] {
			 "name", "ScenarioParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getScenarioParameters_Start(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Start",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_Duration(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "Duration",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_PropertyParameters(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "PropertyParameters",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getScenarioParameters_BaseCurrencyUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "baseCurrencyUnit"
		   });		
		addAnnotation
		  (getScenarioParameters_BaseTimeUnit(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "baseTimeUnit"
		   });		
		addAnnotation
		  (getScenarioParameters_Replication(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "replication"
		   });		
		addAnnotation
		  (getScenarioParameters_Seed(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "seed"
		   });		
		addAnnotation
		  (scenarioParametersTypeEClass, 
		   source, 
		   new String[] {
			 "name", "ScenarioParameters_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (stringParameterTypeEClass, 
		   source, 
		   new String[] {
			 "name", "StringParameter_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getStringParameterType_Value(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "value"
		   });		
		addAnnotation
		  (timeParametersEClass, 
		   source, 
		   new String[] {
			 "name", "TimeParameters",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getTimeParameters_TransferTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "TransferTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_QueueTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "QueueTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_WaitTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "WaitTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_SetUpTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "SetUpTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ProcessingTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ProcessingTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ValidationTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ValidationTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getTimeParameters_ReworkTime(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ReworkTime",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (timeUnitEEnum, 
		   source, 
		   new String[] {
			 "name", "TimeUnit"
		   });		
		addAnnotation
		  (timeUnitObjectEDataType, 
		   source, 
		   new String[] {
			 "name", "TimeUnit:Object",
			 "baseType", "TimeUnit"
		   });		
		addAnnotation
		  (triangularDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "TriangularDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (getTriangularDistributionType_Mode(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mode"
		   });		
		addAnnotation
		  (truncatedNormalDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "TruncatedNormalDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Mean(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "mean"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (getTruncatedNormalDistributionType_StandardDeviation(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "standardDeviation"
		   });		
		addAnnotation
		  (uniformDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UniformDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getUniformDistributionType_Max(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "max"
		   });		
		addAnnotation
		  (getUniformDistributionType_Min(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "min"
		   });		
		addAnnotation
		  (userDistributionDataPointTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UserDistributionDataPoint_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_ParameterValueGroup(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "ParameterValue:group",
			 "namespace", "##targetNamespace"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_ParameterValue(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "ParameterValue",
			 "namespace", "##targetNamespace",
			 "group", "ParameterValue:group"
		   });		
		addAnnotation
		  (getUserDistributionDataPointType_Probability(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "probability"
		   });		
		addAnnotation
		  (userDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "UserDistribution_._type",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getUserDistributionType_Group(), 
		   source, 
		   new String[] {
			 "kind", "group",
			 "name", "group:5"
		   });		
		addAnnotation
		  (getUserDistributionType_UserDistributionDataPoint(), 
		   source, 
		   new String[] {
			 "kind", "element",
			 "name", "UserDistributionDataPoint",
			 "namespace", "##targetNamespace",
			 "group", "#group:5"
		   });		
		addAnnotation
		  (getUserDistributionType_Discrete(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "discrete"
		   });		
		addAnnotation
		  (vendorExtensionEClass, 
		   source, 
		   new String[] {
			 "name", "VendorExtension",
			 "kind", "elementOnly"
		   });		
		addAnnotation
		  (getVendorExtension_Any(), 
		   source, 
		   new String[] {
			 "kind", "elementWildcard",
			 "wildcards", "##other",
			 "name", ":0",
			 "processing", "strict"
		   });		
		addAnnotation
		  (getVendorExtension_Name(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "name"
		   });		
		addAnnotation
		  (getVendorExtension_AnyAttribute(), 
		   source, 
		   new String[] {
			 "kind", "attributeWildcard",
			 "wildcards", "##other",
			 "name", ":2",
			 "processing", "strict"
		   });		
		addAnnotation
		  (weibullDistributionTypeEClass, 
		   source, 
		   new String[] {
			 "name", "WeibullDistribution_._type",
			 "kind", "empty"
		   });		
		addAnnotation
		  (getWeibullDistributionType_Scale(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "scale"
		   });		
		addAnnotation
		  (getWeibullDistributionType_Shape(), 
		   source, 
		   new String[] {
			 "kind", "attribute",
			 "name", "shape"
		   });
	}
135122
public static TypeAnnotationPosition
        classExtends(final List<TypePathEntry> location,
                     final JCLambda onLambda,
                     final int pos) {
        return classExtends(location, onLambda, 65535, pos);
    }
81225
@Override
    public IEntityGroup newGroup(Class type) throws GroupsException {
        throwExceptionIfNotInternallyManaged();
        IEntityGroup group = groupFactory.newInstance(type);
        group.setLocalGroupService(this);
        if (cacheInUse()) {
            cacheAdd(group);
        }
        return group;
    }
202942
public static OffsetGroup from(final CharOffset charOffset, final EDTOffset edtOffset) {
    return new Builder().charOffset(charOffset).edtOffset(edtOffset).build();
  }
878344
public DynaFormRow createExtendedRow() {
        if (extendedRows == null) {
            extendedRows = new ArrayList<DynaFormRow>();
        }

        final DynaFormRow dynaFormRow = new DynaFormRow(extendedRows.size() + 1, true, this);
        extendedRows.add(dynaFormRow);

        return dynaFormRow;
    }
337212
@Override
    public List<ContainerDef> getGroupContainers() {
        List<ContainerDef> containers = new ArrayList<ContainerDef>();
        for (Node container : group.get("container")) {
            containers.add(new GroupContainerDefImpl(getDescriptorName(), getRootNode(), group, container));
        }
        return containers;
    }
1148987
public Map<String, List<Integer>> getExpandedItemIdIndexMap() {
		// CLIENT MODE is include ALL
		boolean expandedOnly = getExpandMode() != ExpandMode.CLIENT;
		if (getScratchMap() == null) {
			if (getCustomTree() == null) {
				return createItemIdIndexMap(expandedOnly);
			} else {
				return createExpandedCustomIdIndexMapping(expandedOnly);
			}
		}
		Map<String, List<Integer>> map = (Map<String, List<Integer>>) getScratchMap().get(EXPANDED_IDS_TO_INDEX_MAPPING_SCRATCH_MAP_KEY);
		if (map == null) {
			if (getCustomTree() == null) {
				map = createItemIdIndexMap(expandedOnly);
			} else {
				map = createExpandedCustomIdIndexMapping(expandedOnly);
			}
			getScratchMap().put(EXPANDED_IDS_TO_INDEX_MAPPING_SCRATCH_MAP_KEY, map);
		}
		return map;
	}
623639
@Override
    public PmdRuleSet create() {
        final SAXBuilder parser = new SAXBuilder();
        final Document dom;
        try {
            dom = parser.build(source);
        } catch (JDOMException | IOException e) {
            if (messages != null) {
                messages.addErrorText(INVALID_INPUT + " : " + e.getMessage());
            }
            LOG.error(INVALID_INPUT, e);
            return new PmdRuleSet();
        }

        final Element eltResultset = dom.getRootElement();
        final Namespace namespace = eltResultset.getNamespace();
        final PmdRuleSet result = new PmdRuleSet();

        final String name = eltResultset.getAttributeValue("name");
        final Element descriptionElement = getChild(eltResultset, namespace);

        result.setName(name);

        if (descriptionElement != null) {
            result.setDescription(descriptionElement.getValue());
        }

        for (Element eltRule : getChildren(eltResultset, "rule", namespace)) {
            PmdRule pmdRule = new PmdRule(eltRule.getAttributeValue("ref"));
            pmdRule.setClazz(eltRule.getAttributeValue("class"));
            pmdRule.setName(eltRule.getAttributeValue("name"));
            pmdRule.setMessage(eltRule.getAttributeValue("message"));
            parsePmdPriority(eltRule, pmdRule, namespace);
            parsePmdProperties(eltRule, pmdRule, namespace);
            result.addRule(pmdRule);
        }
        return result;
    }