Populates a field based on baseline and actual values.

@param container field container
@param target target field
@param baseline baseline field
@param actual actual field
11526
private void populateField(FieldContainer container, FieldType target, FieldType baseline, FieldType actual)
   {
      Object value = container.getCachedValue(actual);
      if (value == null)
      {
         value = container.getCachedValue(baseline);
      }
      container.set(target, value);
   }
1316186
private <T> void preFlightCheckFields(final T target) {

        ClassStreams.selfAndSupertypes(target.getClass())
                    .map(Class::getDeclaredFields)
                    .flatMap(Arrays::stream)
                    .filter(field -> field.getAnnotation(CliOptionGroup.class) != null)
                    .forEach(field -> {
                        field.setAccessible(true);
                        try {
                            preFlightCheck(field.get(target));
                        } catch (IllegalAccessException e) {
                            throw new RuntimeException(e);
                        }
                    });
    }
1175631
public void setBaselineStartText(int baselineNumber, String value)
   {
      set(selectField(TaskFieldLists.BASELINE_STARTS, baselineNumber), value);
   }
395229
public void init(Record record, BaseField fldRecordTarget, String fsTarget, BaseField fldTarget)
    {
        m_fldToCompare = fldTarget;
        m_fsRecordTarget = fsTarget;
        m_fldRecordTarget = fldRecordTarget;
        super.init(record);
    }
621872
public void setTarget(AstNode target) {
        // Don't throw exception if target is an "invalid" node type.
        // See mozilla/js/tests/js1_7/block/regress-350279.js
        if (target == null)
            throw new IllegalArgumentException("invalid target arg");
        this.target = target;
        target.setParent(this);
    }
217720
public void setBaselineFixedCostAccrual(int baselineNumber, AccrueType value)
   {
      set(selectField(TaskFieldLists.BASELINE_FIXED_COST_ACCRUALS, baselineNumber), value);
   }
804625
public void createContainer(String container) {

        ContainerController controller = this.platformContainers.get(container);
        if (controller == null) {

            // TODO make this configurable
            Profile p = new ProfileImpl();
            p.setParameter(Profile.PLATFORM_ID, PLATFORM_ID);
            p.setParameter(Profile.MAIN_HOST, MAIN_HOST);
            p.setParameter(Profile.MAIN_PORT, MAIN_PORT);
            p.setParameter(Profile.LOCAL_HOST, MAIN_HOST);
            int port = Integer.parseInt(MAIN_PORT);
            port = port + 1 + this.platformContainers.size();
            p.setParameter(Profile.LOCAL_PORT, Integer.toString(port));
            p.setParameter(Profile.CONTAINER_NAME, container);
            logger.fine("Creating container " + container + "...");
            ContainerController agentContainer = this.runtime
                    .createAgentContainer(p);
            this.platformContainers.put(container, agentContainer);
            logger.fine("Container " + container + " created successfully.");
        } else {
            logger.fine("Container " + container + " is already created.");
        }

    }
1064624
static public boolean isContainer(ReferenceType target) throws ClassNotFoundException {
        Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
        return subtypes2.isSubtype(target, COLLECTION_TYPE)
                || subtypes2.isSubtype(target, MAP_TYPE);
    }
699850
public static void addItemToList(final Object target, final String fieldName, final Object value) {
		try {
			List list = (List) getFieldValue(target, fieldName);
			list.add(value);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
622141
public static void populate(Object target, Map properties) throws BeanMappingException {
        BeanMap map = BeanMap.create(target.getClass());
        map.populate(target, properties);
    }
718107
function(target, noDefault) {
		var inst = this._getInst(target);
		if (inst && !inst.inline)
			this._setDateFromField(inst, noDefault);
		return (inst ? this._getDate(inst) : null);
	}
927065
private void applyMandatoryAction(final WComponent target, final boolean mandatory) {
		if (target instanceof Mandatable) {
			((Mandatable) target).setMandatory(mandatory);
		} else if (target instanceof Container) { // Apply to the Mandatable children
			Container cont = (Container) target;
			final int size = cont.getChildCount();

			for (int i = 0; i < size; i++) {
				WComponent child = cont.getChildAt(i);
				applyMandatoryAction(child, mandatory);
			}
		}
	}
599310
public void setBaselineWork(int baselineNumber, Duration value)
   {
      set(selectField(AssignmentFieldLists.BASELINE_WORKS, baselineNumber), value);
   }
1120640
public void populateMetadata(final Target target) {
        removeAllItems();
        if (target == null) {
            return;
        }
        selectedTargetId = target.getId();
        final List<TargetMetadata> targetMetadataList = targetManagement
                .findMetaDataByControllerId(PageRequest.of(0, MAX_METADATA_QUERY), target.getControllerId())
                .getContent();
        if (targetMetadataList != null && !targetMetadataList.isEmpty()) {
            targetMetadataList.forEach(this::setMetadataProperties);
        }
    }
1123617
public Date getBaselineEstimatedStart(int baselineNumber)
   {
      Object result = getCachedValue(selectField(TaskFieldLists.BASELINE_ESTIMATED_STARTS, baselineNumber));
      if (!(result instanceof Date))
      {
         result = null;
      }
      return (Date) result;
   }
951985
public void init(BaseField field)
    {
        super.init(field);
        m_BehaviorList = new Vector<BaseListener>();
        m_dependentListener = null;
    }
91535
public void setBaselineIdentities(java.util.Collection<PatchBaselineIdentity> baselineIdentities) {
        if (baselineIdentities == null) {
            this.baselineIdentities = null;
            return;
        }

        this.baselineIdentities = new com.amazonaws.internal.SdkInternalList<PatchBaselineIdentity>(baselineIdentities);
    }