<p>
The map of arguments used to configure this DevEndpoint.
</p>

@param arguments
The map of arguments used to configure this DevEndpoint.
@return Returns a reference to this object so that method calls can be chained together.
344087
public CreateDevEndpointResult withArguments(java.util.Map<String, String> arguments) {
        setArguments(arguments);
        return this;
    }
697095
public void addArguments (final String [] arguments)
  {
    if (arguments != null)
    {
      for (final String argument : arguments)
      {
        addArgument (argument);
      }
    }
  }
430634
@PreAuthorize("hasRole(@configHolder.getSuperAdminRoleName())")
    public Set<RequestMappingInfo> getEndpoints(RequestMappingHandlerMapping requestMappingHandlerMapping) {

        if (requestMappingHandlerMapping.getHandlerMethods() != null) {
            return requestMappingHandlerMapping.getHandlerMethods().keySet();
        }

        return null;
    }
182286
public Type addArguments(List<Type> argTypes) {
    Type t = this;
    for (Type a : argTypes) {
      t = t.addArgument(a);
    }
    return t;
  }
977644
protected String getArguments(Object[] args) {

        if (args == null || args.length == 0) {
            return "";
        }

        StringBuilder sb = new StringBuilder();

        if (args.length == 1) {
            Object arg = args[0];
            String param = getSingleArgParameterAsString(arg);
            String displayParam = getSingleArgDisplayParameter(param);
            if (arg instanceof String) {
                sb.append("\"");
                sb.append(displayParam);
                sb.append("\"");
            } else {
                sb.append(displayParam);
            }
        } else {
            for (int i = 0; i < args.length; i++) {
                Object arg = args[i];
                boolean lastArg = i == args.length - 1;
                String param = getParameterAsString(arg);
                String displayParam = getDisplayParameter(param);
                if (arg instanceof String) {
                    sb.append("\"");
                    sb.append(displayParam);
                    sb.append("\"");
                } else {
                    sb.append(displayParam);
                }

                if (!lastArg) {
                    sb.append(",");
                }
            }
        }

        return sb.toString();
    }
682875
public void setArgs(java.util.Collection<CodeGenNodeArg> args) {
        if (args == null) {
            this.args = null;
            return;
        }

        this.args = new java.util.ArrayList<CodeGenNodeArg>(args);
    }
720432
public static ConfigSource parseMainArgs(String...args) {
        Map<String, String> result;
        if (args == null) {
            result = Collections.emptyMap();
        } else {
            result = new HashMap<>();
            String prefix = System.getProperty("main.args.prefix","");
            String key = null;
            for (String arg : args) {
                if (arg.startsWith("--")) {
                    arg = arg.substring(2);
                    int index = arg.indexOf('=');
                    if (index > 0) {
                        key = arg.substring(0, index).trim();
                        result.put(prefix + key, arg.substring(index + 1).trim());
                        key = null;
                    } else {
                        result.put(prefix + arg, arg);
                    }
                } else if (arg.charAt(0) == '-') {
                    key = arg.substring(1);
                } else {
                    if (key != null) {
                        result.put(prefix + key, arg);
                        key = null;
                    } else {
                        result.put(prefix + arg, arg);
                    }
                }
            }
        }
        return new CLIPropertySource(result);
    }
285394
public static Class<?>[] getParamTypes(Object... arguments)
    {
        Check.notNull(arguments);

        final Collection<Object> types = new ArrayList<>(arguments.length);
        for (final Object argument : arguments)
        {
            if (argument.getClass() == Class.class)
            {
                types.add(argument);
            }
            else
            {
                types.add(argument.getClass());
            }
        }
        final Class<?>[] typesArray = new Class<?>[types.size()];
        return types.toArray(typesArray);
    }
98459
public Partition withParameters(java.util.Map<String, String> parameters) {
        setParameters(parameters);
        return this;
    }
501161
public static <T extends CitrusAppConfiguration> T apply(T configuration, String[] arguments) {
        LinkedList<String> args = new LinkedList<>(Arrays.asList(arguments));

        CitrusAppOptions options = new CitrusAppOptions();
        while (!args.isEmpty()) {
            String arg = args.removeFirst();

            for (CliOption option : options.options) {
                if (option.processOption(configuration, arg, args)) {
                    break;
                }
            }
        }

        return configuration;
    }
216358
public static List<String> buildList(String... args) {
        List<String> newList = new ArrayList<String>();
        Collections.addAll(newList, args);
        return newList;
    }
535680
public CliCommandBuilder addCliArgument(final String arg) {
        if (arg != null) {
            final Argument argument = Arguments.parse(arg);
            final CliArgument cliArgument = CliArgument.find(argument.getKey());
            if (cliArgument != null) {
                // Remove the alternate key if required
                if (cliArgument.altKey != null) {
                    cliArgs.remove(cliArgument.altKey);
                }
            }
            cliArgs.set(argument);
        }
        return this;
    }
846190
public synchronized Map<String, Argument> getPluginArguments() {
        if (PLUGIN_ARGUMENTS == null) {
            final List<Element> params = toList(Plugins.getPluginConfiguration().getElementsByTagName("param"));
            PLUGIN_ARGUMENTS = params.stream()
                    .map(ArgumentParser::getArgument)
                    .collect(Collectors.toMap(
                            arg -> ("--" + arg.property),
                            arg -> arg,
                            ArgumentParser::mergeArguments));
        }
        return PLUGIN_ARGUMENTS;
    }
780796
public MethodConfig setParameters(Map<String, String> parameters) {
        if (this.parameters == null) {
            this.parameters = new ConcurrentHashMap<String, String>();
            this.parameters.putAll(parameters);
        }
        return this;
    }
261100
private static Object[] getParams(Context context, Object... arguments)
    {
        final Collection<Object> params = new ArrayList<>(1);
        params.add(context);
        params.addAll(Arrays.asList(arguments));
        return params.toArray();
    }
492508
public ParameterBuilder<T> properties(Map<String, Object> map) {
    if (map == null) {
      throw new IllegalArgumentException("Map argument must not be null.");
    }
    this.properties.putAll(map);
    return this;
  }
663384
public static Map<String, QueryParameter> toMap(List<QueryParameter> parameters) {
        Map<String, QueryParameter> map = new HashMap<String, QueryParameter>();
        for (QueryParameter qp : parameters) {
            map.put(qp.getName(), qp);
        }
        return map;
    }