Calculate the name of the input value.

@param inputPrefix a nullable prefix to prepend to the name if non-null and non-empty
@param inputMapper the name mapper
@param field the field containing the value
198534
public static String getInputValueName(
            @Nullable final String inputPrefix,
            @Nonnull final BiMap<String, String> inputMapper,
            @Nonnull final String field) {
        String name = inputMapper == null ? null : inputMapper.inverse().get(field);
        if (name == null) {
            if (inputMapper != null && inputMapper.containsKey(field)) {
                throw new RuntimeException("field in keys");
            }
            final String[] defaultValues = {
                    Values.TASK_DIRECTORY_KEY, Values.CLIENT_HTTP_REQUEST_FACTORY_KEY,
                    Values.TEMPLATE_KEY, Values.PDF_CONFIG_KEY, Values.SUBREPORT_DIR_KEY,
                    Values.OUTPUT_FORMAT_KEY, Values.JOB_ID_KEY
            };
            if (inputPrefix == null || Arrays.asList(defaultValues).contains(field)) {
                name = field;
            } else {
                name = inputPrefix.trim() +
                        Character.toUpperCase(field.charAt(0)) +
                        field.substring(1);
            }
        }
        return name;
    }
1138293
@VisibleForTesting
	static String createIncompletePartObjectNamePrefix(String objectName) {
		checkNotNull(objectName);

		final int lastSlash = objectName.lastIndexOf('/');
		final String parent;
		final String child;

		if (lastSlash == -1) {
			parent = "";
			child = objectName;
		} else {
			parent = objectName.substring(0, lastSlash + 1);
			child = objectName.substring(lastSlash + 1);
		}
		return parent + (child.isEmpty() ? "" : '_') + child + "_tmp_";
	}
1119648
private static void setInputMapUnsafe(Node node, InputMap<?> im) {
        getProperties(node).put(P_INPUTMAP, im);
    }
451010
public void init(BaseField field, String keyName)
    {
        super.init(field, keyName);
        
        m_bReadOnly = true;
    }
528168
public static void removeInputMap(Node node, InputMap<?> im) {
        // getInputMap calls init, so can use unsafe setter
        setInputMapUnsafe(node, getInputMap(node).without(im));
    }
1288695
public void startPrefixMapping(String prefix, String uri)
          throws SAXException
  {

    if (DEBUG)
      System.out.println("TransformerHandlerImpl#startPrefixMapping: "
                         + prefix + ", " + uri);

    if (m_contentHandler != null)
    {
      m_contentHandler.startPrefixMapping(prefix, uri);
    }
  }
446016
def _map_name(self, name, mapper):
        
        if mapper is not None:
            if isinstance(mapper, basestring):
                name = mapper + name
            try:
                name = mapper[name]
            except KeyError:
                pass
        return name
70325
public static String getMapFieldKeyType(Field field) {
        FieldType type = field.getType();
        if (!(type instanceof Message)) {
            throw new IllegalArgumentException(field.toString());
        }
        Message entryType = (Message) type;
        ScalarFieldType keyType = (ScalarFieldType) entryType.getField(MAP_ENTRY_KEY).getType();
        return ScalarFieldTypeUtil.getWrapperType(keyType);
    }
275097
private static void appendFirstField(
      Appendable out, String name, CharSequence value)
      throws IOException {
    appendFieldStart(out, name, true);
    out.append(value);
  }
591119
String getterNameFor(Element field) {
        String methodNamePrefix = "get";
        if (field.asType().getKind() == TypeKind.BOOLEAN) {
            methodNamePrefix = "is";
        }
        return methodNamePrefix + NameUtils.capitalize(field.getSimpleName().toString());
    }
37041
public static String getMapSetterName(Field field) {
        if (field.isMap()) {
            return SETTER_PREFIX + Formatter.toPascalCase(field.getName()) + MAP_SUFFIX;
        }
        throw new IllegalArgumentException(field.toString());
    }
2442
public void putField(final JBBPNumericField field) {
    JBBPUtils.assertNotNull(field, "Field must not be null");
    final JBBPNamedFieldInfo fieldName = field.getNameInfo();
    JBBPUtils.assertNotNull(fieldName, "Field name info must not be null");
    this.fieldMap.put(fieldName, field);
  }
331504
@Override
    protected void appendFieldStart( final StringBuffer    buffer,
                                     final String          fieldName )
    {
        appendFieldSeparator( buffer );

        if ( isUseFieldNames() && fieldName != null )
        {
            buffer.append( fieldName );

            for ( int ii = 0; ii < ( 18 - fieldName.length()); ii++ )
            {
                buffer.append( " " );
            }

            buffer.append( getFieldNameValueSeparator() );
        }
    }
1110634
private void initPrefixStatsField(String field) {
    if (!singlePositionPrefix.containsKey(field)) {
      singlePositionPrefix.put(field, new HashSet<String>());
    }
    if (!multiplePositionPrefix.containsKey(field)) {
      multiplePositionPrefix.put(field, new HashSet<String>());
    }
    if (!setPositionPrefix.containsKey(field)) {
      setPositionPrefix.put(field, new HashSet<String>());
    }
  }
592539
protected void setDefaultNameIfNone(StreamletNamePrefix prefix, Set<String> stageNames) {
    if (getName() == null) {
      setName(defaultNameCalculator(prefix, stageNames));
    }
    if (stageNames.contains(getName())) {
      throw new RuntimeException(String.format(
          "The stage name %s is used multiple times in the same topology", getName()));
    }
    stageNames.add(getName());
  }
306071
public boolean add(String inputValue) {
        String value = Normalizer.normalize(inputValue, Normalizer.NORMALIZE_LOWER);
        if (!contains(this.genericValues, value)) {
            addElement(value);
            return true;
        }
        return false;
    }
1333540
public static void parseInputParameterElement(Element inputParameterElement, IoMapping ioMapping) {
    String nameAttribute = inputParameterElement.attribute("name");
    if(nameAttribute == null || nameAttribute.isEmpty()) {
      throw new BpmnParseException("Missing attribute 'name' for inputParameter", inputParameterElement);
    }

    ParameterValueProvider valueProvider = parseNestedParamValueProvider(inputParameterElement);

    // add parameter
    ioMapping.addInputParameter(new InputParameter(nameAttribute, valueProvider));
  }