visiting the field.
165225
@Override
    public FieldVisitor visitField(int access, String name, String desc, String signature, Object defaultValue) {
        if (scanPolicyIsExternal() || !isDetailEnabled()) {
            visitEnd();
            throw VISIT_ENDED_DETAIL;
        }

        return fieldVisitor;
    }
831677
public static void doWithLocalFields(Class<?> clazz, FieldCallback fc) {
		for (Field field : getDeclaredFields(clazz)) {
			try {
				fc.doWith(field);
			}
			catch (IllegalAccessException ex) {
				throw new IllegalStateException("Not allowed to access field '" + field.getName() + "': " + ex);
			}
		}
	}
1051217
function(){
            var x = this.x,
                y = this.y,
                fieldRange = this.fovFieldRange,
                direction = this.fovDirection,
                maxViewDistance = this.fovMaxViewDistance;
            this.fov.update(x, y, fieldRange, direction, maxViewDistance, this);
        }
158899
@Override
  public void visitField(FieldNode gField) {
    PropertyNode owner = spec.getAst().getProperty(gField.getName());
    if (gField.isStatic()) return;

    Field field = new Field(spec, gField, fieldCount++);
    field.setShared(AstUtil.hasAnnotation(gField, Shared.class));
    field.setOwner(owner);
    spec.getFields().add(field);
  }
1040180
@Override
  public void visit(Visitable visitable) {
    if (isCommitable(visitable)) {
      ObjectUtils.setField(visitable, "lastModifiedBy", ((Auditable) visitable).getModifiedBy());
      ObjectUtils.setField(visitable, "lastModifiedOn", ((Auditable) visitable).getModifiedOn());
      ObjectUtils.setField(visitable, "lastModifiedWith", ((Auditable) visitable).getModifiedWith());
    }
  }
1200329
private AssignmentField selectField(AssignmentField[] fields, int index)
   {
      if (index < 1 || index > fields.length)
      {
         throw new IllegalArgumentException(index + " is not a valid field index");
      }
      return (fields[index - 1]);
   }
193429
def _read_field(self):
        '''
        
        '''
        ftype = self._input[self._pos]
        self._pos += 1

        reader = self.field_type_map.get(ftype)
        if reader:
            return reader(self)

        raise Reader.FieldError('Unknown field type %s', ftype)
1321714
def check(self, field):
        '''
        
        '''
        if self.permissions is None:
            return field.parent.permissions
        return self.permissions
199428
public void displayField()                  // init this field override for other value
    {
        if (m_vScreenField == null)
            return;
        for (Enumeration<Object> e = m_vScreenField.elements() ; e.hasMoreElements() ;) { 
            ScreenComponent sField = (ScreenComponent)e.nextElement();
            sField.fieldToControl();    // Display using the new value(s)
        }
    }
877739
@Override
    public void visit(PCM pcm) {
        for (Product product : pcm.getProducts()) {
            product.accept(this);
        }
    }
85620
def current(self, fields=None):
        """"""
        if fields is None:
            deferred_fields = self.deferred_fields
            if deferred_fields:
                fields = [
                    field for field in self.fields
                    if field not in deferred_fields
                ]
            else:
                fields = self.fields

        return dict((f, self.get_field_value(f)) for f in fields)
244195
private ProjectField selectField(ProjectField[] fields, int index)
   {
      if (index < 1 || index > fields.length)
      {
         throw new IllegalArgumentException(index + " is not a valid field index");
      }
      return (fields[index - 1]);
   }
793010
public function importField($field, $field_name = null)
    {
        $field = $this->model->hasElement($field);
        if (!$field) {
            return;
        }
        /** @type Field $field */
        if (!$field->editable()) {
            return;
        }

        if ($field_name === null) {
            $field_name = $this->_unique($this->owner->elements, $field->short_name);
        }
        $field_type = $this->getFieldType($field);
        $field_caption = $field->caption();

        $this->field_associations[$field_name] = $field;

        if ($field->listData() || $field instanceof Field_Reference) {
            if ($field_type == 'Line') {
                $field_type = 'DropDown';
            }
        }

        $form_field = $this->owner->addField($field_type, $field_name, $field_caption);
        $form_field->set($field->get());

        $field_placeholder = $field->placeholder() ?: $field->emptyText() ?: null;
        if ($field_placeholder) {
            $form_field->setAttr('placeholder', $field_placeholder);
        }

        if ($field->hint()) {
            $form_field->setFieldHint($field->hint());
        }

        if ($field->listData()) {
            /** @type Form_Field_ValueList $form_field */
            $a = $field->listData();
            $form_field->setValueList($a);
        }
        if ($msg = $field->mandatory()) {
            $form_field->validateNotNULL($msg);
        }

        if ($field instanceof Field_Reference || $field_type == 'reference') {
            $form_field->setModel($field->getModel());
        }
        if ($field->theModel) {
            $form_field->setModel($field->theModel);
        }
        if ($form_field instanceof Form_Field_ValueList && !$field->mandatory()) {
            /** @type string $text */
            $text = $field->emptyText();
            $form_field->setEmptyText($text);
        }

        if ($field->onField()) {
            call_user_func($field->onField(), $form_field);
        }

        return $form_field;
    }
612392
public void setupSFields()
    {
        Record record = this.getMainRecord();
        BaseField field = record.getField(DBConstants.MAIN_FIELD);
        if (field == record.getCounterField())
            this.addColumn(field);
        super.setupSFields();
    }
1247047
protected void visitSetTraceObjectField() {
        visitFieldInsn(
                       PUTSTATIC,
                       classAdapter.getClassInternalName(),
                       classAdapter.getTraceObjectFieldName(),
                       classAdapter.getTraceObjectFieldType().getDescriptor());
    }
1047115
def flag_field(self, move_x, move_y):
        """"""
        field_status = self.info_map[move_y, move_x]

        # a questioned or undiscovered field
        if field_status != 9 and (field_status == 10 or field_status == 11):
            self.info_map[move_y, move_x] = 9
590750
public function importField($field, $field_name = null)
    {
        $field = $this->model->hasElement($field);
        /** @type \atk4\data\Field $field */

        if (!$field || !$field->isEditable() || $field->isHidden()) {
            return;
        }

        if ($field_name === null) {
            $field_name = $this->_unique($this->owner->elements, $field->short_name);
        }
        $this->field_associations[$field_name] = $field;

        $field_type = $this->getFieldType($field);
        $field_caption = isset($field->ui['caption']) ? $field->ui['caption'] : null;

        // add form field
        $form_field = $this->owner->addField($field_type, $field_name, $field_caption);
        $form_field->set($field->get());

        // set model for hasOne field
        if ($ref_field = $this->model->hasRef($field->short_name)) {
            $form_field->setModel($ref_field->getModel());
        }

        // set model for enum field
        if (isset($field->enum)) {

            $list = isset($field->ui['valueList'])
                ? $field->ui['valueList']
                : array_combine($field->enum, $field->enum);

            if ($form_field instanceof Form_Field_Checkbox) {
                $list = array_reverse($list);
            }


            $form_field->setValueList($list);
        }

        // field value is mandatory
        if ($field->mandatory) {
            $form_field->validateNotNULL($field->mandatory);
        }

        // form field placeholder
        $placeholder = isset($field->ui['placeholder']) ? $field->ui['placeholder'] : /*$field->emptyText() ?:*/ null;
        if ($placeholder) {
            $form_field->setAttr('placeholder', $placeholder);
        }

        // form field hint
        if (isset($field->ui['hint'])) {
            $form_field->setFieldHint($field->ui['hint']);
        }

        // set empty text option for dropdown type form fields if model field is not mandatory
        if ($form_field instanceof Form_Field_ValueList && !$field->mandatory) {
            /** @type string $text */
            //$text = $field->emptyText();
            //$form_field->setEmptyText($text);
            $form_field->setEmptyText('- no value -');
        }

        return $form_field;
    }