Java Doc for Arguments.java in  » Science » Cougaar12_4 » org » cougaar » util » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Note that Arguments instances are unmodifiable, like Strings.

Example use:

 Arguments args = new Arguments("x=y, q=one, q=two, z=99");
 String x = args.getString("x");
 assert "y".equals(x);
 int z = args.getInt("z", 1234);
 assert z == 99;
 List<String> q = args.getStrings("q");
 assert q != null && q.size() == 2;
 

The Cougaar component model includes built-in support to invoke an optional "setArguments" method. Here's an example:

 package org;
 public class MyPlugin ... {
 private Arguments args;
 // The "setArguments" method is special -- it's an optional method
 // that's found by the component model via reflection.  The passed-in
 // arguments instance is created via:
 //    new Arguments(listOfStrings, classname);
 public void setArguments(Arguments args) { this.args = args; }
 public void load() {
 super.load();
 // Get the value of our "foo" argument
 //
 // First looks for a plugin XML argument named "foo",
 // next looks for a "-Dorg.MyPlugin.foo=" system property,
 // otherwise the value will be the 1234 default.
 int foo = args.getInt("foo", 1234);
 System.out.println("foo is "+foo);
 }
 }
 

The Arguments.callSetters method supports "setter" reflection, for example:

 package org;
 public class MyPlugin ... {
 private int foo = 1234;
 public void setArguments(Arguments args) { args.callSetters(this); }
 // This "setNAME(TYPE)" method is found by reflection.
 // The args class will only invoke the setters for which it has values.
 public void setFoo(int i) { this.foo = i; }
 public void load() {
 super.load();
 System.out.println("foo is "+foo);
 }
 }
 

 For example, if our map contains:
 A=B
 X=V0,V1,V2
 then:
 toString("the_$key is the_$value", " * ");
 would return:
 the_A is the_B * the_X is the_V0
 and:
 toString("($key eq $vals)", " +\n");
 would return:
 (A eq B) +
 (X eq [V0, V1, V2])
 and:
 toString("$key=$veach", "&");
 would return a URL-like string:
 A=B&X=V0&X=V1&X=V2
 and:
 "{" + toString("$key=$vlist", ", ") + "}";
 would return the standard 
Map.toString  format:
 {A=[B], X=[V0, V1, V2]}
 

• "$key" is the string key name (e.g.

For example, the name=value pair "x=y" will look for:

 public void setX(type) {..}
 

 public type x;
 

Equivalent to:

 List<String> l = get(key);
 return (l == null ? deflt : l.get(0));
 

Equivalent to:

 List<String> l = get(key);
 return (l == null ? deflt : l);
 

This is useful to group together same-named arguments.

 For example, the constructor input:
 "foo=f1, bar=b1, qux=q1,
 foo=f2, bar=b2, qux=q2,
 foo=f3, bar=b3, qux=q3"
 will be parsed as:
 {foo=[f1,f2,f3], bar=[b1,b2,b3], qux=[q1,q2,q3]}
 and can be split into:
 [{foo=[f1], bar=[b1], qux=[q1]},
 {foo=[f2], bar=[b2], qux=[q2]},
 {foo=[f3], bar=[b3], qux=[q3]}}
 This simplifies iteration:
 for (Arguments a : args.split()) {
 System.out.println("foo is "+a.getString("foo"));
 }
 which will print:
 foo is f1
 foo is f2
 foo is f3
 

In other words:

 // given:
 List<String> v1 = args.getStrings(key1);
 List<String> v2 = args.getStrings(key2);
 // do swap:
 Arguments ret = args.swap(key1, key2);
 // validate:
 assert(ret.size() == args.size());
 List<String> x1 = ret.getStrings(key1);
 List<String> x2 = ret.getStrings(key2);
 assert(v1 == null ? x2 == null : v1.equals(x2));
 assert(v2 == null ? x1 == null : v2.equals(x1));
 

 For example, if our map contains:
 A=B
 X=V0,V1,V2
 then:
 toString("the_$key is the_$value", " * ");
 would return:
 the_A is the_B * the_X is the_V0
 and:
 toString("($key eq $vals)", " +\n");
 would return:
 (A eq B) +
 (X eq [V0, V1, V2])
 and:
 toString("$key=$veach", "&");
 would return a URL-like string:
 A=B&X=V0&X=V1&X=V2
 and:
 "{" + toString("$key=$vlist", ", ") + "}";
 would return the standard 
Map.toString  format:
 {A=[B], X=[V0, V1, V2]}
 

• "$key" is the string key name (e.g. "X")
• "$value" is the first value (e.g. "V0"), as defined in Arguments.getString(String)
• "$vals" is the first value if there is only one value (e.g. "B"), otherwise the list of values prefixed with "[" and "]" if there are multiple values (e.g. "[V0, V1, V2]").
• "$veach" is current value in the list (e.g. "V1")
• "$vlist" is the "[]" wrapped list (e.g. "[B]" or "[V0, V1, V2]")