Returns {@code true} if the specified label is resolved, that is,
is associated with an offset in the bytecode of the method.
555536
@Requires("label != null")
  protected static boolean labelIsResolved(Label label) {
    try {
      label.getOffset();
    } catch (IllegalStateException e) {
      return false;
    }
    return true;
  }
1048689
public InstructionHandle getLabeledInstruction(String label) {
        PatternElementMatch first = getFirstLabeledMatch(label);
        return first != null ? first.getMatchedInstructionInstructionHandle() : null;
    }
408420
private boolean isSolvable(int method) throws NullPointerException {
    if(solved) {
      return solvable;
    }

    if(!reducedRowEchelonForm) {
      reducedRowEchelonForm(method);
    }

    // test if rank(coeff) == rank(coeff|rhs)
    for(int i = rank; i < rhs.length; i++) {
      if(Math.abs(rhs[row[i]]) > DELTA) {
        solvable = false;
        return false; // not solvable
      }
    }

    solvable = true;
    return true;
  }
100475
public int store(String label) {
        if (strInt.containsKey(label)) {
            return (strInt.get(label).intValue());
        } else if (!newLabelsAllowed) {
            return KEY_DUMMY_LABEL;
        } else { // store label
            Integer intKey = count++;
            strInt.put(label, intKey);
            intStr.put(intKey, label);
            return intKey.intValue();
        }
    }
634266
private boolean isIsGetter(AptMethod method) {
        String methodName = method.getName();

        if (methodName.length() < 3)
            return false;

        if (!methodName.startsWith("is"))
            return false;

        if (method.getArgList().length() > 0)
            return false;

        if (!"boolean".equals(method.getReturnType()))
            return false;

        return true;
    }
445030
private static boolean isAPortOffset(int offset) {
    return (offset == STANDARD_ASCII_PORT_OFFSET)
                   || (offset == STANDARD_HTTP_PORT_OFFSET)
                   || (offset == STANDARD_SERVLET_PORT_OFFSET)
                   || (offset == STANDARD_CFASL_PORT_OFFSET);
  }
1078486
protected boolean isReassignmentOperator(XBinaryOperation operator) {
		if (operator.isReassignFirstArgument()) {
			return true;
		}
		final QualifiedName operatorName = this.operatorMapping.getOperator(
				QualifiedName.create(operator.getFeature().getSimpleName()));
		final QualifiedName compboundOperatorName = this.operatorMapping.getSimpleOperator(operatorName);
		return compboundOperatorName != null;
	}
111877
final public Boolean checkRealOffset() {
    if ((tokenRealOffset == null) || !provideRealOffset) {
      return false;
    } else if (tokenOffset == null) {
      return true;
    } else if (tokenOffset.getStart() == tokenRealOffset.getStart()
        && tokenOffset.getEnd() == tokenRealOffset.getEnd()) {
      return false;
    } else {
      return true;
    }
  }
670465
public int indexOf(String labelText)
	{
		if (!labelMap.containsKey(labelText))
			throw new IllegalArgumentException("The label \"" + labelText +
				"\" is absent in pattern.");
		
		return labelMap.get(labelText);
	}
1077719
@Override
    public boolean isBoundary(int offset) {
        checkOffset(offset, fText);

        // the beginning index of the iterator is always a boundary position by definition
        if (offset == fText.getBeginIndex()) {
            first();       // For side effects on current position, tag values.
            return true;
        }

        if (offset == fText.getEndIndex()) {
            last();       // For side effects on current position, tag values.
            return true;
        }

        // otherwise, we can use following() on the position before the specified
        // one and return true if the position we get back is the one the user
        // specified

        // return following(offset - 1) == offset;
        // TODO:  check whether it is safe to revert to the simpler offset-1 code
        //         The safe rules may take care of unpaired surrogates ok.
        fText.setIndex(offset);
        previous32(fText);
        int  pos = fText.getIndex();
        boolean result = following(pos) == offset;
        return result;
    }
860099
private boolean isValidTaxonomy(final String label, final Double score) {
    return !StringUtils.isBlank(label)
           || score != null;
  }
151004
public boolean release(long offset) {
    Assert.argNot(offset < 0, "offset must be positive");
    if (bits.size() <= offset) {
      while (bits.size() <= offset) {
        bits.resize(bits.size() * 2);
      }
    }
    return bits.set(offset);
  }
392287
public static boolean hasMatchingLabels(FlatRow row) {
    int inLabelCount = 0;
    int outLabelCount = 0;
    for (FlatRow.Cell cell : row.getCells()) {
      for (String label : cell.getLabels()) {
        // TODO(kevinsi4508): Make sure {@code label} is a {@link WhileMatchFilter} label.
        // TODO(kevinsi4508): Handle multiple {@link WhileMatchFilter} labels.
        if (label.endsWith(WHILE_MATCH_FILTER_IN_LABEL_SUFFIX)) {
          inLabelCount++;
        } else if (label.endsWith(WHILE_MATCH_FILTER_OUT_LABEL_SUFFIX)) {
          outLabelCount++;
        }
      }
    }

    // Checks if there is mismatching {@link WhileMatchFilter} label.
    if (inLabelCount != outLabelCount) {
      return false;
    }

    return true;
  }
155314
private void checkLabels(boolean forGenerative, String... label)
	{
		for (int i = 0; i < (forGenerative ? label.length - 1 : label.length); i++)
		{
			if (!hasLabel(label[i])) throw new IllegalArgumentException(
				"Label neither found, nor generated: " + label[i]);
		}
	}
386856
static boolean containsDisallowedLeLabelForHistogram(List<String> labelNames, Type type) {
    if (!Type.HISTOGRAM.equals(type)) {
      return false;
    }
    for (String label : labelNames) {
      if (LABEL_NAME_BUCKET_BOUND.equals(label)) {
        return true;
      }
    }
    return false;
  }
93425
def resolve(self, lineno):
        
        if not self.defined:
            error(lineno, "Undeclared label '%s'" % self.name)

        if isinstance(self.value, Expr):
            return self.value.eval()

        return self.value
1253281
public void setLabel(String label) {

        int ix = lstSizes.indexOf(label);
        if (ix != -1) {
            setLabel(ix);
        }
    }