Adds the value of arg and possibly nextArg to the parser for handler.

@param nextArg - The argument following this one, or null if there isn't one.
@return if nextArg was consumed by handling this option.
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;
        }
    }
1005884
private boolean verifyLastArgumentIsString(Node methodName, Node arg) {
    return verifyNotNull(methodName, arg)
        && verifyOfType(methodName, arg, Token.STRING)
        && verifyIsLast(methodName, arg);
  }
251445
public final void setArgument(final String key, final Object value) {

		if (key != null && value != null) {
			this.arguments.put(key, value);
		}
	}
302667
function(arg) {

            var segments = this.segments;
            var numSegments = segments.length;
            // works even if path has no segments

            var currentSegment;

            var previousSegment = ((numSegments !== 0) ? segments[numSegments - 1] : null); // if we are appending to an empty path, previousSegment is null
            var nextSegment = null;

            if (!Array.isArray(arg)) { // arg is a segment
                if (!arg || !arg.isSegment) throw new Error('Segment required.');

                currentSegment = this.prepareSegment(arg, previousSegment, nextSegment);
                segments.push(currentSegment);

            } else { // arg is an array of segments
                if (!arg[0].isSegment) throw new Error('Segments required.');

                var n = arg.length;
                for (var i = 0; i < n; i++) {

                    var currentArg = arg[i];
                    currentSegment = this.prepareSegment(currentArg, previousSegment, nextSegment);
                    segments.push(currentSegment);
                    previousSegment = currentSegment;
                }
            }
        }
642309
public void add(String name, MessageArg arg) {
    args.add(arg);
    if (map == null) {
      map = new HashMap<>();
    }
    map.put(name, arg);
  }
1088336
public void setArgs(String args) {
    for (String s : args.trim().split("\\s*,\\s*"))
      argv.add(s);
  }
179593
private void initMainParameterValue(String arg) {
        if (mainParameter == null) {
            throw new ParameterException(
                    "Was passed main parameter '" + arg + "' but no main parameter was defined in your arg class");
        }

        Object object = mainParameter.parameterized.get(mainParameter.object);
        Class<?> type = mainParameter.parameterized.getType();

        // If it's a List<String>, we might need to create that list and then add the value to it.
        if (List.class.isAssignableFrom(type)) {
            List result;
            if (object == null) {
                result = Lists.newArrayList();
            } else {
                result = (List) object;
            }

            if (mainParameter.firstTimeMainParameter) {
                result.clear();
                mainParameter.firstTimeMainParameter = false;
            }

            mainParameter.multipleValue = result;
            mainParameter.parameterized.set(mainParameter.object, result);
        }

    }
607166
public void setArgs(String[] args) {
        if (args == null) {
            args = new String[]{};
        }
        this.args = args;
        this.argsList = Collections.unmodifiableList(new ArrayList<String>(Arrays.asList(args)));
    }
421864
def AddArg(self, argument):
    
    self.args.append(argument)
    if len(self.args) > self.number_of_args:
      raise errors.ParseError('Too many arguments for this expression.')

    elif len(self.args) == self.number_of_args:
      return True

    return False
1178268
private void oneArg(String[] args, int index) {
        if ((index + 1) < args.length) {
            setOption(args[index], args[index+1]);
        } else {
            usageError("main.requires_argument", args[index]);
        }
    }
1006898
protected void addConfiguredProcessorArg(final CommandLineArgument arg) throws NullPointerException, BuildException {
    if (arg == null) {
      throw new NullPointerException("arg");
    }
    if (isReference()) {
      throw noChildrenAllowed();
    }
    this.processorArgs.addElement(arg);
  }
924451
@Override
    public void add(int arg0, Object arg1) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "add", new Object[] { Integer.valueOf(arg0), arg1 });

        synchronized (getMessageLockArtefact()) {
            super.add(arg0, arg1);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.exit(this, tc, "add");
    }
805528
public synchronized void loadValue(final ARG_TYPE arg) {
        if (fetchFuture != null) {
            // Cancel thread if it was not yet starter.
            fetchFuture.cancel(false);
            // If thread was cancelled before it was started inform error listeners.
            if (fetchThread != null) {
                fetchThread.interruptAndInformListenersIfNeeded();
            }
        }
        // We use thread instead of pure runnable so we can interrupt loading.
        fetchThread = new LoadThread<RETURN_TYPE, ARG_TYPE>(valueGetter,
                successListener,
                errorListener,
                value, arg, dropValueOnFailure);
        fetchFuture = valueGetterExecutor.submit(fetchThread);
    }
747352
private static void appendArgument(StringBuilder argumentsAsString, int index, String argumentName,
                                       Object[] arguments) {
        argumentsAsString.append(argumentName);
        if (index != arguments.length - 1) {
            argumentsAsString.append(", ");
        }
    }
565037
public T addAppArgs(String... args) {
    for (String arg : args) {
      checkNotNull(arg, "arg");
      builder.appArgs.add(arg);
    }
    return self();
  }
259317
private String getArgumentName(final String arg) {
        int pos = arg.indexOf("=");
        if (pos == -1) {
            pos = arg.indexOf(":");
        }
        return arg.substring(0, pos != -1 ? pos : arg.length());
    }
668216
public void setArguments(Object args) {

	if (args instanceof lucee.runtime.type.Collection) {
	    StringBuilder sb = new StringBuilder();
	    lucee.runtime.type.Collection coll = (lucee.runtime.type.Collection) args;
	    // lucee.runtime.type.Collection.Key[] keys=coll.keys();
	    Iterator<Object> it = coll.valueIterator();
	    while (it.hasNext()) {
		sb.append(' ');
		sb.append(it.next());
	    }
	    arguments = sb.toString();
	}
	else if (args instanceof String) {
	    arguments = " " + args.toString();
	}
	else this.arguments = "";
    }