Пример #1
0
 public String migrate(String formattedString, String toBeFormattedString, Pattern format) {
   if (Strings.isEmpty(toBeFormattedString) || Strings.isEmpty(formattedString))
     return toBeFormattedString;
   FormattedString formatted = createFormattedString(formattedString, format);
   FormattedString toBeFormatted = createFormattedString(toBeFormattedString, format);
   if (formatted.semantic.equals(toBeFormatted.semantic)) return formattedString;
   List<Mapping> mappings = Lists.newArrayList();
   List<Region> remainingRegions = Lists.newArrayList();
   findLinearMatches(formatted, toBeFormatted, mappings, remainingRegions);
   for (Mapping m : mappings) toBeFormatted.migrateFrom(formatted, m);
   return toBeFormatted.toString();
 }
 @Override
 public String getQualifiedName(char innerClassDelimiter) {
   if (simpleName == null) return null;
   JvmDeclaredType declaringType = getDeclaringType();
   if (declaringType == null) {
     if (Strings.isEmpty(packageName)) return simpleName;
     return packageName + "." + simpleName;
   }
   String parentName = declaringType.getQualifiedName(innerClassDelimiter);
   if (parentName == null) return null;
   return parentName + innerClassDelimiter + simpleName;
 }
 @Override
 protected String computeIdentifier() {
   if (simpleName == null) return null;
   JvmDeclaredType declaringType = internalGetDeclaringType();
   if (declaringType == null) {
     if (Strings.isEmpty(packageName)) return simpleName;
     return packageName + "." + simpleName;
   }
   String parentName = declaringType.getIdentifier();
   if (parentName == null) return null;
   return parentName + '$' + simpleName;
 }
 @Override
 protected List<ImportNormalizer> internalGetImportedNamespaceResolvers(
     EObject context, boolean ignoreCase) {
   if (!(context instanceof XtendFile)) return Collections.emptyList();
   List<ImportNormalizer> importedNamespaceResolvers =
       super.internalGetImportedNamespaceResolvers(context, ignoreCase);
   if (context instanceof XtendFile && !Strings.isEmpty(((XtendFile) context).getPackage())) {
     importedNamespaceResolvers.add(
         new ImportNormalizer(
             nameConverter.toQualifiedName(((XtendFile) context).getPackage()), true, ignoreCase));
   }
   return importedNamespaceResolvers;
 }
 public Number toValue(String string, INode node) {
   if (Strings.isEmpty(string))
     throw new ValueConverterException("Couldn't convert empty string to number", node, null);
   try {
     if (string.contains(".") || string.contains("e") || string.contains("e")) {
       return new BigDecimal(string);
     } else {
       return new BigInteger(string);
     }
   } catch (NumberFormatException e) {
     throw new ValueConverterException("Couldn't convert '" + string + "' to number", node, e);
   }
 }
 /**
  * Create a new {@link ImportNormalizer} for the given namespace.
  *
  * @param namespace the namespace.
  * @param ignoreCase <code>true</code> if the resolver should be case insensitive.
  * @return a new {@link ImportNormalizer} or <code>null</code> if the namespace cannot be
  *     converted to a valid qualified name.
  */
 protected ImportNormalizer createImportedNamespaceResolver(
     final String namespace, boolean ignoreCase) {
   if (Strings.isEmpty(namespace)) return null;
   QualifiedName importedNamespace = qualifiedNameConverter.toQualifiedName(namespace);
   if (importedNamespace == null || importedNamespace.getSegmentCount() < 1) {
     return null;
   }
   boolean hasWildcard =
       ignoreCase
           ? importedNamespace.getLastSegment().equalsIgnoreCase(getWildcard())
           : importedNamespace.getLastSegment().equals(getWildcard());
   if (hasWildcard) {
     if (importedNamespace.getSegmentCount() <= 1) return null;
     return doCreateImportNormalizer(importedNamespace.skipLast(1), true, ignoreCase);
   } else {
     return doCreateImportNormalizer(importedNamespace, false, ignoreCase);
   }
 }
 public String check(IEObjectDescription input) {
   if (input instanceof IValidatedEObjectDescription) {
     final IValidatedEObjectDescription validatedDescription =
         (IValidatedEObjectDescription) input;
     JvmIdentifiableElement identifiable = validatedDescription.getEObjectOrProxy();
     if (identifiable.eIsProxy())
       identifiable = (JvmIdentifiableElement) EcoreUtil.resolve(identifiable, context);
     String issueCode;
     if (identifiable.eIsProxy()) issueCode = UNRESOLVABLE_PROXY;
     else if (!validatedDescription.isValid()) {
       if (Strings.isEmpty(validatedDescription.getIssueCode())) issueCode = FEATURE_NOT_VISIBLE;
       else return validatedDescription.getIssueCode();
     } else issueCode = dispatcher.invoke(identifiable, context, reference, validatedDescription);
     validatedDescription.setIssueCode(issueCode);
     return issueCode;
   }
   return null;
 }
  protected IScope getLocalElementsScope(
      IScope parent, IScope globalScope, EObject context, EReference reference) {
    IScope result = parent;
    QualifiedName name = getQualifiedNameOfLocalElement(context);
    boolean ignoreCase = isIgnoreCase(reference);
    ISelectable resourceOnlySelectable = getAllDescriptions(context.eResource());
    ISelectable globalScopeSelectable = new ScopeBasedSelectable(globalScope);

    // imports
    List<ImportNormalizer> explicitImports = getImportedNamespaceResolvers(context, ignoreCase);
    if (!explicitImports.isEmpty()) {
      result =
          createImportScope(
              result,
              explicitImports,
              globalScopeSelectable,
              reference.getEReferenceType(),
              ignoreCase);
    }

    // local element
    if (name != null) {
      ImportNormalizer localNormalizer = doCreateImportNormalizer(name, true, ignoreCase);
      result =
          createImportScope(
              result,
              singletonList(localNormalizer),
              resourceOnlySelectable,
              reference.getEReferenceType(),
              ignoreCase);
    }

    // scope for jvm elements
    Set<EObject> elements = associations.getJvmElements(context);
    for (EObject derivedJvmElement : elements) {
      // scope for JvmDeclaredTypes
      if (derivedJvmElement instanceof JvmDeclaredType) {
        JvmDeclaredType declaredType = (JvmDeclaredType) derivedJvmElement;
        QualifiedName jvmTypeName = getQualifiedNameOfLocalElement(declaredType);
        if (declaredType.getDeclaringType() == null
            && !Strings.isEmpty(declaredType.getPackageName())) {
          QualifiedName packageName =
              this.qualifiedNameConverter.toQualifiedName(declaredType.getPackageName());
          ImportNormalizer normalizer = doCreateImportNormalizer(packageName, true, ignoreCase);
          result =
              createImportScope(
                  result,
                  singletonList(normalizer),
                  globalScopeSelectable,
                  reference.getEReferenceType(),
                  ignoreCase);
        }
        if (jvmTypeName != null && !jvmTypeName.equals(name)) {
          ImportNormalizer localNormalizer =
              doCreateImportNormalizer(jvmTypeName, true, ignoreCase);
          result =
              createImportScope(
                  result,
                  singletonList(localNormalizer),
                  resourceOnlySelectable,
                  reference.getEReferenceType(),
                  ignoreCase);
        }
      }
      // scope for JvmTypeParameterDeclarator
      if (derivedJvmElement instanceof JvmTypeParameterDeclarator) {
        JvmTypeParameterDeclarator parameterDeclarator =
            (JvmTypeParameterDeclarator) derivedJvmElement;
        List<IEObjectDescription> descriptions = null;
        for (JvmTypeParameter param : parameterDeclarator.getTypeParameters()) {
          if (param.getSimpleName() != null) {
            if (descriptions == null) descriptions = Lists.newArrayList();
            QualifiedName paramName = QualifiedName.create(param.getSimpleName());
            descriptions.add(EObjectDescription.create(paramName, param));
          }
        }
        if (descriptions != null && !descriptions.isEmpty())
          result = MapBasedScope.createScope(result, descriptions);
      }
    }
    return result;
  }
Пример #9
0
 String text(PuppetManifest ele) {
   String s = ele.eResource().getURI().lastSegment();
   return Strings.isEmpty(s) ? "<unnamed>" : URI.decode(s);
 }