Put a numeric field into map.

@param field a field to be added into map or replace already exists one, it
must not be null
@throws NullPointerException if the field is null or if it is an anonymous
field
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);
  }
1216665
public void addUniqueField(int field) {
		if (this.uniqueFields == null) {
			this.uniqueFields = new HashSet<FieldSet>();
		}
		this.uniqueFields.add(new FieldSet(field));
	}
690590
public Expression add(String field, JsonNode value) {
        try {
            ((ObjectNode) node).set(field, value);
            return this;
        } catch (ClassCastException e) {
            throw new RuntimeException("Object node expected while adding " + field);
        }
    }
667107
public void getField(VariableElement field) throws IOException
    {
        if (field.getModifiers().contains(Modifier.STATIC))
        {
            throw new IllegalArgumentException(field+" is static");
        }
        int index = subClass.resolveFieldIndex(field);
        getfield(index);
    }
690639
public void put(String key, Integer value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindLong(compiledStatementBindIndex++, (int) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.INTEGER);
	}
853656
protected void addFieldInto(int[] values, DurationFieldType field, int value) {
        int index = indexOf(field);
        if (index == -1) {
            if (value != 0 || field == null) {
                throw new IllegalArgumentException(
                    "Period does not support field '" + field + "'");
            }
        } else {
            values[index] = FieldUtils.safeAdd(values[index], value);
        }
    }
181887
public MapBuilder add(String fieldName, boolean include, @Nullable String value) {
        if (include && value != null) {
            map.put(getFieldName(fieldName), value);
        }
        return this;
    }
28960
private void processSimpleField(Field field) {
    PropertyMetadata propertyMetadata = IntrospectionUtils.getPropertyMetadata(field);
    if (propertyMetadata != null) {
      metadata.putPropertyMetadata(propertyMetadata);
    }
  }
148393
@SuppressWarnings("unchecked")
    private static void setMapParam(Field field, List<?> values) {
        try {
            // Find Map method: put(Object, Object)
            Class<?> fieldClass = field.getType();
            Method addMethod = fieldClass.getMethod("put", Object.class, Object.class);
            
            // Add each map key/value to field value
            for (Object subParam : values) {
                if (subParam instanceof Map) {
                    Map<String, ?> map = (Map<String, ?>)subParam;
                    for (String key : map.keySet()) {
                        Object value = map.get(key);
                        if (value instanceof List) {
                            // Contains a single element, which is a key/value map
                            value = ((List<?>)value).get(0);
                        }
                        addMethod.invoke(field.get(config), key, value);
                    }
                } else {
                    throw new RuntimeException("Unexpected collection parameter type for '" + field.getName() + ":" + subParam);
                }
            }
        } catch (NoSuchMethodException  | IllegalArgumentException | InvocationTargetException | IllegalAccessException e) {
            throw new RuntimeException("Error setting configuration parameter '" + field.getName() + "'", e);
        }
    }
631611
public void put(int index, long value) {
        if(desc.get(index) != Cursor.FIELD_TYPE_INTEGER) {
            throw new IllegalArgumentException("Inserting an integer, but expecting " + getTypeName(desc.get(index)));
        }
        this.values.add(index, value);
    }
907467
@Override
    public BigIntegerMapper build(String field) {
        return new BigIntegerMapper(field, column, validated, digits);
    }
1043240
public void put(String key, String value) {
		if (this.compiledStatement != null) {
			if (value==null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);				
			} else {				
				compiledStatement.bindString(compiledStatementBindIndex++, (String) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.STRING);
	}
767151
public AnnotatedTypeBuilder<X> addToField(Field field, Annotation annotation) {
       if (fields.get(field) == null) {
           fields.put(field, new AnnotationBuilder());
       }
       fields.get(field).add(annotation);
       return this;
   }
599415
public CMAContentType addField(CMAField field) {
    if (fields == null) {
      fields = new ArrayList<CMAField>();
    }

    fields.add(field);
    return this;
  }
739964
public void addFields(GenericField[] fields)
	{
		for (int i=0; i < fields.length;i++)
		{
			this.fieldMap.put(fields[i].getFieldName(), fields[i]);
		}
	}
981675
public Notification setFieldValue(String field, @Nullable String value) {
    fields.put(field, value);
    return this;
  }
1328589
private void populate(Field field, Object target, Map<String, Option> options) {
        field.setAccessible(true);
        try {
            final Object fieldValue = field.getType().newInstance();
            injectParameters(fieldValue, options);
            field.set(target, fieldValue);
        } catch (IllegalAccessException | InstantiationException e) {
            throw new RuntimeException("Could not populate field " + field, e);
        }
    }