Get the UTF-8 string constant at given constant pool index.

@param refIndex
the constant pool index
@return the String at that index
@throws InvalidClassFileFormatException
541182
private String getUtf8String(int refIndex) throws InvalidClassFileFormatException {
        checkConstantPoolIndex(refIndex);
        Constant refConstant = constantPool[refIndex];
        checkConstantTag(refConstant, IClassConstants.CONSTANT_Utf8);
        return (String) refConstant.data[0];
    }
549200
public String convertIndexToDisStr(int index)
    {
        int iErrorCode = this.moveToIndex(index);
        if (iErrorCode == DBConstants.NORMAL_RETURN)
        {
            if (displayFieldName != null)
                return m_record.getField(displayFieldName).getString();
            else
                return m_record.getField(m_iFieldSeq).getString();
        }
        else
            return Constants.BLANK;
    }
776279
function toIndexableString(key) {
  var zero = '\u0000';
  key = normalizeKey(key);
  return collationIndex(key) + SEP + indexify(key) + zero;
}
227655
static Matcher convertRepeatedAnyCharSeqToIndexOf(Matcher matcher) {
    if (matcher instanceof ZeroOrMoreMatcher) {
      ZeroOrMoreMatcher zm1 = matcher.as();
      Matcher prefix = PatternUtils.getPrefix(zm1.next());
      if (zm1.repeated() instanceof AnyMatcher && prefix instanceof CharSeqMatcher) {
        String pattern = prefix.<CharSeqMatcher>as().pattern();
        Matcher suffix = PatternUtils.getSuffix(zm1.next());
        return new IndexOfMatcher(pattern, suffix);
      }
    }
    return matcher;
  }
275400
public String getCapturedText(int index) {
		if (this.beginpos == null)
			throw new IllegalStateException("match() has never been called.");
		if (index < 0 || this.nofgroups <= index)
			throw new IllegalArgumentException(
					"The parameter must be less than " + this.nofgroups + ": "
							+ index);
		String ret;
		int begin = this.beginpos[index], end = this.endpos[index];
		if (begin < 0 || end < 0)
			return null;
		if (this.ciSource != null) {
			ret = REUtil.substring(this.ciSource, begin, end);
		} else if (this.strSource != null) {
			ret = this.strSource.substring(begin, end);
		} else {
			ret = new String(this.charSource, begin, end - begin);
		}
		return ret;
	}
611207
public int getNameIndex(CharSequence name)
    {
        for (ConstantInfo ci : listConstantInfo(Utf8.class))
        {
            Utf8 utf8 = (Utf8) ci;
            String str = utf8.getString();
            if (str.contentEquals(name))
            {
                return constantPoolIndexMap.get(ci);
            }
        }
        return -1;
    }
154443
private Collection<ClassDescriptor> extractReferencedClasses() throws InvalidClassFileFormatException {
        Set<ClassDescriptor> referencedClassSet = new HashSet<>();
        for (Constant constant : constantPool) {
            if (constant == null) {
                continue;
            }
            if (constant.tag == IClassConstants.CONSTANT_Class) {
                @SlashedClassName
                String className = getUtf8String((Integer) constant.data[0]);
                if (className.indexOf('[') >= 0) {
                    extractReferencedClassesFromSignature(referencedClassSet, className);
                } else if (ClassName.isValidClassName(className)) {
                    referencedClassSet.add(DescriptorFactory.instance().getClassDescriptor(className));
                }
            } else if (constant.tag == IClassConstants.CONSTANT_Methodref || constant.tag == IClassConstants.CONSTANT_Fieldref
                    || constant.tag == IClassConstants.CONSTANT_InterfaceMethodref) {
                // Get the target class name
                String className = getClassName((Integer) constant.data[0]);
                extractReferencedClassesFromSignature(referencedClassSet, className);

                // Parse signature to extract class names
                String signature = getSignatureFromNameAndType((Integer) constant.data[1]);
                extractReferencedClassesFromSignature(referencedClassSet, signature);
            }
        }
        return referencedClassSet;
    }
703147
public String convertIndexToDisStr(int index)
    {
        if (this.getNextConverter() != null)
            return this.getNextConverter().convertIndexToDisStr(index);   // By default, use the same string
        else
            return super.convertIndexToDisStr(index);
    }
998412
private function getConstantValue(RefClass $refClass, $member)
    {
        if (!isset($refClass->constants[$member])) {
            throw new MarkupException(sprintf('constant %s::%s does not exist', $refClass->name, $member));
        }

        return $refClass->constants[$member]->value;
    }
215389
@Override
	public String getQualifiedName(char innerClassDelimiter) {
		if (references != null && !references.isEmpty()) {
			StringBuilder result = new StringBuilder();
			for(JvmTypeReference reference: references) {
				if (result.length() > 0) {
					result.append(getDelimiter());
				}
				result.append(reference.getQualifiedName(innerClassDelimiter));
			}
			return result.toString();
		}
		return super.getIdentifier();
	}
33477
public static int getCatalogIndexSize(Index index) {
        int indexSize = 0;
        String jsonstring = index.getExpressionsjson();

        if (jsonstring.isEmpty()) {
            indexSize = getSortedCatalogItems(index.getColumns(), "index").size();
        } else {
            try {
                indexSize = AbstractExpression.fromJSONArrayString(jsonstring, null).size();
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        return indexSize;
    }
1216024
public String convertIndexToString(int index)
    {
        String tempString = null;
        if ((index >= 0) && (index <= 9))
        {
            char value[] = new char[1];
            value[0] = (char)('0' + index);
            tempString = new String(value);         // 1 = '1'; 2 = '2'; etc...
        }
        else
            tempString = Constants.BLANK;
        return tempString;
    }
191833
private String unexternalizeImageRef(String ref) {
    String unexternalizedRef = ref;

    if (StringUtils.isNotEmpty(unexternalizedRef)) {

      // decode if required
      unexternalizedRef = decodeIfEncoded(unexternalizedRef);

      // TODO: implementation has to be aligned with MediaSource implementations!
      // remove default servlet extension that is needed for inline images in RTE
      unexternalizedRef = StringUtils.removeEnd(unexternalizedRef, "/" + JcrConstants.JCR_CONTENT + ".default");
      unexternalizedRef = StringUtils.removeEnd(unexternalizedRef, "/_jcr_content.default");
    }

    return unexternalizedRef;
  }
299544
public static String getTerm(IndexInput inTerm, Long ref) throws IOException {
    try {
      inTerm.seek(ref);
      return inTerm.readString();
    } catch (Exception e) {
      throw new IOException(e);
    }
  }
268000
private static String readAnnotationValue(String ref, TypeDef source, Property property) {
        return convertMap(ref, source, ((ClassRef)property.getTypeRef()).getDefinition());
    }
1195583
@javax.annotation.Nonnull
  public static String getIndent(@javax.annotation.Nonnull final String txt) {
    @javax.annotation.Nonnull final Matcher matcher = Pattern.compile("^\\s+").matcher(txt);
    return matcher.find() ? matcher.group(0) : "";
  }
37107
private Utf8Constant parseUtf8Constant(int index)
    throws IOException
  {
    int length = readShort();
    
    StringBuilder cb = new StringBuilder();

    for (int i = 0; i < length; i++) {
      int ch = read();

      if (ch < 0x80) {
        cb.append((char) ch);
      }
      else if ((ch & 0xe0) == 0xc0) {
        int ch2 = read();
        i++;

        cb.append((char) (((ch & 0x1f) << 6)+
                          (ch2 & 0x3f)));
      }
      else {
        int ch2 = read();
        int ch3 = read();
        i += 2;
      
        cb.append((char) (((ch & 0xf) << 12)+
                          ((ch2 & 0x3f) << 6) +
                          ((ch3 & 0x3f))));
      }
    }

    return new Utf8Constant(_class.getConstantPool(), index, cb.toString());
  }