Stands for "qualified name", a utility function to turn a namespace
    prefixed tag name into a Clark-notation qualified tag name for lxml. For
    example, ``qn('p:cSld')`` returns ``'{http://schemas.../main}cSld'``.
426060
def qn(tag):
    
    prefix, tagroot = tag.split(':')
    uri = nsmap[prefix]
    return '{%s}%s' % (uri, tagroot)
1367571
public String getQualifiedName(Node n) {
    if (n.getBooleanProp(Node.IS_MODULE_NAME)) {
      return n.getString();
    } else if (n.isGetProp()) {
      String left = getQualifiedName(n.getFirstChild());
      if (left == null) {
        return null;
      }
      return left + "." + n.getLastChild().getString();
    }
    return n.getQualifiedName();
  }
600805
private static String fullQualifiedName(Tree tree) {
		if (tree.is(Tree.Kind.IDENTIFIER)) {
			return ((IdentifierTree) tree).name();
		} else if (tree.is(Tree.Kind.MEMBER_SELECT)) {
			MemberSelectExpressionTree m = (MemberSelectExpressionTree) tree;
			return fullQualifiedName(m.expression()) + "." + m.identifier().name();
		}
		throw new UnsupportedOperationException(String.format("Kind/Class '%s' not supported", tree.getClass()));
	}
661018
def qual_name(self) -> QualName:
        """"""
        p, s, loc = self._key.partition(":")
        return (loc, p) if s else (p, self.namespace)
832654
public static QualifiedName of(Class<?> cls) {
    if (cls.getEnclosingClass() != null) {
      return QualifiedName.of(cls.getEnclosingClass()).nestedType(cls.getSimpleName());
    } else if (cls.getPackage() != null) {
      return QualifiedName.of(cls.getPackage().getName(), cls.getSimpleName());
    } else {
      return QualifiedName.of("", cls.getSimpleName());
    }
  }
1030016
public function clarkNotation()
	{
		if ( $this->namespaceURI )
		{
			return sprintf( '{%s}%s', $this->namespaceURI, $this->localName );
		}
		else
		{
			return $this->localName;
		}
	}
249591
private boolean requiresFullyQualifiedName() {
        String currentPackage = PackageScope.get();
        if (currentPackage != null) {
            if (definition != null && definition.getPackageName() != null && definition.getFullyQualifiedName() != null) {
                String conflictingFQCN = getDefinition().getFullyQualifiedName().replace(definition.getPackageName(), currentPackage);
                if (!conflictingFQCN.equals(getFullyQualifiedName()) && DefinitionRepository.getRepository().getDefinition(conflictingFQCN) != null) {
                    return true;
                }
            }
        }

        Map<String, String> referenceMap = DefinitionRepository.getRepository().getReferenceMap();
        if (referenceMap != null && referenceMap.containsKey(definition.getName())) {
            String fqn = referenceMap.get(definition.getName());
            if (!getDefinition().getFullyQualifiedName().equals(fqn)) {
                return true;
            }
        }
        return false;
    }
237239
public static QualifiedName valueOf(String value, NamespaceContext ctx) {
        if (value == null) {
            throw new IllegalArgumentException("value must not be null");
        }
        int colon = value.indexOf(':');
        int closingBrace = value.indexOf('}');
        boolean qnameToStringStyle = value.startsWith("{") && closingBrace > 0;
        if (!qnameToStringStyle && colon < 0) {
            return new QualifiedName(value); // null namespace
        }
        return qnameToStringStyle ? parseQNameToString(value, closingBrace)
            : parsePrefixFormat(value, colon, ctx);
    }
475733
public String renderQualifiedName(String qualifiedName) {
		Assert.notNull(qualifiedName, "No qualified name specified");
		StringBuffer sb = new StringBuffer(qualifiedName.length() + 5);
		char[] chars = qualifiedName.toCharArray();
		sb.append(Character.toUpperCase(chars[0]));
		boolean foundDot = false;
		for (int i = 1; i < chars.length; i++) {
			char c = chars[i];
			if (Character.isLetter(c)) {
				if (Character.isLowerCase(c)) {
					if (foundDot) {
						sb.append(Character.toUpperCase(c));
						foundDot = false;
					}
					else {
						sb.append(c);
					}
				}
				else {
					sb.append(c);
				}
			}
			else if (c == '.') {
				sb.append(c);
				foundDot = true;
			}
		}
		return sb.toString();
	}
1289751
public String getQualifiedName() {
		if (prefixManager != null) {
			String shortName = prefixManager.getShortForm(getFullName());
			if (shortName.startsWith(":")) {
				return shortName.substring(1, shortName.length());
			} else {
				return shortName;
			}
		} else {
			return getFullName();
		}
	}
840795
def p_fully_qualified_class_name(p):
    ''''''
    if len(p) == 2:
        p[0] = p[1]
    elif len(p) == 3:
        p[0] = p[1] + p[2]
    else:
        p[0] = p[1] + p[2] + p[3]
102109
def GetNSAndWsdlname(self, tag):
      
      idx = tag.find(":")
      if idx >= 0:
         prefix, name = tag[:idx], tag[idx + 1:]
      else:
         prefix, name = None, tag
      # Map prefix to ns
      ns = self._GetNamespaceFromPrefix(prefix)
      return ns, name
1372565
def _inclusiveNamespacePrefixes(node, context, unsuppressedPrefixes):
    ''''''
    inclusive = []
    if node.prefix:
        usedPrefixes = ['xmlns:%s' %node.prefix]
    else:
        usedPrefixes = ['xmlns']

    for a in _attrs(node):
        if a.nodeName.startswith('xmlns') or not a.prefix: continue
        usedPrefixes.append('xmlns:%s' %a.prefix)

    unused_namespace_dict = {}
    for attr in context:
        n = attr.nodeName
        if n in unsuppressedPrefixes:
            inclusive.append(attr)
        elif n.startswith('xmlns:') and n[6:] in unsuppressedPrefixes:
            inclusive.append(attr)
        elif n.startswith('xmlns') and n[5:] in unsuppressedPrefixes:
            inclusive.append(attr)
        elif attr.nodeName in usedPrefixes:
            inclusive.append(attr)
        elif n.startswith('xmlns:'):
            unused_namespace_dict[n] = attr.value

    return inclusive, unused_namespace_dict
547557
public static String qualifier(String qualifiedName) {
		int loc = qualifiedName.lastIndexOf('.');
		if (loc < 0)
			return "";

		return qualifiedName.substring(0, loc);
	}
278014
@SuppressWarnings("ReferenceEquality")
  public final boolean matchesQualifiedName(Node n) {
    if (n.token != token) {
      return false;
    }
    switch (token) {
      case NAME:
        // ==, rather than equal as it is intern'd in setString
        return !getString().isEmpty() && getString() == n.getString();
      case THIS:
      case SUPER:
        return true;
      case GETPROP:
        // ==, rather than equal as it is intern'd in setString
        return getLastChild().getString() == n.getLastChild().getString()
            && getFirstChild().matchesQualifiedName(n.getFirstChild());

      case MEMBER_FUNCTION_DEF:
        // These are explicitly *not* qualified name components.
      default:
        return false;
    }
  }
1093523
protected static String qualifiedNameFromIdAndContext(String name, String context) {
        if (!name.contains(".")) {
            return context + "." + name;
        }
        return name;
    }
1246383
private static Expression symbolWithNamespace(String requireSymbol, String fullyQualifiedSymbol) {
    GoogRequire require = GoogRequire.create(requireSymbol);
    if (fullyQualifiedSymbol.equals(require.symbol())) {
      return require.reference();
    }
    String ident = fullyQualifiedSymbol.substring(require.symbol().length() + 1);
    return require.dotAccess(ident);
  }