Handles the arguments, which have been passed to the fragment.
351681
private void handleArguments() {
        Bundle arguments = getArguments();

        if (arguments != null) {
            handleShowRestoreDefaultsButtonArgument(arguments);
            handleRestoreDefaultsButtonTextArgument(arguments);
        }
    }
826813
private void swapFragments()
	{
		final Fragment fragment = view;
		view.replaceWith(edit);
		view = edit;
		edit = fragment;
	}
638124
def args(self, args):
        '''
        '''
        self._args = args
        self._logger.log('debug', 'Args set to {}'.format(args))
913501
public void setArguments(List<AstNode> arguments) {
        if (arguments == null) {
            this.arguments = null;
        } else {
            if (this.arguments != null)
                this.arguments.clear();
            for (AstNode arg : arguments) {
                addArgument(arg);
            }
        }
    }
259767
def prepare_params(self):
        
        if self.options.resolve_fragment:
            self.fragment_name = self.node.fragment_name.resolve(self.context)
        else:
            self.fragment_name = str(self.node.fragment_name)
            # Remove quotes that surround the name
            for char in '\'\"':
                if self.fragment_name.startswith(char) or self.fragment_name.endswith(char):
                    if self.fragment_name.startswith(char) and self.fragment_name.endswith(char):
                        self.fragment_name = self.fragment_name[1:-1]
                        break
                    else:
                        raise ValueError('Number of quotes around the fragment name is incoherent')

        self.expire_time = self.get_expire_time()

        if self.options.versioning:
            self.version = force_bytes(self.get_version())

        self.vary_on = [template.Variable(var).resolve(self.context) for var in self.node.vary_on]
551736
private void validateArgumentValues()  {
        namedArgumentDefinitions = validatePluginArgumentValues(); // trim the list of plugin-derived argument definitions before validation
        for (final NamedArgumentDefinition argumentDefinition : namedArgumentDefinitions) {
            argumentDefinition.validateValues(this);
        }
        if (positionalArgumentDefinition != null) {
            positionalArgumentDefinition.validateValues(this);
        }
    }
1286803
def _handle_argument_separator(self):
        """"""
        self._context ^= contexts.ARGUMENT_NAME
        self._context |= contexts.ARGUMENT_DEFAULT
        self._emit(tokens.ArgumentSeparator())
967839
protected boolean handleOption (String arg, String nextArg, OptionArgument handler)
        throws YarrgParseException
    {
        checkState(handler != null, "No such option '" + arg + "'");
        if (handler instanceof ValueOptionArgument) {
            checkState(nextArg != null, "'" + arg + "' requires a value following it");
            parse(nextArg, handler);
            return true;
        } else if (handler instanceof HelpArgument) {
            throw new YarrgHelpException(_usage, _detail);
        } else {
            parse("true", handler);
            return false;
        }
    }
1225772
private void parseArgs(String[] args) {
        int index = 0;
        while (index < args.length) {
            String name = args[index];
            if (name.equals("-?") || name.equalsIgnoreCase("-help")) {
                usage();
            }
            if (name.charAt(0) != '-') {
                m_logger.error("Unrecognized parameter: {}", name);
                usage();
            }
            if (++index >= args.length) {
                m_logger.error("Another parameter expected after '{}'", name);
                usage();
            }
            String value = args[index];
            try {
                m_config.set(name.substring(1), value);
            } catch (Exception e) {
                m_logger.error(e.toString());
                usage();
            }
            index++;
        }
    }
1047041
def execute(self, *args, **kwargs):
        
        # Remove internal Django command handling machinery
        kwargs.pop('skip_checks', None)
        parent_ctx = click.get_current_context(silent=True)
        with self.make_context('', list(args), parent=parent_ctx) as ctx:
            # Rename kwargs to to the appropriate destination argument name
            opt_mapping = dict(self.map_names())
            arg_options = {opt_mapping.get(key, key): value
                           for key, value in six.iteritems(kwargs)}

            # Update the context with the passed (renamed) kwargs
            ctx.params.update(arg_options)

            # Invoke the command
            self.invoke(ctx)
679016
def _handle_argument(self, token):
        """"""
        name = None
        self._push()
        while self._tokens:
            token = self._tokens.pop()
            if isinstance(token, tokens.ArgumentSeparator):
                name = self._pop()
                self._push()
            elif isinstance(token, tokens.ArgumentClose):
                if name is not None:
                    return Argument(name, self._pop())
                return Argument(self._pop())
            else:
                self._write(self._handle_token(token))
        raise ParserError("_handle_argument() missed a close token")
413541
private void helpAction(String arg) {
        if (arg == null) {
            printMainUsage();
            return;
        }

        String helpTarget = arg.toLowerCase();

        if (helpTarget.equals(ACTION_VIEW)) {
            printViewUsage();
        } else if (helpTarget.equals(ACTION_COPY)) {
            printCopyUsage();
        } else if (helpTarget.equals(ACTION_LISTINSTANCES)) {
            printListInstancesUsage();
        } else {
            printMainUsage();
        }
    }
697095
public void addArguments (final String [] arguments)
  {
    if (arguments != null)
    {
      for (final String argument : arguments)
      {
        addArgument (argument);
      }
    }
  }
946218
private void processArgs(final String[] arguments) {
        args = argumentParser.processArgs(arguments);
        final Map<String, Object> definedProps = new HashMap<>(args.definedProps);
        buildFile = args.buildFile;

        if (args.justPrintUsage || args.justPrintVersion || args.justPrintDiagnostics || args.justPrintPlugins || args.justPrintTranstypes || args.justPrintDeliverables) {
            if (args.justPrintVersion) {
                printVersion(args.msgOutputLevel);
            }
            if (args.justPrintUsage) {
                printUsage();
            }
            if (args.justPrintDiagnostics) {
                Diagnostics.doReport(System.out, args.msgOutputLevel);
            }
            if (args.justPrintPlugins) {
                printPlugins();
            }
            if (args.justPrintTranstypes) {
                printTranstypes();
            }
            if (args.justPrintDeliverables) {
                if (args.projectFile == null) {
                    printErrorMessage("Error: Project file not defined");
                    printUsage();
                    throw new BuildException("");
                }
                printDeliverables();
            }

            return;
        }

        if (args.install) {
            buildFile = findBuildFile(System.getProperty("dita.dir"), "integrator.xml");
            targets.clear();
            if (args.installFile != null) {
                targets.add("install");
                final File f = new File(args.installFile.replace('/', File.separatorChar)).getAbsoluteFile();
                if (f.exists()) {
                    definedProps.put(ANT_PLUGIN_FILE, f.getAbsolutePath());
                } else {
                    definedProps.put(ANT_PLUGIN_FILE, args.installFile);
                }
            } else if (args.uninstallId != null) {
                targets.add("uninstall");
                definedProps.put(ANT_PLUGIN_ID, args.uninstallId);
            } else {
                targets.add("integrate");
            }
        } else {
            if (args.projectFile == null) {
                if (!definedProps.containsKey(ANT_TRANSTYPE)) {
                    printErrorMessage("Error: Transformation type not defined");
                    printUsage();
                    throw new BuildException("");
                    //justPrintUsage = true;
                }
                if (!definedProps.containsKey(ANT_ARGS_INPUT)) {
                    printErrorMessage("Error: Input file not defined");
                    printUsage();
                    throw new BuildException("");
                    //justPrintUsage = true;
                }
            }
            // default values
            if (!definedProps.containsKey(ANT_OUTPUT_DIR)) {
                definedProps.put(ANT_OUTPUT_DIR, new File(new File("."), "out").getAbsolutePath());
            }
            if (!definedProps.containsKey(ANT_BASE_TEMP_DIR) && !definedProps.containsKey(ANT_TEMP_DIR)) {
                definedProps.put(ANT_BASE_TEMP_DIR, new File(System.getProperty("java.io.tmpdir")).getAbsolutePath());
            }
        }

        projectProps = args.projectFile != null
                ? handleProject(definedProps)
                : Collections.singletonList(definedProps);

        // make sure buildfile exists
        if (!args.buildFile.exists() || buildFile.isDirectory()) {
            System.out.println("Buildfile: " + buildFile + " does not exist!");
            throw new BuildException("Build failed");
        }

        // Normalize buildFile for re-import detection
        buildFile = FileUtils.getFileUtils().normalize(buildFile.getAbsolutePath());

        if (args.msgOutputLevel >= Project.MSG_VERBOSE) {
            System.out.println("Buildfile: " + buildFile);
        }

        if (args.logFile != null) {
            PrintStream logTo;
            try {
                logTo = new PrintStream(new FileOutputStream(args.logFile));
            } catch (final IOException ioe) {
                throw new BuildException("Cannot write on the specified log file. "
                        + "Make sure the path exists and you have write permissions.");
            }
            out = logTo;
            err = logTo;
            System.setOut(out);
            System.setErr(err);
        }
        readyToRun = true;
    }
936534
def _process_arguments(arguments):
    ''' 

    '''
    if arguments is None: return ""
    result = ""
    for key, value in arguments.items():
        if not key.startswith("bokeh-"):
            result += "&{}={}".format(quote_plus(str(key)), quote_plus(str(value)))
    return result
196719
public void parse(String... args) {
        try {
            parse(true /* validate */, args);
        } catch(ParameterException ex) {
            ex.setJCommander(this);
            throw ex;
        }
    }
1297911
protected void preprocessArgument(Object arg) {
        if (arg instanceof Type) {
            preprocessType((Type)arg);
        }
        else if (arg instanceof Symbol) {
            preprocessSymbol((Symbol)arg);
        }
        else if (arg instanceof JCDiagnostic) {
            preprocessDiagnostic((JCDiagnostic)arg);
        }
        else if (arg instanceof Iterable<?>) {
            for (Object o : (Iterable<?>)arg) {
                preprocessArgument(o);
            }
        }
    }