causing the field to be persisted and overwritten on the load method.
5171
@SuppressWarnings({"ConstantConditions"})
    @Override
    public void load() {
        Class<? extends RepositoryBrowser> rb = repositoryBrowser;
        super.load();
        if (repositoryBrowser!=rb) { // XStream may overwrite even the final field.
            try {
                Field f = SCMDescriptor.class.getDeclaredField("repositoryBrowser");
                f.setAccessible(true);
                f.set(this,rb);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                LOGGER.log(WARNING, "Failed to overwrite the repositoryBrowser field",e);
            }
        }
    }
311230
protected boolean fieldIsUninitialized( Field field )
    {
        try
        {
            return field != null && field.get( this ) == null;
        }
        catch ( IllegalAccessException e )
        {
            _log.error( "Error initializing field " + field.getName() + " in " + getDisplayName(), e );
            return false;
        }
    }
913168
public function onCreating()
    {
        // Delete any other encoding jobs for the same parent and field
        self::where('encodable_type', '=', $this->encodable_type)
            ->where('encodable_id', '=', $this->encodable_id)
            ->where('encodable_attribute', '=', $this->encodable_attribute)
            ->delete();

        // Default values
        $this->status = 'pending';
    }
19476
public void writeFieldInit()
    {
        String strClassName;
        Record recClassInfo = this.getMainRecord();
        strClassName = recClassInfo.getField(ClassInfo.CLASS_NAME).getString();
        if (this.readThisMethod(strClassName))
            this.writeThisMethod(CodeType.THICK);
        else
            this.writeThisMethod(CodeType.THICK);
    }
571188
protected function overwriteExistingField($name)
    {
        if ($this->fields->isEmpty()) {
            return;
        }

        $this->fields = $this->fields->filter(
            function (Field $field) use ($name) {
                return $field->getName() != $name;
            }
        );
    }
1164857
@Override
    public void updateGeneratedFields(boolean performEditionChecking) throws RepositoryResourceCreationException {
        super.updateGeneratedFields(performEditionChecking);
        if (getType() == ResourceType.INSTALL) {
            generateAppliesToFilterInfo();
        }
    }
379890
protected void initializeField( Field field, Object instance )
    {
        if ( instance != null )
        {
            if ( _log.isTraceEnabled() )
            {
                _log.trace( "Initializing field " + field.getName() + " in " + getDisplayName() + " with " + instance );
            }
            
            try
            {
                field.set( this, instance );
            }
            catch ( IllegalArgumentException e )
            {
                _log.error( "Could not set field " + field.getName() + " on " + getDisplayName() +
                            "; instance is of type " + instance.getClass().getName() + ", field type is "
                            + field.getType().getName() );
            }
            catch ( IllegalAccessException e )
            {
                _log.error( "Error initializing field " + field.getName() + " in " + getDisplayName(), e );
            }
        }
    }
382762
function(field, value) {
        if (field in this) {
            if (this.get(field) !== value && !([
                null,
                undefined
            ].indexOf(this.get(field)) > -1 && [
                null,
                undefined
            ].indexOf(value) > -1)) {
                if (CRUD.EntityManager.entities[this.getType()].autoSerialize.indexOf(field) > -1) {
                    if (JSON.stringify(this.get(field)) != JSON.stringify(value)) {
                        this.__dirtyValues__[field] = value;
                    }
                } else {
                    this.__dirtyValues__[field] = value;
                }
            }
        } else {
            CRUD.log('Could not find field \'' + field + '\' in \'' + this.getType() + '\' (for set)');
        }
    }
485348
public void killLoadsOfField(XField field) {
        if (!REDUNDANT_LOAD_ELIMINATION) {
            return;
        }
        HashSet<AvailableLoad> killMe = new HashSet<>();
        for (AvailableLoad availableLoad : getAvailableLoadMap().keySet()) {
            if (availableLoad.getField().equals(field)) {
                if (RLE_DEBUG) {
                    System.out.println("KILLING Load of " + availableLoad + " in " + this);
                }
                killMe.add(availableLoad);
            }
        }
        killAvailableLoads(killMe);
    }
279533
public void saveField(BaseField field)
    {
        String strFieldName = field.getFieldName();   // Fieldname only
        String strData = field.getString();
        this.setProperty(strFieldName, strData);
    }
368854
private void marshalEmbeddedFields() {
    for (EmbeddedMetadata embeddedMetadata : entityMetadata.getEmbeddedMetadataCollection()) {
      if (embeddedMetadata.getStorageStrategy() == StorageStrategy.EXPLODED) {
        marshalWithExplodedStrategy(embeddedMetadata, entity);
      } else {
        ValueBuilder<?, ?, ?> embeddedEntityBuilder = marshalWithImplodedStrategy(embeddedMetadata,
            entity);
        if (embeddedEntityBuilder != null) {
          entityBuilder.set(embeddedMetadata.getMappedName(), embeddedEntityBuilder.build());
        }
      }
    }

  }
295425
public void removeCacheField()
    {
        try {
            Record record = this.getOwner();
            Object objKey = record.getHandle(DBConstants.OBJECT_ID_HANDLE);
            m_hsCache.remove(objKey);
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
    }
381760
public void putField(VariableElement field) throws IOException
    {
        if (field.getModifiers().contains(Modifier.STATIC))
        {
            throw new IllegalArgumentException(field+" is static");
        }
        int index = subClass.resolveFieldIndex(field);
        putfield(index);
    }
433714
public void markAsVisited(final Field field) {
        if (field.getAnnotation(Requires.class) != null) {
            this.dependantsInJson.add(field);
        }

        final Field dependant = this.requirementToDependantMap.get(field.getName());
        if (dependant != null) {
            this.dependantToRequirementsMap.remove(dependant, field.getName());
        }
    }
444750
private boolean doRedundantLoadElimination() {
        if (!REDUNDANT_LOAD_ELIMINATION) {
            return false;
        }

        XField xfield = loadedFieldSet.getField(handle);
        if (xfield == null) {
            return false;
        }

        // TODO: support two-slot fields
        return !(xfield.getSignature().equals("D") || xfield.getSignature().equals("J"));
    }
296583
function updateUserDataField(userId, data, overwrite, callback) {
        return _updateUserObjectField(userId, ['data'], data, overwrite)
            .then(function (userData) {
                return userData.data;
            })
            .nodeify(callback);
    }
1162715
private void writeField(FieldType field, Object value) throws IOException
   {
      String fieldName = field.name().toLowerCase();
      writeField(fieldName, field.getDataType(), value);
   }