Create a DiffBuilder from all kind of types supported by {@link Input#from(Object)}.

@see DiffBuilder
@param control the expected reference document.
186224
public static DiffBuilder compare(final Object control) {
        final Source controlSource = getSource(control);
        return new DiffBuilder(controlSource);
    }
617347
public void createControlAdapter()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "createControlAdapter");
    controlAdapter = new ForeignBus(messageProcessor, this);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "createControlAdapter", controlAdapter);
  }
1293727
function(containerBlock) {
    var clauseBlock = containerBlock.nextConnection.targetBlock();
    var i = 1;
    while (clauseBlock) {
      switch (clauseBlock.type) {
        case 'controls_if_elseif':
          var inputIf = this.getInput('IF' + i);
          var inputDo = this.getInput('DO' + i);
          clauseBlock.valueConnection_ =
              inputIf && inputIf.connection.targetConnection;
          clauseBlock.statementConnection_ =
              inputDo && inputDo.connection.targetConnection;
          i++;
          break;
        case 'controls_if_else':
          var inputDo = this.getInput('ELSE');
          clauseBlock.statementConnection_ =
              inputDo && inputDo.connection.targetConnection;
          break;
        default:
          throw 'Unknown block type.';
      }
      clauseBlock = clauseBlock.nextConnection &&
          clauseBlock.nextConnection.targetBlock();
    }
  }
1250677
private void setDateControl(DateControl control) {
        requireNonNull(control);

        control.addEventFilter(RequestEvent.REQUEST,
                evt -> addEvent(evt, LogEntryType.REQUEST_EVENT));
        control.addEventFilter(LoadEvent.LOAD,
                evt -> addEvent(evt, LogEntryType.LOAD_EVENT));

        // listen to calendars

        for (Calendar calendar : control.getCalendars()) {
            calendar.addEventHandler(calendarListener);
        }

        ListChangeListener<? super Calendar> l = change -> {
            while (change.next()) {
                if (change.wasAdded()) {
                    for (Calendar c : change.getAddedSubList()) {
                        c.addEventHandler(calendarListener);
                    }
                } else if (change.wasRemoved()) {
                    for (Calendar c : change.getRemoved()) {
                        c.removeEventHandler(calendarListener);
                    }
                }
            }
        };

        control.getCalendars().addListener(l);

        Bindings.bindBidirectional(datePicker.valueProperty(),
                control.dateProperty());
        Bindings.bindBidirectional(todayPicker.valueProperty(),
                control.todayProperty());
        Bindings.bindBidirectional(timeField.valueProperty(),
                control.timeProperty());
        timeField.setDisable(false);
    }
971608
function(type, parameters, args) {

            parameters = parameters || {};
            args = args || {};

            var __type = parse_type(type, parameters, args),
                constructor = resolve_ctr(__type, parameters);

            if (!constructor)
                throw new TypeError('Type ' + __type + ' not registered!');

            for(var prop in parameters)
                if (parameters.hasOwnProperty(prop) && prop[0] === '$')
                    args[prop.substr(1)] = parameters[prop];

            // create object

            var new_control = (constructor.is_constructor) // constructor or factory method ?
                ? new constructor(parameters, args)
                : constructor(parameters, args);

            // reflect after creation if control only
            if (typeof new_control === 'object' && '__type' in new_control)
                new_control.raise('type');

            return new_control;
        }
915922
public String generateDiff(String objectType, Object from, Object to) {
        GenericObject fromGenericObject = from == null ? null : genericObjectFramework.serialize(from, objectType);
        GenericObject toGenericObject = to == null ? null : genericObjectFramework.serialize(to, objectType);

        return generateDiff(fromGenericObject, toGenericObject);
    }
60560
public static ModelDiff createModelDiff(OpenEngSBModel updated, String completeModelId,
            EngineeringDatabaseService edbService, EDBConverter edbConverter) {
        EDBObject queryResult = edbService.getObject(completeModelId);
        OpenEngSBModel old = edbConverter.convertEDBObjectToModel(updated.getClass(), queryResult);
        ModelDiff diff = new ModelDiff(old, updated);
        calculateDifferences(diff);
        return diff;
    }
183502
public void createControlAdapter()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "createControlAdapter");
    
    controlAdapter = new MQLinkQueuePoint(destinationHandler.getMessageProcessor(), this);
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "createControlAdapter");
  }
112131
private ComparisonState compareNodeLists(Iterable<Node> controlSeq,
                                             final XPathContext controlContext,
                                             Iterable<Node> testSeq,
                                             final XPathContext testContext) {
        ComparisonState chain = new OngoingComparisonState();

        Iterable<Map.Entry<Node, Node>> matches =
            getNodeMatcher().match(controlSeq, testSeq);
        List<Node> controlList = Linqy.asList(controlSeq);
        List<Node> testList = Linqy.asList(testSeq);
        Set<Node> seen = new HashSet<Node>();
        for (Map.Entry<Node, Node> pair : matches) {
            final Node control = pair.getKey();
            seen.add(control);
            final Node test = pair.getValue();
            seen.add(test);
            int controlIndex = controlList.indexOf(control);
            int testIndex = testList.indexOf(test);

            controlContext.navigateToChild(controlIndex);
            testContext.navigateToChild(testIndex);
            try {
                chain =
                    chain.andThen(new Comparison(ComparisonType.CHILD_NODELIST_SEQUENCE,
                                                 control, getXPath(controlContext),
                                                 Integer.valueOf(controlIndex), getParentXPath(controlContext),
                                                 test, getXPath(testContext),
                                                 Integer.valueOf(testIndex), getParentXPath(testContext)))
                    .andThen(new DeferredComparison() {
                            @Override
                            public ComparisonState apply() {
                                return compareNodes(control, controlContext,
                                                    test, testContext);
                            }
                        });
            } finally {
                testContext.navigateToParent();
                controlContext.navigateToParent();
            }
        }

        return chain.andThen(new UnmatchedControlNodes(controlList, controlContext, seen, testContext))
            .andThen(new UnmatchedTestNodes(testList, testContext, seen, controlContext));
    }
246612
@Override
    public void createControlAdapter()
    {
        if (tc.isEntryEnabled())
            SibTr.entry(tc, "createControlAdapter");
        controlAdapter = new ForeignDestination(messageProcessor, this);
        if (tc.isEntryEnabled())
            SibTr.exit(tc, "createControlAdapter", controlAdapter);
    }
558639
@SuppressWarnings("unchecked")  // The type is always ControlFlowGraph<Node>
  public ControlFlowGraph<Node> getControlFlowGraph() {
    ControlFlowGraph<Node> result;
    Object o = cfgs.peek();
    if (o instanceof Node) {
      Node cfgRoot = (Node) o;
      ControlFlowAnalysis cfa = new ControlFlowAnalysis(compiler, false, true);
      cfa.process(null, cfgRoot);
      result = cfa.getCfg();
      cfgs.pop();
      cfgs.push(result);
    } else {
      result = (ControlFlowGraph<Node>) o;
    }
    return result;
  }
152304
protected void copyControlOutBound(int srcTaskId,
                                     HeronTuples.AckTuple control,
                                     boolean isSuccess) {
    for (HeronTuples.RootId rootId : control.getRootsList()) {
      HeronTuples.AckTuple t =
          HeronTuples.AckTuple.newBuilder().
              addRoots(rootId).
              setAckedtuple(control.getAckedtuple()).
              build();

      if (isSuccess) {
        tupleCache.addAckTuple(srcTaskId, rootId.getTaskid(), t);
      } else {
        tupleCache.addFailTuple(srcTaskId, rootId.getTaskid(), t);
      }
    }
  }
729614
static protected Point2D newControl (Point2D start, Point2D ctrl, Point2D end) {
        Point2D.Double newCtrl = new Point2D.Double();
        newCtrl.x = 2 * ctrl.getX() - (start.getX() + end.getX()) / 2;
        newCtrl.y = 2 * ctrl.getY() - (start.getY() + end.getY()) / 2;
        return newCtrl;
    }
577677
function(containerBlock) {
    var clauseBlock = containerBlock.nextConnection.targetBlock();
    // Count number of inputs.
    this.elseifCount_ = 0;
    this.elseCount_ = 0;
    var valueConnections = [null];
    var statementConnections = [null];
    var elseStatementConnection = null;
    while (clauseBlock) {
      switch (clauseBlock.type) {
        case 'controls_if_elseif':
          this.elseifCount_++;
          valueConnections.push(clauseBlock.valueConnection_);
          statementConnections.push(clauseBlock.statementConnection_);
          break;
        case 'controls_if_else':
          this.elseCount_++;
          elseStatementConnection = clauseBlock.statementConnection_;
          break;
        default:
          throw 'Unknown block type.';
      }
      clauseBlock = clauseBlock.nextConnection &&
          clauseBlock.nextConnection.targetBlock();
    }
    this.updateShape_();
    // Reconnect any child blocks.
    for (var i = 1; i <= this.elseifCount_; i++) {
      Blockly.Mutator.reconnect(valueConnections[i], this, 'IF' + i);
      Blockly.Mutator.reconnect(statementConnections[i], this, 'DO' + i);
    }
    Blockly.Mutator.reconnect(elseStatementConnection, this, 'ELSE');
  }
135184
public Control createRequestControl(Class<?>[] paramTypes, Object[] params) {
		Constructor<?> constructor = ClassUtils.getConstructorIfAvailable(requestControlClass, paramTypes);
		if (constructor == null) {
			throw new IllegalArgumentException("Failed to find an appropriate RequestControl constructor");
		}

		Control result = null;
		try {
			result = (Control) constructor.newInstance(params);
		}
		catch (Exception e) {
			ReflectionUtils.handleReflectionException(e);
		}

		return result;
	}
170702
function (control) {
				var properties = control.getMetadata().getAllProperties();
				var propertiesBindingData = Object.create(null);

				for (var key in properties) {
					if (properties.hasOwnProperty(key) && control.getBinding(key)) {
						propertiesBindingData[key] = Object.create(null);
						propertiesBindingData[key].path = control.getBinding(key).getPath();
						propertiesBindingData[key].value = control.getBinding(key).getValue();
						propertiesBindingData[key].type = control.getMetadata().getProperty(key).getType().getName ? control.getMetadata().getProperty(key).getType().getName() : '';
						propertiesBindingData[key].mode = control.getBinding(key).getBindingMode();
						propertiesBindingData[key].model = this._getModelFromContext(control, key);
					}
				}

				return propertiesBindingData;
			}
994260
public static void defineDefaultConstructor(ClassVisitor cv, TypeInfo ownerType) {
    CodeBuilder mg = new CodeBuilder(Opcodes.ACC_PUBLIC, NULLARY_INIT, null, cv);
    mg.visitCode();
    Label start = mg.mark();
    Label end = mg.newLabel();
    LocalVariable thisVar = LocalVariable.createThisVar(ownerType, start, end);
    thisVar.gen(mg);
    mg.invokeConstructor(OBJECT.type(), NULLARY_INIT);
    mg.returnValue();
    mg.mark(end);
    thisVar.tableEntry(mg);
    mg.endMethod();
  }