Create a {@link NavigationResult} using the given {@link UICommand} type as the target.
328942
public static final NavigationResult navigateTo(Class<? extends UICommand> next)
   {
      if (next == null)
      {
         return null;
      }
      NavigationResultBuilder builder = navigationBuilder();
      builder.add(next);
      return builder.build();
   }
242179
public static void associateCommand(String commandName, BaseUIComponent component, BaseUIComponent commandTarget) {
        getCommand(commandName, true).bind(component, commandTarget);
    }
1151938
public final ControlBrowseEnd createNewControlBrowseEnd() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createNewControlBrowseEnd");
    ControlBrowseEnd msg = null;
    try {
      msg = new ControlBrowseEndImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createNewControlBrowseEnd");
    return msg;
  }
1270632
private Result executeResultUpdate(Result cmd) {

        long   id         = cmd.getResultId();
        int    actionType = cmd.getActionType();
        Result result     = sessionData.getDataResult(id);

        if (result == null) {
            return Result.newErrorResult(Error.error(ErrorCode.X_24501));
        }

        Object[]        pvals     = cmd.getParameterData();
        Type[]          types     = cmd.metaData.columnTypes;
        StatementQuery  statement = (StatementQuery) result.getStatement();
        QueryExpression qe        = statement.queryExpression;
        Table           baseTable = qe.getBaseTable();
        int[]           columnMap = qe.getBaseTableColumnMap();

        sessionContext.rowUpdateStatement.setRowActionProperties(actionType,
                baseTable, types, columnMap);

        Result resultOut =
            executeCompiledStatement(sessionContext.rowUpdateStatement, pvals);

        return resultOut;
    }
117667
def create(cls, selection, config, **kwargs):
        """"""

        if selection['target'] is not None:
            return cls.create_from_source(selection['target'],
                                          config, **kwargs)
        else:
            target_skydir = wcs_utils.get_target_skydir(selection)
            return cls.create_from_position(target_skydir, config, **kwargs)
130016
private CmsCreatableListItem makeNavigationLevelItem() {

        CmsNewResourceInfo typeInfo = getController().getData().getNewNavigationLevelElementInfo();
        CmsListItemWidget widget = new CmsListItemWidget(typeInfo);
        CmsCreatableListItem listItem = new CmsCreatableListItem(widget, typeInfo, NewEntryType.regular);
        listItem.initMoveHandle(CmsSitemapView.getInstance().getTree().getDnDHandler());
        return listItem;
    }
232089
function CommandController(descriptor){

	Object.defineProperties(this, {
		name: {
			get: function(){
				return descriptor.name;
			}
		},
		description: {
			get: function(){
				return descriptor.description;
			}
		},
		CommandError: {
			get: function(){
				return LocalCommandError;
			}
		},
		RuntimeCommandError: {
			get: function (){
				return LocalRuntimeCommandError;
			}
		},
		errorLvl: {
			get: function(){
				return Object.create(CONST.errorLvl);
			}
		}
	});

	function LocalCommandError(message, level){
		CommandError.call(this, message, descriptor.name, level);
	}
	LocalCommandError.prototype = Object.create(CommandError.prototype);

	function LocalRuntimeCommandError(message){
		RuntimeCommandError.call(this, message, descriptor.name);
	}
	LocalRuntimeCommandError.prototype = Object.create(RuntimeCommandError.prototype);
}
1245563
public static <R> MethodResult<R> success(R result) {
        return new MethodResult<>(result, null, false);
    }
1129872
function create(type, constructor) {
  return function projection() {
    var p = constructor();

    p.type = type;

    p.path = geoPath().projection(p);

    p.copy = p.copy || function() {
      var c = projection();
      projectionProperties.forEach(function(prop) {
        if (p.hasOwnProperty(prop)) c[prop](p[prop]());
      });
      c.path.pointRadius(p.path.pointRadius());
      return c;
    };

    return p;
  };
}
503923
private DockerCommand createCommand(Class<? extends DockerCommand> commandType) {
        try {
            return commandType.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new BeanCreationException("Failed to create Docker command of type: " + commandType, e);
        }
    }
949613
private void animateView(final View target, final int type) {
        if(ANIMATION_EXPAND==type&&target.getVisibility()==VISIBLE){
            return;
        }
        if(ANIMATION_COLLAPSE==type&&target.getVisibility()!=VISIBLE){
            return;
        }
        if(mDefaultAnimExecutor !=null){
            mDefaultAnimExecutor.executeAnim(target,type);
        }

    }
818542
function() {
			this._createSettingsCommand();
			this._createGotoLineCommnand();
			this._createFindCommnand();
			this._createBlameCommand();
			this._createDiffCommand();
			this._createShowTooltipCommand();
			this._createUndoStackCommands();
			this._createClipboardCommands();
			this._createDelimiterCommands();
			this._createEncodingCommand();
			this._createFormatterCommand();
			this._createSaveCommand();
			this._createOpenFolderCommand();
			this._createOpenRecentCommand();
			this._createSwitchWorkspaceCommand();
			this._createReferencesCommand();
			this._createOpenDeclCommand();
			
			return this._createEditCommands();
		}
723182
public final ControlDecision createNewControlDecision() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createNewControlDecision");
    ControlDecision msg = null;
    try {
      msg = new ControlDecisionImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createNewControlDecision");
    return msg;
  }
1198474
private NavigationCase getOutcomeNavigationCase (FacesContext facesContext, String fromAction, String outcome)
    {
        String implicitViewId = null;
        boolean includeViewParams = false;
        int index;
        boolean isRedirect = false;
        String queryString = null;
        NavigationCase result = null;
        String viewId = facesContext.getViewRoot() != null ? facesContext.getViewRoot().getViewId() : null;
        //String viewIdToTest = outcome;
        StringBuilder viewIdToTest = SharedStringBuilder.get(facesContext, OUTCOME_NAVIGATION_SB);
        viewIdToTest.append(outcome);
        
        // If viewIdToTest contains a query string, remove it and set queryString with that value.
        index = viewIdToTest.indexOf ("?");
        if (index != -1)
        {
            queryString = viewIdToTest.substring (index + 1);
            //viewIdToTest = viewIdToTest.substring (0, index);
            viewIdToTest.setLength(index);
            
            // If queryString contains "faces-redirect=true", set isRedirect to true.
            if (queryString.indexOf ("faces-redirect=true") != -1)
            {
                isRedirect = true;
            }
            
            // If queryString contains "includeViewParams=true" or 
            // "faces-include-view-params=true", set includeViewParams to true.
            if (queryString.indexOf("includeViewParams=true") != -1 
                    || queryString.indexOf("faces-include-view-params=true") != -1)
            {
                includeViewParams = true;
            }
        }
        
        // If viewIdToTest does not have a "file extension", use the one from the current viewId.
        index = viewIdToTest.indexOf (".");
        if (index == -1)
        {
            if (viewId != null)
            {
                index = viewId.lastIndexOf(".");

                if (index != -1)
                {
                    //viewIdToTest += viewId.substring (index);
                    viewIdToTest.append(viewId.substring (index));
                }
            }
            else
            {
                // This case happens when for for example there is a ViewExpiredException,
                // and a custom ExceptionHandler try to navigate using implicit navigation.
                // In this case, there is no UIViewRoot set on the FacesContext, so viewId 
                // is null.

                // In this case, it should try to derive the viewId of the view that was
                // not able to restore, to get the extension and apply it to
                // the implicit navigation.
                String tempViewId = getNavigationHandlerSupport().calculateViewId(facesContext);
                if (tempViewId != null)
                {
                    index = tempViewId.lastIndexOf(".");
                    if(index != -1)
                    {
                        viewIdToTest.append(tempViewId.substring (index));
                    }
                }
            }
            if (log.isLoggable(Level.FINEST))
            {
                log.finest("getOutcomeNavigationCase -> viewIdToTest: " + viewIdToTest);
            } 
        }

        // If viewIdToTest does not start with "/", look for the last "/" in viewId.  If not found, simply prepend "/".
        // Otherwise, prepend everything before and including the last "/" in viewId.
        
        //if (!viewIdToTest.startsWith ("/") && viewId != null)
        boolean startWithSlash = false;
        if (viewIdToTest.length() > 0)
        {
            startWithSlash = (viewIdToTest.charAt(0) == '/');
        } 
        if (!startWithSlash) 
        {
            index = -1;
            if( viewId != null )
            {
               index = viewId.lastIndexOf ("/");
            }
            
            if (index == -1)
            {
                //viewIdToTest = "/" + viewIdToTest;
                viewIdToTest.insert(0,"/");
            }
            
            else
            {
                //viewIdToTest = viewId.substring (0, index + 1) + viewIdToTest;
                viewIdToTest.insert(0, viewId, 0, index + 1);
            }
        }
        
        // Apply normalization 
        String viewIdToTestString = null;
        boolean applyNormalization = false;
        
        for (int i = 0; i < viewIdToTest.length()-1; i++)
        {
            if (viewIdToTest.charAt(i) == '.' &&
                viewIdToTest.charAt(i+1) == '/')
            {
                applyNormalization = true; 
                break;
            }
        }
        if (applyNormalization)
        {
            viewIdToTestString = FilenameUtils.normalize(viewIdToTest.toString(), true);
        }
        else
        {
            viewIdToTestString = viewIdToTest.toString();
        }
        
        // Call ViewHandler.deriveViewId() and set the result as implicitViewId.
        try
        {
            implicitViewId = facesContext.getApplication().getViewHandler().deriveViewId (
                    facesContext, viewIdToTestString);
        }
        
        catch (UnsupportedOperationException e)
        {
            // This is the case when a pre-JSF 2.0 ViewHandler is used.
            // In this case, the default algorithm must be used.
            // FIXME: I think we're always calling the "default" ViewHandler.deriveViewId() algorithm and we don't
            // distinguish between pre-JSF 2.0 and JSF 2.0 ViewHandlers.  This probably needs to be addressed.
        }
        
        if (implicitViewId != null)
        {
            // Append all params from the queryString
            // (excluding faces-redirect, includeViewParams and faces-include-view-params)
            Map<String, List<String>> params = null;
            if (queryString != null && !"".equals(queryString))
            {
                //String[] splitQueryParams = queryString.split("&(amp;)?"); // "&" or "&amp;"
                String[] splitQueryParams = AMP_PATTERN.split(queryString); // "&" or "&amp;"
                params = new HashMap<String, List<String>>(splitQueryParams.length, 
                        (splitQueryParams.length* 4 + 3) / 3);
                for (String queryParam : splitQueryParams)
                {
                    String[] splitParam = StringUtils.splitShortString(queryParam, '=');
                    if (splitParam.length == 2)
                    {
                        // valid parameter - add it to params
                        if ("includeViewParams".equals(splitParam[0])
                                || "faces-include-view-params".equals(splitParam[0])
                                || "faces-redirect".equals(splitParam[0]))
                        {
                            // ignore includeViewParams, faces-include-view-params and faces-redirect
                            continue;
                        }
                        List<String> paramValues = params.get(splitParam[0]);
                        if (paramValues == null)
                        {
                            // no value for the given parameter yet
                            paramValues = new ArrayList<String>();
                            params.put(splitParam[0], paramValues);
                        }
                        paramValues.add(splitParam[1]);
                    }
                    else
                    {
                        // invalid parameter
                        throw new FacesException("Invalid parameter \"" + 
                                queryParam + "\" in outcome " + outcome);
                    }
                }
            }
            
            // Finally, create the NavigationCase.
            result = new NavigationCase (viewId, fromAction, outcome, null, 
                    implicitViewId, params, isRedirect, includeViewParams);
        }
        
        return result;
    }
1232934
private void buildUI() {
		// Create the layout:
		VLayout layout = new VLayout();
		layout.setWidth100();
		layout.setHeight100();

		logicalOperatorRadio = new RadioGroupItem("logicalOperator");
		logicalOperatorRadio.setValueMap(I18nProvider.getSearch().radioOperatorOr(), I18nProvider.getSearch()
				.radioOperatorAnd());
		logicalOperatorRadio.setVertical(false);
		logicalOperatorRadio.setRequired(true);
		logicalOperatorRadio.setAlign(Alignment.LEFT);
		logicalOperatorRadio.setWidth(250);
		logicalOperatorRadio.setShowTitle(false);

		HLayout optionLayout = new HLayout();
		optionLayout.setHeight(50);
		optionLayout.setWidth100();

		VLayout leftLayout = new VLayout();
		leftLayout.setAlign(Alignment.LEFT);

		HLayout layerLayout = new HLayout();
		layerLayout.setWidth(420);
		DynamicForm layerForm = new DynamicForm();
		layerForm.setHeight(30);
		if (manualLayerSelection) {
			layerSelect = new SelectItem();
			layerSelect.setTitle(I18nProvider.getSearch().labelLayerSelected());
			layerSelect.setWidth(250);
			layerSelect.setHint(I18nProvider.getSearch().labelNoLayerSelected());
			((SelectItem) layerSelect).setShowHintInField(true);
			layerSelect.addChangedHandler(new ChangedHandler() {

				public void onChanged(ChangedEvent event) {
					String layerLabel = (String) event.getValue();
					for (Layer<?> vLayer : mapModel.getLayers()) {
						if (vLayer.getLabel().equals(layerLabel)) {
							setLayer((VectorLayer) vLayer);
						}
					}
				}
			});
			mapModel.addMapModelChangedHandler(new MapModelChangedHandler() {

				public void onMapModelChanged(MapModelChangedEvent event) {
					fillLayerSelect();
				}
			});
			// needed if map is already loaded !
			fillLayerSelect();
		} else {
			mapModel.addLayerSelectionHandler(new LayerSelectionHandler() {

				public void onDeselectLayer(LayerDeselectedEvent event) {
					empty();
					updateLabelTitle(I18nProvider.getSearch().labelNoLayerSelected());
				}

				public void onSelectLayer(LayerSelectedEvent event) {
					if (event.getLayer() instanceof VectorLayer) {
						setLayer((VectorLayer) event.getLayer());
						if (event.getLayer() != null) {
							updateLabelTitle(event.getLayer().getLabel());
						}
					}
				}
			});
			layerSelect = new BlurbItem();
			layerSelect.setShowTitle(true);
			layerSelect.setTitle(I18nProvider.getSearch().labelLayerSelected());
			layerSelect.setWidth(250);
			layerSelect.setValue("<b>" + I18nProvider.getSearch().labelNoLayerSelected() + "</b>");
		}
		layerForm.setFields(layerSelect);
		layerLayout.addMember(layerForm);

		leftLayout.addMember(layerLayout);
		DynamicForm logicalForm = new DynamicForm();
		logicalForm.setAutoWidth();
		logicalForm.setLayoutAlign(Alignment.CENTER);
		logicalForm.setFields(logicalOperatorRadio);
		leftLayout.setWidth(420);
		leftLayout.addMember(logicalForm);

		VLayout rightLayout = new VLayout();
		rightLayout.setLayoutAlign(VerticalAlignment.TOP);
		rightLayout.setMargin(5);
		rightLayout.setMembersMargin(5);
		rightLayout.setWidth(100);
		searchButton = new IButton(I18nProvider.getSearch().btnSearch());
		searchButton.setIcon(WidgetLayout.iconFind);
		searchButton.setWidth(100);
		searchButton.setDisabled(true);
		searchButton.addClickHandler(new ClickHandler() {

			public void onClick(ClickEvent event) {
				search();
			}
		});
		resetButton = new IButton(I18nProvider.getSearch().btnReset());
		resetButton.setIcon(WidgetLayout.iconUndo);
		resetButton.setWidth(100);
		resetButton.setDisabled(true);
		resetButton.addClickHandler(new ClickHandler() {

			public void onClick(ClickEvent event) {
				empty();
			}
		});
		rightLayout.addMember(searchButton);
		rightLayout.addMember(resetButton);

		optionLayout.addMember(leftLayout);
		optionLayout.addMember(new LayoutSpacer());
		optionLayout.addMember(rightLayout);

		// Create a header for the criterionStack:
		HLayout headerLayout = new HLayout();
		headerLayout.setHeight(26);
		headerLayout.setStyleName(STYLE_HEADER_BAR);
		HTMLPane attrHeader = new HTMLPane();
		attrHeader.setStyleName(STYLE_SEARCH_HEADER);
		attrHeader.setContents("Attribute");
		attrHeader.setWidth(140);
		HTMLPane operatorHeader = new HTMLPane();
		operatorHeader.setContents("Operator");
		operatorHeader.setWidth(140);
		operatorHeader.setStyleName(STYLE_SEARCH_HEADER);
		HTMLPane valueHeader = new HTMLPane();
		valueHeader.setContents("Value");
		valueHeader.setStyleName(STYLE_SEARCH_HEADER);

		criterionStack = new VStack();
		criterionStack.setAlign(VerticalAlignment.TOP);
		headerLayout.addMember(attrHeader);
		headerLayout.addMember(operatorHeader);
		headerLayout.addMember(valueHeader);
		criterionStack.addMember(headerLayout);

		buttonStack = new VStack();
		buttonStack.setWidth(70);
		buttonStack.setAlign(VerticalAlignment.TOP);
		HTMLPane btnHeader = new HTMLPane();
		btnHeader.setStyleName(STYLE_HEADER_BAR);
		btnHeader.setWidth(70);
		btnHeader.setHeight(26);
		buttonStack.addMember(btnHeader);

		HLayout searchGrid = new HLayout();
		searchGrid.addMember(criterionStack);
		searchGrid.addMember(buttonStack);
		searchGrid.setBorder("1px solid lightgrey");

		layout.addMember(optionLayout);
		layout.addMember(searchGrid);
		addChild(layout);
	}
347721
public CommandArgs<K, V> add(CommandType type) {

        LettuceAssert.notNull(type, "CommandType must not be null");
        singularArguments.add(ProtocolKeywordArgument.of(type));
        return this;
    }
463884
public static Intent newNavigationIntent(String address) {
        StringBuilder sb = new StringBuilder();
        sb.append("google.navigation:q=");

        String addressEncoded = Uri.encode(address);
        sb.append(addressEncoded);

        return new Intent(Intent.ACTION_VIEW, Uri.parse(sb.toString()));
    }