Matches a {@link NamedElement} for its name's suffix.

@param suffix The expected name's suffix.
@param <T>    The type of the matched object.
@return An element matcher for a named element's name's suffix.
356357
public static <T extends NamedElement> ElementMatcher.Junction<T> nameEndsWith(String suffix) {
        return new NameMatcher<T>(new StringMatcher(suffix, StringMatcher.Mode.ENDS_WITH));
    }
1179492
public boolean endsWith(final BinaryString suffix) {
		ensureMaterialized();
		suffix.ensureMaterialized();
		return matchAt(suffix, sizeInBytes - suffix.sizeInBytes);
	}
824465
function NamedElement(name, parent) {
        var _this = _super.call(this, parent) || this;
        _this.name = name;
        _this.qualifiedName = parent ? parent.toString() + NamedElement.namespaceSeparator + name : name;
        return _this;
    }
701762
@Override
    public MatchType match(int level, Node node) {
        if(! (node instanceof Element)) {
            return MatchType.NOT_A_MATCH;
        }
        Element element = (Element) node;
        if(this.level != level) {
            return MatchType.NOT_A_MATCH;
        } else if(nodename.equals(element.getName())) {
            return MatchType.NODE_MATCH;
        }
        return MatchType.NOT_A_MATCH;
    }
1192742
def match_namespace(self, el, tag):
        """"""

        match = True
        namespace = self.get_tag_ns(el)
        default_namespace = self.namespaces.get('')
        tag_ns = '' if tag.prefix is None else self.namespaces.get(tag.prefix, None)
        # We must match the default namespace if one is not provided
        if tag.prefix is None and (default_namespace is not None and namespace != default_namespace):
            match = False
        # If we specified `|tag`, we must not have a namespace.
        elif (tag.prefix is not None and tag.prefix == '' and namespace):
            match = False
        # Verify prefix matches
        elif (
            tag.prefix and
            tag.prefix != '*' and (tag_ns is None or namespace != tag_ns)
        ):
            match = False
        return match
54503
public static <T extends TypeDescription> ElementMatcher.Junction<T> isAnnotation() {
        return new ModifierMatcher<T>(ModifierMatcher.Mode.ANNOTATION);
    }
352240
protected Element findTag(String tagName, Element element) {
        Node result = element.getFirstChild();
        
        while (result != null) {
            if (result instanceof Element
                    && (tagName.equals(((Element) result).getNodeName()) || tagName
                            .equals(((Element) result).getLocalName()))) {
                break;
            }
            result = result.getNextSibling();
        }
        
        return (Element) result;
    }
1020470
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter() {
        return nameStartsWith("set").and(takesArguments(1)).and(returns(TypeDescription.VOID));
    }
960564
protected XmlElement findMatchedElementIn(Document document, org.dom4j.Element element) {
    org.dom4j.Attribute id = element.attribute("id");
    String idName = id.getName();
    String idValue = id.getValue();
    for (Element me : document.getRootElement().getElements()) {
      if (me instanceof XmlElement) {
        XmlElement xe = (XmlElement) me;
        for (Attribute ab : xe.getAttributes()) {
          if (StringUtils.equals(idName, ab.getName()) && StringUtils.equals(idValue, ab.getValue())) {
            return xe;
          }
        }
      }
    }
    return null;
  }
1185711
public static <T extends FieldDescription> ElementMatcher.Junction<T> genericFieldType(ElementMatcher<? super TypeDescription.Generic> matcher) {
        return new FieldTypeMatcher<T>(matcher);
    }
1285524
private static Element getFirstNamedElement(Element element, String name) {
		NodeList list = element.getElementsByTagName(name);
		if (list.getLength() == 0) {
			return null;
		}

		return (Element) list.item(0);
	}
250825
public boolean defineElement(String name, Node definingNode) {
    elements.add(name);
    return defineDeclaredProperty(name, elementsType, definingNode);
  }
679689
public static UnindexedMatcher matcherWithSelector(Map<String, Object> selector) {
        ChildrenQueryNode root = buildExecutionTreeForSelector(selector);

        if (root == null) {
            return null;
        }

        UnindexedMatcher matcher = new UnindexedMatcher();
        matcher.root = root;

        return matcher;
    }
538429
private void parseMatcherDefinitions(BeanDefinitionBuilder builder, Element element) {
        ManagedMap<String, Object> matchers = new ManagedMap<String, Object>();
        for (Element matcher : DomUtils.getChildElementsByTagName(element, "matcher")) {
            if (matcher.hasAttribute("ref")) {
                matchers.put(matcher.getAttribute("name"), new RuntimeBeanReference(matcher.getAttribute("ref")));
            } else {
                matchers.put(matcher.getAttribute("name"), BeanDefinitionBuilder.rootBeanDefinition(matcher.getAttribute("class")).getBeanDefinition());
            }
        }

        if (!matchers.isEmpty()) {
            builder.addPropertyValue("members", matchers);
        }
    }
587041
private String createExpressionKey(String suffix) {
		String[] parts = suffix.split("_");
		StringBuilder ret = new StringBuilder("[if ");
		boolean ieAdded = false;
		for (String part : parts) {
			if ("".equals(part)) {
				continue;
			}
			if ("ie".equals(part)) {
				break;
			} else if (Pattern.matches("(lt|lte|gt|gte)", part)) {
				ret.append(part).append(" ");
			} else {
				ret.append("IE ").append(part);
				ieAdded = true;
			}
		}
		if (!ieAdded)
			ret.append("IE");
		ret.append("]");
		return ret.toString();
	}
1014219
public static ClassName adapterName(ClassName type, String suffix) {
    return ClassName.get(type.packageName(),
        Joiner.on('$').join(type.simpleNames()) + suffix);
  }
1323102
public static boolean endsWithIgnoreCase(@Nullable final String str,
      @Nullable final String suffix) {
    return str != null && suffix != null && str.length() >= suffix.length()
        && str.regionMatches(true, str.length() - suffix.length(), suffix, 0, suffix.length());
  }