Remove the given {@code annotation} from the list of annotations for the given {@code field}.
167728
public static void removeAnnotation(JVar field, JAnnotationUse annotation) {
		List<JAnnotationUse> annotations = getPrivateField(field, "annotations");
		annotations.remove(annotation);
	}
1098654
public AnnotatedTypeBuilder<X> addToField(AnnotatedField<? super X> field, Annotation annotation) {
       return addToField(field.getJavaMember(), annotation);
   }
211801
public function removeField($field)
    {
        foreach ($this->fieldsets as $fieldset) {
            if ($fieldset->hasField($field)) {
                unset($fieldset[$field]);
            }
        }
        return $this;
    }
759599
function deleteAnnotation() {
  if (!overlay) { return; }

  let annotationId = overlay.getAttribute('data-target-id');
  let nodes = document.querySelectorAll(`[data-pdf-annotate-id="${annotationId}"]`);
  let svg = overlay.parentNode.querySelector('svg.annotationLayer');
  let { documentId } = getMetadata(svg);

  [...nodes].forEach((n) => {
    n.parentNode.removeChild(n);
  });
  
  PDFJSAnnotate.getStoreAdapter().deleteAnnotation(documentId, annotationId);

  destroyEditOverlay();
}
230172
public void removeField(final JavaClassSource targetClass, final Field<JavaClassSource> field)
   {
      PropertySource<JavaClassSource> property = targetClass.getProperty(field.getName());
      property.setMutable(false).setAccessible(false);
      targetClass.removeProperty(property);
      updateToString(targetClass);
   }
924140
public final void clear(int field)
    {
        if (areFieldsVirtuallySet) {
            computeFields();
        }
        fields[field] = 0;
        stamp[field] = UNSET;
        isTimeSet = areFieldsSet = areAllFieldsSet = areFieldsVirtuallySet = false;
    }
1052229
private void filterRelevantFields(List<Field> fields) {
        Iterator<Field> fieldIterator = fields.iterator();

        while (fieldIterator.hasNext()) {
            Field field = fieldIterator.next();
            if (Modifier.isStatic(field.getModifiers())) {
                fieldIterator.remove();
            }
        }
    }
816126
protected void removeAnnotation(String annotIdentifier) {
		if (m_annotations != null) {
			Iterator it = m_annotations.iterator();
			while (it.hasNext()) {
				Annotation ann = (Annotation) it.next();
				if (ann.getIdentifier().equals(annotIdentifier))
					it.remove();
			}
		}
	}
217603
public void clearFields() {
		this.requiredFields = NO_FIELDS;
		this.optionalFields = NO_FIELDS;

		this.textFields = Collections.emptyMap();

		removeAll();
		validate();
	}
1217727
public void markAsVisited(final Field field) {
        final OneOf oneOfAnnotation = field.getAnnotation(OneOf.class);
        if (oneOfAnnotation != null) {
            final OneOfGroup oneOfGroup = this.mapping.get(oneOfAnnotation.value());
            oneOfGroup.satisfiedBy.add(new OneOfSatisfier(field, false));
        }
        final CanSatisfyOneOf canSatisfyOneOf = field.getAnnotation(CanSatisfyOneOf.class);
        if (canSatisfyOneOf != null) {
            final OneOfGroup oneOfGroup = this.mapping.get(canSatisfyOneOf.value());
            oneOfGroup.satisfiedBy.add(new OneOfSatisfier(field, true));
        }
    }
448729
public void clearListField(String fieldName) {
		Object val = getFieldValue(fieldName, true); // internal
		if (val instanceof List<?>)
			((List<?>)val).clear();
		else if (val != null && val.getClass().isArray()) {
			DOField fld = getDomainObjectType().getFieldByName(fieldName);
			String ctn = fld.getComponentTypeName();
			Class<?> clazz;
			try {
				clazz = getDomainObjectType().getDomainModel().getClassForName(ctn);
				tryInitListOrArray(null, fld, clazz);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(e);
			}
		} else {
			if (!getDomainObjectType().getFieldByName(fieldName).isListOrArray())
				throw new RuntimeException("field: [" + fieldName + "] is neither list nor array");
			if (val == null)
				throw new RuntimeException("list or array field: [" + fieldName + "] is null");
		}
	}
814461
private com.google.code.siren4j.component.Field annotationToField(Siren4JActionField fieldAnno,
                                                                      EntityContext context)
            throws Siren4JException {
        FieldBuilder builder = FieldBuilder.newInstance();
        builder.setName(fieldAnno.name());
        if (ArrayUtils.isNotEmpty(fieldAnno.fieldClass())) {
            builder.setComponentClass(fieldAnno.fieldClass());
        }
        if(StringUtils.isNotBlank(fieldAnno.title())) {
            builder.setTitle(fieldAnno.title());
        }
        if (fieldAnno.max() > -1) {
            builder.setMax(fieldAnno.max());
        }
        if (fieldAnno.min() > -1) {
            builder.setMin(fieldAnno.min());
        }
        if (fieldAnno.maxLength() > -1) {
            builder.setMaxLength(fieldAnno.maxLength());
        }
        if (StringUtils.isNotBlank(fieldAnno.step())) {
            builder.setStep(fieldAnno.step());
        }
        if (fieldAnno.required()) {
            builder.setRequired(true);
        }
        if (StringUtils.isNotBlank(fieldAnno.pattern())) {
            builder.setPattern(fieldAnno.pattern());
        }
        if (StringUtils.isNotBlank(fieldAnno.type())) {
            builder.setType(FieldType.valueOf(fieldAnno.type().toUpperCase()));
        }
        if (StringUtils.isNotBlank(fieldAnno.value())) {
            builder.setValue(handleTokenReplacement(fieldAnno.value(), context));
        }
        if (ArrayUtils.isNotEmpty(fieldAnno.options())) {
            for (Siren4JFieldOption optAnno : fieldAnno.options()) {
                FieldOption opt = new FieldOption();
                if (StringUtils.isNotBlank(optAnno.title())) {
                    opt.setTitle(optAnno.title());
                }
                if (StringUtils.isNotBlank(optAnno.value())) {
                    opt.setValue(handleTokenReplacement(optAnno.value(), context));
                }
                opt.setOptionDefault(optAnno.optionDefault());
                if (ArrayUtils.isNotEmpty(optAnno.data())) {
                    for (Siren4JOptionData data : optAnno.data()) {
                        opt.putData(data.key(), handleTokenReplacement(data.value(), context));
                    }
                }
                builder.addOption(opt);
            }
        }
        if (StringUtils.isNotBlank(fieldAnno.optionsURL())) {
            builder.setOptionsURL(resolveUri(fieldAnno.optionsURL(), context, false));
        }
        if (StringUtils.isNotBlank(fieldAnno.placeHolder())) {
            builder.setPlaceholder(fieldAnno.placeHolder());
        }
        if(ArrayUtils.isNotEmpty(fieldAnno.metaData())) {
            Map<String, String> metaData = new HashMap();
            for(Siren4JMetaData mdAnno : fieldAnno.metaData()) {
                metaData.put(mdAnno.key(), handleTokenReplacement(mdAnno.value(), context));
            }
            builder.setMetaData(metaData);
        }
        return builder.build();
    }
793756
private void removeField(I_CmsFormField field) {

        String id = field.getId();
        m_fields.remove(id);
        // *not* removing the field id from m_editedFields, because a field of the same id may
        // be added later
        m_fieldsByModelId.remove(field.getModelId(), field);
        field.unbind();
    }
911084
@Nonnull
    public PMessageBuilder<T, F> clear(@Nonnull F field) {
        return clear(field.getId());
    }
1246609
public void clearValues(String fieldName) {
        Utils.require(!Utils.isEmpty(fieldName), "fieldName");
        m_valueMap.remove(fieldName);
        m_valueRemoveMap.remove(fieldName);
    }
1217420
function(annotation) {
			if (!annotation) { return; }
			var index = this._getAnnotationIndex(annotation);
			if (index < 0) { return; }
			annotation._annotationModel = null;
			var e = {
				type: "Changed", //$NON-NLS-0$
				removed: this._annotations.splice(index, 1),
				added: [],
				changed: []
			};
			this.onChanged(e);
		}
1317324
public long remove(final String... fields) {
        return doWithJedis(new JedisCallable<Long>() {
            @Override
            public Long call(Jedis jedis) {
                return jedis.hdel(getKey(), fields);
            }
        });
    }