Add a {@link CommandType} argument. The argument is represented as bulk string.

@param type must not be {@literal null}.
@return the command args.
347721
public CommandArgs<K, V> add(CommandType type) {

        LettuceAssert.notNull(type, "CommandType must not be null");
        singularArguments.add(ProtocolKeywordArgument.of(type));
        return this;
    }
321916
public void addImplements(String type) {
		if (!Strings.isEmpty(type)) {
			this.sarlClass.getImplements().add(newTypeRef(this.container, type));
		}
	}
1308624
public FtpMessage arguments(String arguments) {
        if (command != null) {
            command.setArguments(arguments);
        }

        setHeader(FtpMessageHeaders.FTP_ARGS, arguments);
        return this;
    }
737621
protected function command($type, $parameters = array())
		{
			$parameters = array_merge(compact('type'), $parameters);
			$this->commands[] = new Fluent($parameters);
			return end($this->commands);
		}
719828
public void addParameter(String name, ParameterType type) {
        parameters.put(name, new Parameter(name, type));
    }
627421
List<String> argDecls(List<String> types, List<String> args) {
        List<String> argNames = new ArrayList<>();
        for (int i = 0 ; i < types.size() ; i++) {
            argNames.add(types.get(i) + " " + args.get(i));
        }
        return argNames;
    }
140868
private String addAspToAs(String[] args) throws Exception {
        if (args.length < 5) {
            return M3UAOAMMessages.INVALID_COMMAND;
        }

        // Add Rem ASP to Rem AS
        if (args[3] == null || args[4] == null) {
            return M3UAOAMMessages.INVALID_COMMAND;
        }

        if (args.length > 5) {
            if (!args[5].equals("stackname")) {
                return M3UAOAMMessages.INVALID_COMMAND;
            }

            String m3uaStackName = args[6];
            M3UAManagementImpl m3uaManagementtmp = this.m3uaManagements.get(m3uaStackName);

            if (m3uaManagementtmp == null) {
                return String.format(M3UAOAMMessages.NO_M3UA_MANAGEMENT_BEAN_FOR_NAME, m3uaStackName);
            }

            this.m3uaManagement = m3uaManagementtmp;
        } else {
            this.setDefaultValue();
        }

        this.m3uaManagement.assignAspToAs(args[3], args[4]);
        return String.format(M3UAOAMMessages.ADD_ASP_TO_AS_SUCESSFULL, args[4], args[3], this.m3uaManagement.getName());
    }
1220625
protected void addCommandLineArgument(StringBuilder buffer,String argument,String value)
    {
        if((value!=null)&&(value.length()>0))
        {
            buffer.append(argument);
            buffer.append(Fax4jExeConstants.SPACE_STR);
            buffer.append(Fax4jExeConstants.VALUE_WRAPPER);
            buffer.append(value);
            buffer.append(Fax4jExeConstants.VALUE_WRAPPER);
            buffer.append(Fax4jExeConstants.SPACE_STR);
        }
    }
1036663
private String[] augmentCommand(String[] args, Class<? extends Command> cmd,
			boolean acceptsInputFile) {
		OptionGroup<ID> options;
		try {
			if (acceptsInputFile) {
				options = OptionIntrospector.introspect(cmd, InputFileCommand.class);
			} else {
				options = OptionIntrospector.introspect(cmd);
			}
		} catch (IntrospectionException e) {
			//should never happen
			throw new RuntimeException(e);
		}
		
		ShellContext sc = ShellContext.current();
		for (Option<ID> o : options.getOptions()) {
			if (o.getLongName().equals("style")) {
				args = ArrayUtils.add(args, "--style");
				args = ArrayUtils.add(args, sc.getStyle());
			} else if (o.getLongName().equals("locale")) {
				args = ArrayUtils.add(args, "--locale");
				args = ArrayUtils.add(args, sc.getLocale());
			} else if (o.getLongName().equals("format")) {
				args = ArrayUtils.add(args, "--format");
				args = ArrayUtils.add(args, sc.getFormat());
			} else if (o.getLongName().equals("input") &&
					sc.getInputFile() != null && !sc.getInputFile().isEmpty()) {
				args = ArrayUtils.add(args, "--input");
				args = ArrayUtils.add(args, sc.getInputFile());
			}
		}
		
		return args;
	}
1065440
public void addUpperConstraint(String type) {
		final JvmUpperBound constraint = this.jvmTypesFactory.createJvmUpperBound();
		constraint.setTypeReference(newTypeRef(this.context, type));
		getJvmTypeParameter().getConstraints().add(constraint);
	}
479990
public final void setArgs(String... args) throws CmdArgsException
    {
        try
        {
            options = new HashMap<>();
            Option opt = null;
            int index = 0;
            for (String arg : args)
            {
                if (opt != null)
                {
                    options.put(opt.name, ConvertUtility.convert(opt.cls, arg));
                    opt = null;
                }
                else
                {
                    if (map.containsKey(arg))
                    {
                        opt = map.get(arg);
                        if (opt.exclusiveGroup != null)
                        {
                            if (effectiveGroup != null && !effectiveGroup.equals(opt.exclusiveGroup))
                            {
                                throw new CmdArgsException(opt.exclusiveGroup+" mix with "+effectiveGroup, this);
                            }
                            effectiveGroup = opt.exclusiveGroup;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                index++;
            }
            // defaults
            for (Option o : map.values())
            {
                if (!o.mandatory && !options.containsKey(o.name))
                {
                    options.put(o.name, o.defValue);
                }
            }
            int len = args.length-index;
            if (hasArrayArgument)
            {
                if (len < types.size())
                {
                    throw new CmdArgsException("too few arguments", this);
                }
            }
            else
            {
                if (len != types.size())
                {
                    throw new CmdArgsException("wrong number of arguments", this);
                }
            }
            arguments = new HashMap<>();
            int arraySize = len - types.size() + 1;
            int arrayIndex = Integer.MAX_VALUE;
            Object array = null;
            Class<?> componenType = null;
            if (hasArrayArgument)
            {
                arrayIndex = types.size()-1;
                Class<?> arrayType = types.get(arrayIndex);
                componenType = arrayType.getComponentType();
                array = Array.newInstance(componenType, arraySize);
                arguments.put(names.get(arrayIndex), array);
            }
            for (int ii=0;ii<len;ii++)
            {
                if (ii < arrayIndex)
                {
                    Object value = ConvertUtility.convert(types.get(ii), args[ii+index]);
                    arguments.put(names.get(ii), value);
                }
                else
                {
                    Object value = ConvertUtility.convert(componenType, args[ii+index]);
                    Array.set(array, ii - arrayIndex, value);
                }
            }
            for (Option o : map.values())
            {
                if (o.mandatory && !options.containsKey(o.name))
                {
                    throw new CmdArgsException("mandatory option "+o.name+": "+o.description+" missing", this);
                }
            }
            if (effectiveGroup != null)
            {
                for (Option o : groups.get(effectiveGroup))
                {
                    if (o.mandatory && !options.containsKey(o.name))
                    {
                        throw new CmdArgsException(effectiveGroup+" option "+o.name+": "+o.description+" missing", this);
                    }
                }
            }
        }
        catch (Exception ex)
        {
            throw new CmdArgsException(ex, this);
        }
    }
514770
public CommandArgs<K, V> add(String s) {

        singularArguments.add(StringArgument.of(s));
        return this;
    }
979553
function(commandId, type, binding, bindingOnly) {
			this._pendingBindings[commandId] = this._pendingBindings[commandId] || [];
			this._pendingBindings[commandId].push({
				type: type,
				binding: binding,
				bindingOnly: bindingOnly
			});
		}
49113
public static Class<?> getFirstTypeArgument(Type type) {
        if (type instanceof ParameterizedType) {
            ParameterizedType p = (ParameterizedType) type;
            return getRawClass(p.getActualTypeArguments()[0]);
        } else {
            return null;
        }
    }
765958
private static void populateTypeArgs(ParameterizedType type, Map<TypeVariable<?>, Type> map, boolean depthFirst) {
    if (type.getRawType() instanceof Class) {
      TypeVariable<?>[] typeVariables = ((Class<?>) type.getRawType()).getTypeParameters();
      Type[] typeArguments = type.getActualTypeArguments();

      if (type.getOwnerType() != null) {
        Type owner = type.getOwnerType();
        if (owner instanceof ParameterizedType)
          populateTypeArgs((ParameterizedType) owner, map, depthFirst);
      }

      for (int i = 0; i < typeArguments.length; i++) {
        TypeVariable<?> variable = typeVariables[i];
        Type typeArgument = typeArguments[i];

        if (typeArgument instanceof Class) {
          map.put(variable, typeArgument);
        } else if (typeArgument instanceof GenericArrayType) {
          map.put(variable, typeArgument);
        } else if (typeArgument instanceof ParameterizedType) {
          map.put(variable, typeArgument);
        } else if (typeArgument instanceof TypeVariable) {
          TypeVariable<?> typeVariableArgument = (TypeVariable<?>) typeArgument;
          if (depthFirst) {
            Type existingType = map.get(variable);
            if (existingType != null) {
              map.put(typeVariableArgument, existingType);
              continue;
            }
          }

          Type resolvedType = map.get(typeVariableArgument);
          if (resolvedType == null)
            resolvedType = resolveBound(typeVariableArgument);
          map.put(variable, resolvedType);
        }
      }
    }
  }
723314
private void addArgument(CliArgumentContainer argumentContainer) {

    this.arguments.add(argumentContainer);
    String modeId = argumentContainer.getArgument().mode();
    requireMode(modeId, argumentContainer);
  }
1223481
public void addLowerConstraint(String type) {
		final JvmLowerBound constraint = this.jvmTypesFactory.createJvmLowerBound();
		constraint.setTypeReference(newTypeRef(this.context, type));
		getJvmTypeParameter().getConstraints().add(constraint);
	}