@Override public String toString() { StringBuffer buf = new StringBuffer(); buf.append("[UnitGroup "); buf.append(id); buf.append(" :type "); buf.append(type); buf.append(" :ownerId "); buf.append(ownerId); buf.append(" (:required"); for (Argument arg : unitTypeReqs) { buf.append(" "); buf.append(arg.getName()); buf.append(" "); buf.append(arg.getValue()); } buf.append(") (:actual"); if (!isEmpty()) { for (Map.Entry<String, Integer> entry : getRepresentative().getUnitTypes().entrySet()) { buf.append(" "); buf.append(entry.getKey()); buf.append(" "); buf.append(entry.getValue()); } } buf.append(")]"); return buf.toString(); }
/** Bind and add argument's binding into the scope of the method */ public void bindArguments() { if (this.arguments != null) { // by default arguments in abstract/native methods are considered to be used (no complaint is // expected) if (this.binding == null) { for (int i = 0, length = this.arguments.length; i < length; i++) { this.arguments[i].bind(this.scope, null, true); } return; } boolean used = this.binding.isAbstract() || this.binding.isNative(); AnnotationBinding[][] paramAnnotations = null; for (int i = 0, length = this.arguments.length; i < length; i++) { Argument argument = this.arguments[i]; argument.bind(this.scope, this.binding.parameters[i], used); if (argument.annotations != null) { if (paramAnnotations == null) { paramAnnotations = new AnnotationBinding[length][]; for (int j = 0; j < i; j++) { paramAnnotations[j] = Binding.NO_ANNOTATIONS; } } paramAnnotations[i] = argument.binding.getAnnotations(); } else if (paramAnnotations != null) { paramAnnotations[i] = Binding.NO_ANNOTATIONS; } } if (paramAnnotations != null) this.binding.setParameterAnnotations(paramAnnotations); } }
public String toUsageString() { StringBuilder sb = new StringBuilder(); for (Argument a : parameters.values()) { sb.append(a.toUsageString("\t")); } return sb.toString(); }
@Test(expected = IllegalArgumentException.class) public void testcheckNotBlankFail() { Argument.checkNotBlank(null, "message"); Argument.checkNotBlank("", "message"); Argument.checkNotBlank(" ", "message"); Argument.checkNotBlank(" \n\r\t ", "message"); }
/** * Set the value of an input parameter before a message service call * * @param parameterName the parameter name * @param parameterValue the date parameter value, will be automatically translated to the correct * ISO 8601 date format for the given action input param related state variable * @return the current ActionMessage object instance * @throws IllegalArgumentException if the provided parameterName is not valid for this message or * if no input parameters are required for this message */ public ActionMessage setInputParameter(String parameterName, Date parameterValue) throws IllegalArgumentException { if (serviceAction.getInputActionArguments() == null) { throw new IllegalArgumentException("No input parameters required for this message"); } Argument arg = serviceAction.getInputActionArgument(parameterName); if (arg == null) { throw new IllegalArgumentException( "Wrong input argument name for this action:" + parameterName + " available parameters are : " + serviceAction.getInputActionArguments()); } StateVariable linkedVar = arg.getRelatedStateVariable(); if (linkedVar.dataType.equals(StateVariableTypes.TIME)) { return setInputParameter(parameterName, ISO8601Date.getIsoTime(parameterValue)); } else if (linkedVar.dataType.equals(StateVariableTypes.TIME_TZ)) { return setInputParameter(parameterName, ISO8601Date.getIsoTimeZone(parameterValue)); } else if (linkedVar.dataType.equals(StateVariableTypes.DATE)) { return setInputParameter(parameterName, ISO8601Date.getIsoDate(parameterValue)); } else if (linkedVar.dataType.equals(StateVariableTypes.DATETIME)) { return setInputParameter(parameterName, ISO8601Date.getIsoDateTime(parameterValue)); } else if (linkedVar.dataType.equals(StateVariableTypes.DATETIME_TZ)) { return setInputParameter(parameterName, ISO8601Date.getIsoDateTimeZone(parameterValue)); } else { throw new IllegalArgumentException( "Related input state variable " + linkedVar.name + " is not of an date type"); } }
protected void buildPython(IndentingAppender ia) throws IOException { String name = getClass().getSimpleName(); ia.append("def ").append(name).append("(self"); ia.incrementIndent().incrementIndent(); for (Argument arg : _arguments) { ia.append(", ").append(arg._name); if (!arg._required) ia.append("=None"); } ia.appendln("):"); ia.decrementIndent().decrementIndent(); ia.incrementIndent(); ia.appendln("'''"); ia.appendln(Objects.firstNonNull(_requestHelp, "MISSING HELP STRING")); if (!_arguments.isEmpty()) ia.appendln("Arguments:"); ia.incrementIndent(); for (Argument arg : _arguments) { ia.append(arg._name).append(" -- "); if (arg._required) ia.append("required -- "); ia.appendln(arg.queryDescription()); ia.incrementIndent(); ia.appendln(Objects.firstNonNull(arg._requestHelp, "MISSING HELP STRING")); ia.decrementIndent(); } ia.decrementIndent(); ia.appendln("'''"); ia.appendln("pass"); ia.decrementIndent(); }
private void displayCommand(Command c, Player p) { p.sendMessage("-------------Command Arguments---------------"); p.sendMessage("--------------------------------------------"); for (Argument arg : c.listArguments()) { p.sendMessage(arg.toString()); } }
/** * Register a regular command argument/parameter for this command. * * <p>When adding multiple arguments the order you add them in determines the indexing of the * argument! * * @param name The argument name/key used to identify the argument. This name must be used with * the {@link CmdData} result to get the argument value. * @param requirement The requirement for this argument. (See {@link ArgRequirement} for more * info) * @param option The {@link SingleOption} used for parsing the argument. This option determines * the argument value and everything else. For example if it's a {@link PlayerO} the argument * value must be a player and the result value would be a player. * @return The added {@link Argument} * @throws IllegalArgumentException if an argument with the specified name is already registered * for this command if the argument option is a sub command option and the command already has * an sub command argument or if the argument option is a sub command option and the command * is a sub command. */ public Argument addArgument(String name, ArgRequirement requirement, SingleOption option) { Argument argument = new Argument(name, requirement, option); if (getAllArguments().containsKey(name.toLowerCase())) { throw new IllegalArgumentException( "The command already has an argument with the name '" + name + "'!"); } if (argument.option() instanceof SubCmdO) { if (isSub()) { throw new IllegalArgumentException( "Sub commands can not have sub command arguments. [argument=" + name + "]"); } for (Argument arg : arguments.values()) { if (arg.option() instanceof SubCmdO) { throw new IllegalArgumentException( "The command already has a sub command argument." + "Commands can only have one sub command option. [argument=" + name + "]"); } } } arguments.put(name.toLowerCase(), argument); return argument; }
@Test public void testcheckBlank() { Argument.checkBlank(null, "message"); Argument.checkBlank("", "message"); Argument.checkBlank(" ", "message"); Argument.checkBlank(" \n\r\t ", "message"); }
private void declTexteFormu(Programme prog, StringBuffer buf, int indent, Argument arg) { if (arg.avecTexteRadio()) { String zone = "zone_" + arg.nom; zone = Divers.remplacer(zone, ".", "_"); String group = "group_" + arg.nom; group = Divers.remplacer(group, ".", "_"); Divers.indenter(buf, indent); Divers.ecrire(buf, "ButtonGroup " + group + "; "); String p_group = "p_" + group; Divers.indenter(buf, indent); Divers.ecrire(buf, "JPanel " + p_group + "; "); String[] liste = arg.getTexteRadio(); int n = liste.length; for (int i = 0; i < n; i++) { Divers.indenter(buf, indent); String zone_bouton = "zone_" + liste[i] + "_" + arg.nom; zone_bouton = Divers.remplacer(zone_bouton, ".", "_"); Divers.ecrire(buf, "JRadioButton " + zone_bouton + "; "); } } else if (arg.avecTexteListe()) { String zone = "zone_" + arg.nom; zone = Divers.remplacer(zone, ".", "_"); String model = "model_" + arg.nom; model = Divers.remplacer(model, ".", "_"); Divers.indenter(buf, indent); Divers.ecrire(buf, "JList " + zone + "; "); Divers.indenter(buf, indent); Divers.ecrire(buf, "DefaultListModel " + model + "; "); } else { String zone = "zone_" + arg.nom; zone = Divers.remplacer(zone, ".", "_"); Divers.indenter(buf, indent); Divers.ecrire(buf, "JTextField " + zone + "; "); } }
@Test public void argTest() { startTest("arg test"); attr = Method.Create("name():String"); assertNotNull(attr); assertTrue(attr.getParameters().isEmpty()); attr = Method.Create("name ( ) : String"); assertNotNull(attr); assertTrue(attr.getParameters().isEmpty()); attr = Method.Create(" name ( index : int ): String "); assertNotNull(attr); // only type of an argument matters assertTrue(attr.getParameters().contains(Argument.Create("x : int"))); assertTrue(attr.getParameters().size() == 1); attr = Method.Create("add ( int x, int y ) : int"); assertNotNull(attr); assertTrue(attr.getParameters().contains(Argument.Create("x : int"))); assertTrue(attr.getParameters().size() == 2); passed(); }
public LightDevice() throws InvalidDescriptionException { super(new File(DESCRIPTION_FILE_NAME)); setSSDPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null)); setHTTPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null)); Action getPowerAction = getAction("GetPower"); getPowerAction.setActionListener(this); Action setPowerAction = getAction("SetPower"); setPowerAction.setActionListener(this); ServiceList serviceList = getServiceList(); Service service = serviceList.getService(0); service.setQueryListener(this); powerVar = getStateVariable("Power"); Argument powerArg = getPowerAction.getArgument("Power"); StateVariable powerState = powerArg.getRelatedStateVariable(); AllowedValueList allowList = powerState.getAllowedValueList(); for (int n = 0; n < allowList.size(); n++) System.out.println("[" + n + "] = " + allowList.getAllowedValue(n)); AllowedValueRange allowRange = powerState.getAllowedValueRange(); System.out.println("maximum = " + allowRange.getMaximum()); System.out.println("minimum = " + allowRange.getMinimum()); System.out.println("step = " + allowRange.getStep()); }
@Override public boolean equals(Object o) { if ((o instanceof Argument) == false) return false; Argument p = (Argument) o; return this.name.equals(p.getName()); }
/** * converts a argument scope to a regular array * * @param arg argument scope to convert * @return resulting array */ public static Array toArray(Argument arg) { ArrayImpl trg = new ArrayImpl(); int[] keys = arg.intKeys(); for (int i = 0; i < keys.length; i++) { trg.setEL(keys[i], arg.get(keys[i], null)); } return trg; }
/* verifies that each of our registered parameters has a value, either given or default throws an exeption otherwise */ private void verify() throws Exception { for (Argument parameter : parameters.values()) { if (parameter.getValue() == null && parameter.getDefaultValue() == null) { throw new Exception( String.format("Argument '%s' is required. Please see usage.", parameter.name)); } } }
@Override public <T> T getArgumentValue(String name) { Argument arg = cli.getArgument(name); if (arg == null) { return null; } return getArgumentValue(arg.getIndex()); }
/** * Chooses between two non null items based on the value of one of their argument * * @param first The first item on which make the choice * @param second The second item on which make the choice * @return The choosen item */ @Override protected T choose(T first, T second) { A firstArgument = argument.evaluate(first); if (firstArgument == null) return second; A secondArgument = argument.evaluate(second); if (secondArgument == null) return first; return chooseOnArgument(first, firstArgument, second, secondArgument); }
void setService(Service s) { serviceNode = s.getServiceNode(); /*To ensure integrity of the XML structure*/ Iterator<Argument> i = getArgumentList().iterator(); while (i.hasNext()) { Argument arg = i.next(); arg.setService(s); } }
private void clearOutputAgumentValues() { ArgumentList allArgList = getArgumentList(); int allArgCnt = allArgList.size(); for (int n = 0; n < allArgCnt; n++) { Argument arg = allArgList.getArgument(n); if (arg.isOutDirection() == false) continue; arg.setValue(""); } }
/** * Finds the argument named <code>strArgName</code> in the specific intrinsic argument list and * returns its number. * * @param rgArgs The array of arguments * @param strArgName The generic name of the argument (defined in {@link Globals}) for which to * look * @return The number of the argument (i.e., the index within the <code>rgArgs</code> array), or * {@link InstructionListTranslator#UNDEFINED} if the argument couldn't be found */ private static int getArgNum(Argument[] rgArgs, String strArgName) { Argument arg = null; if (Globals.ARGNAME_LHS.equals(strArgName)) arg = Arguments.getLHS(rgArgs); else if (Globals.ARGNAME_RHS.equals(strArgName)) arg = Arguments.getRHS(rgArgs); else arg = Arguments.getNamedArgument(rgArgs, strArgName); return arg == null ? UNDEFINED : arg.getNumber(); }
/** * Helper to specify which arguments trigger a refresh on change * * @param ver */ @Override protected void registered(RequestServer.API_VERSION ver) { super.registered(ver); for (Argument arg : _arguments) { if (arg._name.equals("validation")) { arg.setRefreshOnChange(); } } }
@Override public Set<VariableRef> getReadsFrom() { Set<VariableRef> s = new HashSet<VariableRef>(); for (Argument a : args) { if (a.getValue() instanceof VariableRef) { s.add((VariableRef) a.getValue()); } } return s; }
public Argument getArgument(String name) { int nArgs = size(); for (int n = 0; n < nArgs; n++) { Argument arg = getArgument(n); String argName = arg.getName(); if (argName == null) continue; if (argName.equals(name) == true) return arg; } return null; }
/** @deprecated */ public void set(ArgumentList inArgList) { int nInArgs = inArgList.size(); for (int n = 0; n < nInArgs; n++) { Argument inArg = inArgList.getArgument(n); String inArgName = inArg.getName(); Argument arg = getArgument(inArgName); if (arg == null) continue; arg.setValue(inArg.getValue()); } }
@Override public boolean isDynamic() { for (Argument argument : getArguments()) { if (argument.isDynamic()) { return true; } } return false; }
protected JsonObject serveHelp() { JsonObject r = new JsonObject(); r.addProperty(NAME, getClass().getSimpleName()); r.addProperty(DESCRIPTION, _requestHelp); JsonArray args = new JsonArray(); for (Argument arg : _arguments) { args.add(arg.requestHelp()); } r.add(ARGUMENTS, args); return r; }
/** * Add a return argument to this entity. * * @exception IllegalActionException If the argument with the name "return" is not of an * acceptable class for the container. * @exception NameDuplicationException If there is already an argument with the name "return" */ public void addArgumentReturn() throws IllegalActionException, NameDuplicationException { try { _workspace.getReadAccess(); Argument ret = new Argument(this, "return"); ret.setReturn(true); ret.setCType("void"); } finally { _workspace.doneReading(); } }
public ArgumentList getOutputArgumentList() { ArgumentList allArgList = getArgumentList(); int allArgCnt = allArgList.size(); ArgumentList argList = new ArgumentList(); for (int n = 0; n < allArgCnt; n++) { Argument arg = allArgList.getArgument(n); if (arg.isOutDirection() == false) continue; argList.add(arg); } return argList; }
/** * Try to get an array with sub commands that this command has. * * <p>If this command doesn't have sub commands this will return {@code null}. See {@link * #hasSubCmds()} * * @return Array with {@link SubCmd}s (May be {@code null} when the command doesn't have sub * commands) */ public SubCmd[] getSubCmds() { if (isSub() || arguments.size() < 1) { return null; } for (Argument arg : arguments.values()) { if (arg.option() instanceof SubCmdO) { return ((SubCmdO) arg.option()).getSubCmds(); } } return null; }
void updateArgumentList(TreeNode parentNode, Action action) { ArgumentList argList = action.getArgumentList(); int nArguments = argList.size(); for (int n = 0; n < nArguments; n++) { Argument arg = argList.getArgument(n); String argName = arg.getName() + "(" + arg.getDirection() + ")"; TreeNode argNode = new TreeNode(argName); argNode.setUserData(arg); parentNode.add(argNode); } }