Performs the replacement of arguments[x] -> a if x is known.

@param argNames maps param index to param name, if the param with that index has a name.
437498
private void changeBody(ImmutableMap<Integer, String> argNames) {
    for (Node ref : currentArgumentsAccesses) {
      Node index = ref.getNext();
      Node parent = ref.getParent();
      int value = (int) index.getDouble(); // This was validated earlier.

      @Nullable String name = argNames.get(value);
      if (name == null) {
        continue;
      }

      Node newName = IR.name(name).useSourceInfoIfMissingFrom(parent);
      parent.replaceWith(newName);
      // TODO(nickreid): See if we can do this fewer times. The accesses may be in different scopes.
      compiler.reportChangeToEnclosingScope(newName);
    }
  }
1148918
@Override
	public void loadArgs(List<String> arguments)
	{		
		if(arguments == null || arguments.isEmpty())
			return;
		
		this.setProperties(ArgsParser.parse(arguments));
	}
52286
def _unknown_args(self, args):
        
        for u in args:
            self.tcex.log.warning(u'Unsupported arg found ({}).'.format(u))
385785
List<String> argNames(int size) {
        List<String> argNames = new ArrayList<>();
        for (int i = 0 ; i < size ; i++) {
            argNames.add(StubKind.FACTORY_METHOD_ARG.format(i));
        }
        return argNames;
    }
59739
private List<ResourceArgument> computeMethodArguments(final ExecutableElement ee) {
    final List<ResourceArgument> arguments = Lists.newArrayList();
    for (VariableElement ve : ee.getParameters()) {
      final PathParam pathAnnotation = ve.getAnnotation(PathParam.class);
      final String argName;
      if (pathAnnotation != null) {
        argName = pathAnnotation.value();
      } else {
        argName = ve.getSimpleName().toString();
      }
      arguments.add(new ResourceArgument(argName, makeTypeDescriptor(ve.asType())));
    }
    return arguments;
  }
234712
@SafeVarargs
  public final QueryBuilder arguments(Object...args) {
    set(Param.QUERY_ARGS, "");
    queryArgs = args.clone();
    return this;
  }
196202
public static void main(String[] args) {
        if (args.length < 2) { // NOSONAR
            LOGGER.error("There must be at least two arguments");
            return;
        }
        int lastIndex = args.length - 1;
        AllureReportGenerator reportGenerator = new AllureReportGenerator(
                getFiles(Arrays.copyOf(args, lastIndex))
        );
        reportGenerator.generate(new File(args[lastIndex]));
    }
184218
protected static String verifyNonEmpty(String value, String argName) {
        if (value != null) {
            value = value.trim();
            if (value.isEmpty()) {
                value = null;
            }
        }
        if (value == null) {
            throw new IllegalArgumentException(argName);
        }
        return value;
    }
1254153
public void addArgument(AstNode arg) {
        assertNotNull(arg);
        if (arguments == null) {
            arguments = new ArrayList<AstNode>();
        }
        arguments.add(arg);
        arg.setParent(this);
    }
1336564
@Override
    public int[] apply(INDArray... outputs) {
        Preconditions.checkArgument(outputs.length == 1, "Argmax adapter can have only 1 output");
        val array = outputs[0];
        Preconditions.checkArgument(array.rank() < 3, "Argmax adapter requires 2D or 1D output");
        val result = array.rank() == 2 ? new int[(int) array.size(0)] : new int[1];

        if (array.rank() == 2) {
            val t = Nd4j.argMax(array, 1);
            for (int e = 0; e < t.length(); e++)
                result[e] = (int) t.getDouble(e);
        } else
            result[0] = (int) Nd4j.argMax(array, Integer.MAX_VALUE).getDouble(0);

        return result;
    }
}
871409
ArgumentsBuilder intersperse(String param, List<String> values) {
        if (values != null) {
            for (String value : values) {
                args.add(param);
                args.add(value);
            }
        }
        return this;
    }
664585
public function getMethodArgs($argName){

		//check if the argument is already set
		if( array_key_exists($argName, $this->methodArgs)){

			//return the value of this argument
			return $this->methodArgs[$argName];

		}

		//this argument is not yet set, so return null
		else{

			//return a null
			return null;

		}

	}
993199
public static void addArgument(MethodCallExpr call, Expression arg) {
        List<Expression> args = call.getArgs();
        if (args == null) {
            args = new ArrayList<Expression>();
            call.setArgs(args);
        }
        args.add(arg);
    }
618486
public void bindAllArgsAsStrings(String[] bindArgs) {
        if (bindArgs != null) {
            for (int i = bindArgs.length; i != 0; i--) {
                bindString(i, bindArgs[i - 1]);
            }
        }
    }
460808
public static void main(String[] args)
    {
        Class<?> exampleClass = args.length > 0 ? EXAMPLES.get(args[0]) : null;
        if (exampleClass == null)
        {
            System.err.println("First argument must be the name of an example, i.e. one of "
                               + Arrays.toString(EXAMPLES.keySet().toArray()));
            System.exit(1);
        }

        // All args except the first one should be passed to the example application.
        String[] appArgs = new String[args.length - 1];
        System.arraycopy(args, 1, appArgs, 0, appArgs.length);

        // Invoke the main method for the selected example application.
        Method main = ReflectionUtils.findKnownMethod(exampleClass, "main", String[].class);
        ReflectionUtils.invokeUnchecked(main, exampleClass, new Object[]{appArgs});
    }
1261
public static int checkArgPositive(final int arg, final String argNameOrErrorMsg) {
        if (arg <= 0) {
            if (argNameOrErrorMsg.indexOf(' ') == N.INDEX_NOT_FOUND) {
                throw new IllegalArgumentException("'" + argNameOrErrorMsg + "' can not be zero or negative: " + arg);
            } else {
                throw new IllegalArgumentException(argNameOrErrorMsg);
            }
        }

        return arg;
    }
841157
public void addAll(final String... args) {
        if (args != null) {
            for (String arg : args) {
                add(arg);
            }
        }
    }