Extracts qualifier action part from given qualifier string.

@param qualifierAsString qualifier string.
@return qualifier action.
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);
  }
1240221
public static QualifiedName getQualifiedName(DereferenceExpression expression)
    {
        List<String> parts = tryParseParts(expression.base, expression.field.getValue().toLowerCase(Locale.ENGLISH));
        return parts == null ? null : QualifiedName.of(parts);
    }
441374
@Nullable
	static String extractName(@Nullable Object authentication) {

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

		Expression expression = PARSER.parseExpression(NAME_EXPRESSION);

		return expression.getValue(authentication, String.class);
	}
755511
def get_qualifier_id(self):
        
        # Implemented from template for osid.learning.Activity.get_objective_id
        if not bool(self._my_map['qualifierId']):
            raise errors.IllegalState('qualifier empty')
        return Id(self._my_map['qualifierId'])
1115060
private static ServicePort findQualifiedServicePort(Service service, Annotation... qualifiers) {
        Port port = null;
        for (Annotation q : qualifiers) {
            if (q instanceof Port) {
                port = (Port) q;
            }
        }
        if (service.getSpec() != null && service.getSpec().getPorts() != null) {
            for (ServicePort servicePort : service.getSpec().getPorts()) {
                //if no port name is specified we will use the first.
                if (port == null) {
                    return servicePort;
                }

                if (servicePort.getName() != null && servicePort.getName().equals(port.name())) {
                    return servicePort;
                }
            }
        }
        return null;
    }
1255534
public static String getSetKey(ExecutableElement method) {
    StringBuilder result = new StringBuilder();
    AnnotationMirror qualifier = getQualifier(method.getAnnotationMirrors());
    if (qualifier != null) {
      qualifierToString(qualifier, result);
    }
    result.append(SET_PREFIX);
    typeToString(method.getReturnType(), result, '$');
    result.append(">");
    return result.toString();
  }
873385
@SuppressWarnings({"unchecked", "unused"})
    @Internal
    protected final Object getProxiedBean(BeanContext beanContext) {
        DefaultBeanContext defaultBeanContext = (DefaultBeanContext) beanContext;
        Optional<String> qualifier = getAnnotationMetadata().getAnnotationNameByStereotype(javax.inject.Qualifier.class);
        return defaultBeanContext.getProxyTargetBean(getBeanType(), (Qualifier<T>) qualifier.map(q -> Qualifiers.byAnnotation(getAnnotationMetadata(), q)).orElse(null));
    }
943723
public static byte[] getQualifier(final int level, final int order) {
    final byte[] suffix = (level + ":" + order).getBytes(CHARSET);
    final byte[] qualifier = new byte[RULE_PREFIX.length + suffix.length];
    System.arraycopy(RULE_PREFIX, 0, qualifier, 0, RULE_PREFIX.length);
    System.arraycopy(suffix, 0, qualifier, RULE_PREFIX.length, suffix.length);
    return qualifier;
  }
913967
@Nonnull
  public String getAsString (@Nonnull final Charset aCharset)
  {
    return new String (m_aBuffer.array (), m_aBuffer.arrayOffset (), m_aBuffer.position (), aCharset);
  }
106747
public void setQualifier(String qualifier) {
        SystemAssert.requireArgument(qualifier != null && !qualifier.isEmpty(), "Namespace qualifier cannot be null or empty.");
        this.qualifier = qualifier;
    }
1361622
public Set<ComponentDto> selectComponentsByQualifiers(DbSession dbSession, Set<String> qualifiers) {
    checkArgument(!qualifiers.isEmpty(), "Qualifiers cannot be empty");
    return new HashSet<>(mapper(dbSession).selectComponentsByQualifiers(qualifiers));
  }
763011
private static String getActionString(int action) {

        switch (action) {

            case Constraint.RESTRICT :
                return Tokens.T_RESTRICT;

            case Constraint.CASCADE :
                return Tokens.T_CASCADE;

            case Constraint.SET_DEFAULT :
                return Tokens.T_SET + ' ' + Tokens.T_DEFAULT;

            case Constraint.SET_NULL :
                return Tokens.T_SET + ' ' + Tokens.T_NULL;

            default :
                return Tokens.T_NO + ' ' + Tokens.T_ACTION;
        }
    }
415441
private String ensureQualified(String name) {
        String qualifier = String.format("%s.", this.modelInfo.getName());
        if (!name.startsWith(qualifier)) {
            return String.format("%s%s", qualifier, name);
        }

        return name;
    }
1290799
public static Builder builder(String qualifier) {
    requireNonNull(qualifier);
    Preconditions.checkArgument(qualifier.length() <= 10, "Qualifier is limited to 10 characters");
    return new Builder(qualifier);
  }
864826
public static InstanceContext parse( String s ) {

		String name = null, qualifier = null, instancePathOrComponentName = null;
		if( s != null ) {
			Matcher m = Pattern.compile( "(.*)::(.*)::(.*)" ).matcher( s );
			if( m.matches()) {
				name = m.group( 1 ).equals( "null" ) ? null : m.group( 1 );
				qualifier = m.group( 2 ).equals( "null" ) ? null : m.group( 2 );
				instancePathOrComponentName = m.group( 3 ).equals( "null" ) ? null : m.group( 3 );
			}
		}

		return new InstanceContext( name, qualifier, instancePathOrComponentName );
	}
847522
public static Segment fromScopedName(String qualifiedName) {
        if (StreamSegmentNameUtils.isTransactionSegment(qualifiedName)) {
            String originalSegmentName = StreamSegmentNameUtils.getParentStreamSegmentName(qualifiedName);
            return fromScopedName(originalSegmentName);
        } else {
            List<String> tokens = StreamSegmentNameUtils.extractSegmentTokens(qualifiedName);
            if (tokens.size() == 2) { // scope not present
                String scope = null;
                String streamName = tokens.get(0);
                long segmentId = Long.parseLong(tokens.get(1));
                return new Segment(scope, streamName, segmentId);
            } else { // scope present
                String scope = tokens.get(0);
                String streamName = tokens.get(1);
                long segmentId = Long.parseLong(tokens.get(2));
                return new Segment(scope, streamName, segmentId);
            }
        }
    }
859174
public static OrderBy parse(String orderBy) {
    OrderBy toReturn = new OrderBy();
    String[] orderBys = orderBy.split(",");
    for (String order : orderBys) {
      order = order.trim();
      String[] fields = order.split(":");
      Order ord = Order.ASC;
      NullOrder nullOrd = NullOrder.NULL_SMALLEST;
      if (fields.length > 1) {
        String[] qualifiers = fields[1].split("\\|");
        for (String qualifier : qualifiers) {
          qualifier = qualifier.trim();
          boolean success = false;
          try {
            ord = Order.valueOf(qualifier.toUpperCase());
            success = true;
          } catch (IllegalArgumentException e) {
          }
          try {
            nullOrd = NullOrder.valueOf(qualifier.toUpperCase());
            success = true;
          } catch (IllegalArgumentException e) {
          }
          if (!success) {
            throw new PangoolRuntimeException("Unrecognised sort qualifier " + qualifier +
                " on sorting string: " + orderBy + ". Valid qualifiers are " + validQualifiers());
          }
        }
      }
      toReturn.add(fields[0].trim(), ord, nullOrd);
    }
    return toReturn;
  }