Processes the property overrides for the embedded objects, if any.
768163
private void processPropertyOverrides() {
    PropertyOverrides propertyOverrides = entityClass.getAnnotation(PropertyOverrides.class);
    if (propertyOverrides == null) {
      return;
    }
    PropertyOverride[] propertyOverridesArray = propertyOverrides.value();
    for (PropertyOverride propertyOverride : propertyOverridesArray) {
      entityMetadata.putPropertyOverride(propertyOverride);
    }
  }
1003197
private void processProperties() {
        state = true;
        try {
            exporterServiceFilter = getFilter(exporterServiceFilterProperty);
        } catch (InvalidFilterException invalidFilterException) {
            LOG.debug("The value of the Property " + FILTER_EXPORTERSERVICE_PROPERTY + " is invalid,"
                    + " the recuperation of the Filter has failed. The instance gonna stop.", invalidFilterException);
            state = false;
            return;
        }

        try {
            exportDeclarationFilter = getFilter(exportDeclarationFilterProperty);
        } catch (InvalidFilterException invalidFilterException) {
            LOG.debug("The value of the Property " + FILTER_EXPORTDECLARATION_PROPERTY + " is invalid,"
                    + " the recuperation of the Filter has failed. The instance gonna stop.", invalidFilterException);
            state = false;
            return;
        }
    }
1160114
private void processGeneratedProperties(
			Serializable id,
			Object entity,
			Object[] state,
			SharedSessionContractImplementor session,
			GenerationTiming matchTiming) {

		Tuple tuple = getFreshTuple( EntityKeyBuilder.fromPersister( this, id, session ), session );
		saveSharedTuple( entity, tuple, session );

		if ( tuple == null || tuple.getSnapshot().isEmpty() ) {
			throw log.couldNotRetrieveEntityForRetrievalOfGeneratedProperties( getEntityName(), id );
		}

		int propertyIndex = -1;
		for ( NonIdentifierAttribute attribute : getEntityMetamodel().getProperties() ) {
			propertyIndex++;
			final ValueGeneration valueGeneration = attribute.getValueGenerationStrategy();
			if ( isReadRequired( valueGeneration, matchTiming ) ) {
				Object hydratedState = gridPropertyTypes[propertyIndex].hydrate( tuple, getPropertyAliases( "", propertyIndex ), session, entity );
				state[propertyIndex] = gridPropertyTypes[propertyIndex].resolve( hydratedState, session, entity );
				setPropertyValue( entity, propertyIndex, state[propertyIndex] );
			}
		}
	}
108565
public void processUpdates(FacesContext context) {

        if (context == null) {
            throw new NullPointerException();
        }
        if (!isSubmitted()) {
            return;
        }

        // Process all facets and children of this component
        Iterator kids = getFacetsAndChildren();
        while (kids.hasNext()) {
            UIComponent kid = (UIComponent) kids.next();
            kid.processUpdates(context);
        }

    }
714154
public function process()
    {
        parent::process();

        $flydown = $this->getCompositeWidget('flydown');
        if ($flydown->value == '') {
            $this->value = null;
        } else {
            $this->value = (int) $flydown->value;
        }
    }
1243537
protected void processRemoterElements(TypeSpec.Builder classBuilder, ElementVisitor elementVisitor, MethodSpec.Builder methodBuilder) {
        processRemoterElements(classBuilder, getRemoterInterfaceElement(), 0, elementVisitor, methodBuilder);
    }
519185
@Override
    public void processElement(Wrapper<Element> elementWrapper) {
        Element element = elementWrapper.getContent();
        element.setAttributes(getSortedAttributes(element));
    }
1146427
function processShorthandPropertyConfiguration () {

  // Fetch extensions implementing .processShorthandPropertyConfiguration(...) method
  let extensions = _.filter(this.extensions, (extension) => {
    return extension.implemented.processShorthandPropertyConfiguration;
  });

  // Create a proxy .processShorthandPropertyConfiguration(...) method
  this.processShorthandPropertyConfiguration =  (propertyConfiguration) => {
    // Execute all extensions' .processShorthandPropertyConfiguration(...) method and update configuration
    _.forEach(extensions, (extension) => {
      propertyConfiguration = extension.processShorthandPropertyConfiguration(propertyConfiguration);
    });
    // Return updated configuration
    return propertyConfiguration;
  };

}
471233
function afterChangeProcessed ({ entity, properties }) {

  // Fetch extensions implementing .afterChangeProcessed(...) method
  let extensions = _.filter(this.extensions, (extension) => {
    return extension.implemented.afterChangeProcessed;
  });

  // Create a proxy .afterChangeProcessed(...) method
  this.afterChangeProcessed =  (event) => {
    // Execute all extensions' .afterChangeProcessed(...) method
    _.forEach(extensions, (extension) => {
      extension.afterChangeProcessed(entity, properties, event);
    });
  };

}
835247
private void processEmitMethods() {
    ElementFilter
        .methodsIn(component.getEnclosedElements())
        .stream()
        .filter(method -> hasAnnotation(method, Emit.class))
        .filter(method -> !hasAnnotation(method, JsMethod.class))
        .forEach(this::exposeExistingJavaMethodToJs);
  }
563544
function (name, value) {
            var overriddenMember = this._extend.prototype[name];
            if (undefined !== overriddenMember) {
                this._checkOverridenMember(value, overriddenMember);
            }
        }
1208666
function processProperty(item, property, value) {
    if (value !== null && typeof value === "object") {
        processObjectProperty(item, property, value);
        return;
    }
    if (!item.hasOwnProperty(property)) {
        item[property] = null;
    }

    //Boolean type
    if (value === false && item[property] == null) {
        delete item.$changedProps[property];
        return;
    }

    //Float type
    if (Number.isFinite(item[property])) {
        item[property] = item[property] + "";
    }

    //Other types
    // console.log("OTHER TYPES, value:", value);
    if (item[property] !== value) {
        item.$changedProps[property] = value;
    } else {
        delete item.$changedProps[property];
    }
}
842703
private void processFields() throws CoreException {

        final Class<?> currentClass = this.getClass();

        // Parse view properties
        for (final Field f : currentClass.getDeclaredFields()) {

            // Only Node and Animation properties are eligible
            if (Node.class.isAssignableFrom(f.getType()) || Animation.class.isAssignableFrom(f.getType())) {

                // If a property was private, it must set to accessible = false after processing action
                boolean needToHide = false;
                // For private properties, set them accessible temporary
                if (!f.isAccessible()) {
                    f.setAccessible(true);
                    needToHide = true;
                }

                // Process all existing annotation for the current field
                processAnnotations(f);

                // Reset the property visibility
                if (needToHide && f.isAccessible()) {
                    f.setAccessible(false);
                }
            }
        }
    }
520355
private static void applyOverrides() {
        // Get the appropriate InputStream to read overrides from, if any.
        InputStream stream = getContentTypesPropertiesStream();
        if (stream == null) {
            return;
        }

        try {
            try {
                // Read the properties file...
                Properties overrides = new Properties();
                overrides.load(stream);
                // And translate its mapping to ours...
                for (Map.Entry<Object, Object> entry : overrides.entrySet()) {
                    String extension = (String) entry.getKey();
                    String mimeType = (String) entry.getValue();
                    add(mimeType, extension);
                }
            } finally {
                stream.close();
            }
        } catch (IOException ignored) {
        }
    }
1208791
protected void processProperties(Properties properties) throws ParseException
    {
        if (properties == null)
        {
            return;
        }

        for (Enumeration<?> e = properties.propertyNames(); e.hasMoreElements();)
        {
            String option = e.nextElement().toString();
            
            Option opt = options.getOption(option);
            if (opt == null)
            {
                throw new UnrecognizedOptionException("Default option wasn't defined", option);
            }
            
            // if the option is part of a group, check if another option of the group has been selected
            OptionGroup group = options.getOptionGroup(opt);
            boolean selected = group != null && group.getSelected() != null;
            
            if (!cmd.hasOption(option) && !selected)
            {
                // get the value from the properties instance
                String value = properties.getProperty(option);

                if (opt.hasArg())
                {
                    if (opt.getValues() == null || opt.getValues().length == 0)
                    {
                        try
                        {
                            opt.addValueForProcessing(value);
                        }
                        catch (RuntimeException exp) //NOPMD
                        {
                            // if we cannot add the value don't worry about it
                        }
                    }
                }
                else if (!("yes".equalsIgnoreCase(value)
                        || "true".equalsIgnoreCase(value)
                        || "1".equalsIgnoreCase(value)))
                {
                    // if the value is not yes, true or 1 then don't add the
                    // option to the CommandLine
                    continue;
                }

                cmd.addOption(opt);
                updateRequiredOptions(opt);
            }
        }
    }
50723
@Override
    public final void processComponent(String propertyName, final JComponent component) {

        final AbstractOverlayHandler overlayHandler = this.createOverlayHandler(propertyName, component);

        // Wait until has parent and overlay is correctly installed
        final PropertyChangeListener wait4ParentListener = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent e) {

                final JComponent targetComponent = overlayHandler.getTargetComponent();
                final JComponent overlay = overlayHandler.getOverlay();

                // Install overlay
                final int position = AbstractOverlayFormComponentInterceptor.this.getPosition();
                final Boolean success = AbstractOverlayFormComponentInterceptor.this.//
                        getOverlayService().installOverlay(targetComponent, overlay, position, null);

                if (success) {
                    targetComponent.removePropertyChangeListener(//
                            AbstractOverlayFormComponentInterceptor.ANCESTOR_PROPERTY, this);
                }
            }
        };

        component.addPropertyChangeListener(//
                AbstractOverlayFormComponentInterceptor.ANCESTOR_PROPERTY, wait4ParentListener);
    }
627624
void process() {
        fixImports();
        if (insertRegion != null) {
            data.ensureImport(BeanDefinition.class);
            if (properties.size() > 0) {
                data.ensureImport(PropertyDefinition.class);
            }
            removeOld();
            if (data.isRootClass() && data.isExtendsDirectBean()) {
                data.ensureImport(DirectBean.class);
            }
            generateMeta();
            generateSerializationVersionId();
            generatePropertyChangeSupportField();
            generateHashCodeField();
            generateFactory();
            generateImmutableBuilderMethod();
            generateArgBasedConstructor();
            generateBuilderBasedConstructor();
            generateMetaBean();
            generateGettersSetters();
            generateSeparator();
            generateImmutableToBuilder();
            generateClone();
            generateEquals();
            generateHashCode();
            generateToString();
            generateMetaClass();
            generateBuilderClass();
            resolveImports();
            resolveIndents();
        }
    }