Returns the constant map index to constant
@param constant
@return
978173
public final int getConstantIndex(float constant)
    {
        for (ConstantInfo ci : listConstantInfo(ConstantFloat.class))
        {
            ConstantFloat ic = (ConstantFloat) ci;
            if (Float.compare(constant, ic.getConstant()) == 0)
            {
                return constantPoolIndexMap.get(ci);
            }
        }
        return -1;
    }
631111
@Override
    public void ldc(int constant) throws IOException
    {
        int index = subClass.resolveConstantIndex(constant);
        super.ldc(index);
    }
1143902
private StringConstant parseStringConstant(int index)
    throws IOException
  {
    int stringIndex = readShort();

    return new StringConstant(_class.getConstantPool(), index, stringIndex);
  }
546403
public static SanitizedContent constantJs(@CompileTimeConstant final String constant) {
    return fromConstant(constant, ContentKind.JS, Dir.LTR);
  }
902924
public IntegerConstant getIntegerByValue(int value)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof IntegerConstant))
        continue;

      IntegerConstant integerEntry = (IntegerConstant) entry;

      if (integerEntry.getValue() == value)
        return integerEntry;
    }

    return null;
  }
1362893
public final int getConstantIndex(long constant)
    {
        for (ConstantInfo ci : listConstantInfo(ConstantLong.class))
        {
            ConstantLong ic = (ConstantLong) ci;
            if (constant == ic.getConstant())
            {
                return constantPoolIndexMap.get(ci);
            }
        }
        return -1;
    }
140455
public void visitConstantExpression(ConstantExpression expression) {
        final String constantName = expression.getConstantName();
        if (controller.isStaticConstructor() || constantName == null) {
            controller.getOperandStack().pushConstant(expression);
        } else {
            controller.getMethodVisitor().visitFieldInsn(GETSTATIC, controller.getInternalClassName(),constantName, BytecodeHelper.getTypeDescription(expression.getType()));
            controller.getOperandStack().push(expression.getType());
        }
    }
817256
public final String get(final String pkey) {
    try {
      // Replace "." with "_" in the key to match what ConstantsImplCreator does.
      return pkey == null ? null : messages.getString(pkey.replace(".", "_"));
    } catch (final MissingResourceException e) {
      return null;
    }
  }
476579
public static String getName(EnumConstant constant) {
        String name = constant.getName();
        String underscored = Formatter.toUnderscoreCase(name);
        return Formatter.toUpperCase(underscored);
    }
132090
public static Matrix constant(int rows, int columns, double constant) {
        return DenseMatrix.constant(rows, columns, constant);
    }
350798
public Set<String> getConstantNames() {
        return constants.stream()
                .map(EnumConstant::getName)
                .collect(Collectors.toSet());
    }
536962
public OWLIndividual translate(ObjectConstant constant) {
		if (constant instanceof IRIConstant)
			return dataFactory.getOWLNamedIndividual(IRI.create(((IRIConstant)constant).getIRI().getIRIString()));

		else /*if (constant instanceof BNode)*/ 
			return dataFactory.getOWLAnonymousIndividual(((BNode) constant).getName());
	}
957413
public DataSetBuilder value(String column, Object constant) {
    return set(column, new ConstantFiller<Object>(constant)); 
  }
268217
public static SanitizedContent constantUri(@CompileTimeConstant final String constant) {
    return fromConstant(constant, ContentKind.URI, Dir.LTR);
  }
1303224
private Map<? extends String, ? extends Parameter> buildConstParamMap() {
		Map<String, Parameter> paramMap = new HashMap<>();
		for (String className : constantClassNames) {
			if (StringUtils.isNotBlank(className)) {
				try {
					Class<?> targetClass = Class.forName(className, true, Thread.currentThread()
							.getContextClassLoader());
					makeConstParamMap(paramMap, targetClass);
				} catch (ClassNotFoundException ex) {
					LOG.error(ex.getMessage(), ex);
				}
			}
		}
		return paramMap;
	}
100275
private String getSignatureFromNameAndType(int index) throws InvalidClassFileFormatException {
        checkConstantPoolIndex(index);
        Constant constant = constantPool[index];
        checkConstantTag(constant, IClassConstants.CONSTANT_NameAndType);
        return getUtf8String((Integer) constant.data[1]);
    }
182816
def getConstants(ast):
    '''
    
    '''
    constants_order = sorted( ast.allOf('constant') )
    constants = [convertConstantToKind(a.value, a.astKind)
                 for a in constants_order]
    return constants_order, constants