Returns the qualifier for a name separated by dots. The qualified part is
everything up to the last dot separator.

@param qualifiedName The qualified name.
@return The qualifier portion.
547557
public static String qualifier(String qualifiedName) {
		int loc = qualifiedName.lastIndexOf('.');
		if (loc < 0)
			return "";

		return qualifiedName.substring(0, loc);
	}
1019957
def _get_qualifier(val):
        """"""
        quals = set()
        if val == '':
            return quals
        for val in val.split('|'):
            val = val.lower()
            quals.add(val if val != 'not' else 'NOT')
        return quals
189030
public static String getQualifierAction(String qualifierAsString) {
    int pos = qualifierAsString.lastIndexOf(DELIMITER);
    if (pos == -1) {
      throw new IllegalArgumentException("Wrong qualifier format: '" + qualifierAsString + "'");
    }
    return qualifierAsString.substring(pos + 1);
  }
1197751
public byte[] columnQualifier() {
    if (display_name == null || display_name.isEmpty()) {
      throw new IllegalArgumentException("Missing display name");
    }
    
    final byte[] qualifier = new byte[LEAF_PREFIX.length + 4];
    System.arraycopy(LEAF_PREFIX, 0, qualifier, 0, LEAF_PREFIX.length);
    System.arraycopy(Bytes.fromInt(hashCode()), 0, qualifier, 
        LEAF_PREFIX.length, 4);
    return qualifier;
  }
826891
@Override
	public QualifiedName toQualifiedName(String qualifiedNameAsString) {
		if (criticalOperatorNames.contains(qualifiedNameAsString))
			return QualifiedName.create(qualifiedNameAsString);
		return super.toQualifiedName(qualifiedNameAsString);
	}
583653
public QualifiedName qualifiedName(String name) {
		if (!com.google.common.base.Strings.isNullOrEmpty(name)) {
			final List<String> segments = Strings.split(name, "."); //$NON-NLS-1$
			return QualifiedName.create(segments);
		}
		return QualifiedName.create();
	}
1063624
@Override
  public String getQualifiedName() {
    String prefix = StringUtil.defaultString(entityPrefix, "");
    String suffix = StringUtil.defaultString(entitySuffix, "");

    if (packageName == null || packageName.isEmpty()) {
      return prefix + simpleName + suffix;
    }

    return packageName + "." + prefix + simpleName + suffix;
  }
289087
public static NameExpr createNameExpr(String qualifiedName) {
        String[] split = qualifiedName.split("\\.");
        NameExpr ret = new NameExpr(split[0]);
        for (int i = 1; i < split.length; i++) {
            ret = new QualifiedNameExpr(ret, split[i]);
        }
        return ret;
    }
1112393
public static String determineReadableClassName(String qualifiedName) {

        String readableClassName = StringUtils.removeWhitespace(qualifiedName);
        if (readableClassName == null) {

            throw new IllegalArgumentException("qualifiedName must not be null.");
        } else if (readableClassName.startsWith("[")) {

            StringBuilder classNameBuffer = new StringBuilder();
            while (readableClassName.startsWith("[")) {
                classNameBuffer.append("[]");
                readableClassName = readableClassName.substring(1);
            }
            
            if (PRIMITIVE_MAPPING.containsValue(readableClassName)) {
                
                for (Map.Entry<String,String> next : PRIMITIVE_MAPPING.entrySet()) {
                    if (next.getValue().equals(readableClassName)) {
                        readableClassName = next.getKey() + classNameBuffer.toString();
                        break;
                    }
                }
                
            } else if (readableClassName.startsWith("L") && readableClassName.endsWith(";")) {
                readableClassName = readableClassName.substring(1, readableClassName.length() - 1) + classNameBuffer.toString();
            } else {
                throw new IllegalArgumentException("qualifiedName was invalid {" + readableClassName + "}");                
            }
        } else if (readableClassName.endsWith("]")) {
            throw new IllegalArgumentException("qualifiedName was invalid {" + readableClassName + "}");
        }
        
        return readableClassName;
    }
26210
public static String getPrefixPart(String qname)
  {

    int index = qname.indexOf(':');

    return (index >= 0) ? qname.substring(0, index) : "";
  }
732315
private void computeQualifiedName() {
    if (parent != null) {
      qualifiedName = parent.qualifiedName + "." + field.getName();
    } else {
      qualifiedName = field.getName();
    }
  }
606098
public Optional<String> getQualifiedName() {
        if (null == name) {
            return Optional.absent();
        }
        return null == owner ? Optional.of(name) : Optional.of(owner + "." + name);
    }
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();
  }
1093523
protected static String qualifiedNameFromIdAndContext(String name, String context) {
        if (!name.contains(".")) {
            return context + "." + name;
        }
        return name;
    }
592289
public List<A> findAllAttributesByQualifier(String qualifier) {
        return (List<A>)getModelStore().findAllAttributesByQualifier(qualifier);
    }
774623
@ManyToOne(targetEntity = org.openprovenance.prov.sql.QualifiedName.class, cascade = {
        CascadeType.ALL
    })
    @JoinColumn(name = "QN")
    public QualifiedName getQualifiedName() {
        return qualifiedName;
    }
666991
public boolean getQualifierNameMajorTopic() {
    if (MeshHeading_Type.featOkTst && ((MeshHeading_Type)jcasType).casFeat_qualifierNameMajorTopic == null)
      jcasType.jcas.throwFeatMissing("qualifierNameMajorTopic", "de.julielab.jules.types.MeshHeading");
    return jcasType.ll_cas.ll_getBooleanValue(addr, ((MeshHeading_Type)jcasType).casFeatCode_qualifierNameMajorTopic);}