001: /**
002: * Objective Database Abstraction Layer (ODAL)
003: * Copyright (c) 2004, The ODAL Development Group
004: * All rights reserved.
005: * For definition of the ODAL Development Group please refer to LICENCE.txt file
006: *
007: * Distributable under LGPL license.
008: * See terms of license at gnu.org.
009: */package com.completex.objective.util.cmd;
010:
011: import java.util.ArrayList;
012: import java.util.Map;
013: import java.util.Properties;
014:
015: /**
016: * @author Gennady Krizhevsky
017: */
018: public final class CmdLine {
019:
020: private static boolean DEBUG = false;
021: private String appName = null;
022: private StringBuffer[] inputArgs;
023: private ArrayList args = new ArrayList();
024: private Map arguments;
025: private String[] params;
026: private String[] flags;
027: private String extra;
028:
029: private void add(ArgProcessor processor, AbstractArg argCmd) {
030: processor.add(argCmd);
031: args.add(argCmd);
032: }
033:
034: private void checkArgs(String[] params, String[] flags) {
035: boolean anythingSet = false;
036: for (int i = 0; i < args.size(); i++) {
037: AbstractArg this Arg = (AbstractArg) args.get(i);
038: if (this Arg.isInitialized()) {
039: anythingSet = true;
040: break;
041: }
042: }
043: if (!anythingSet) {
044: String usage = "";
045: try {
046: String className = appName == null ? "{ClassName} "
047: : appName + " ";
048: usage = getUsage(className, params, flags, extra);
049: } catch (Exception e) {
050: // Wait until later ...
051: }
052:
053: throw new IllegalArgumentException(
054: "No valid command-line arguments found\n" + usage);
055: }
056: }
057:
058: private Object getArg(String key) {
059: return getArg(key, false);
060: }
061:
062: private Object getArg(String key, boolean required) {
063: AbstractArg gc = (AbstractArg) arguments.get(key);
064: if (gc != null) {
065: return gc.getValue();
066: } else if (required) {
067: String usage = "";
068: try {
069: usage = getUsage(appName, params, flags, extra);
070: } catch (Exception e) {
071: // Wait until later ...
072: }
073: throw new IllegalArgumentException("Required parameter ["
074: + key + "] not found\n" + usage);
075: }
076: return null;
077: }
078:
079: private Object getArg(String key, Object defaultObject) {
080: AbstractArg gc = (AbstractArg) arguments.get(key);
081: if (gc != null) {
082: return gc.getValue();
083: } else {
084: if (defaultObject == null) {
085: return null;
086: } else {
087: return new StringBuffer(defaultObject.toString());
088: }
089: }
090: }
091:
092: public boolean getFlag(String key) {
093: Boolean flag = (Boolean) getArg(key);
094: if (flag != null)
095: return flag.booleanValue();
096: return false;
097: }
098:
099: public String getParam(String key) {
100: return getParam(key, false);
101: }
102:
103: public String getParam(String key, Object defaultObject) {
104: StringBuffer sb = (StringBuffer) getArg(key, defaultObject);
105: if (sb != null) {
106: return sb.toString();
107: }
108: return null;
109: }
110:
111: public String getParam(String key, boolean required) {
112: StringBuffer sb = (StringBuffer) getArg(key, required);
113: if (sb != null && sb.length() > 0) {
114: return sb.toString();
115: } else if (required) {
116: String usage = "";
117: try {
118: usage = getUsage(appName, params, flags, extra);
119: } catch (Exception e) {
120: // Wait until later ...
121: }
122: throw new IllegalArgumentException("Required parameter ["
123: + key + "] not found\n" + usage);
124: }
125: return null;
126: }
127:
128: public CmdLine(String[] args, String[] params) {
129: this (args, params, (String) null);
130: }
131:
132: public CmdLine(String[] args, String[] params, String extra) {
133: this (args, params, null, extra);
134: }
135:
136: public CmdLine(String[] args, String[] params, String[] flags) {
137: this (null, args, params, flags, null);
138: }
139:
140: public CmdLine(String[] args, String[] params, String[] flags,
141: String extra) {
142: this (null, args, params, flags, extra);
143: }
144:
145: public CmdLine(String app, String[] args, String[] params,
146: String[] flags, String extra) {
147: this .appName = app;
148: this .params = params;
149: this .flags = flags;
150: this .extra = extra;
151:
152: inputArgs = new StringBuffer[params.length];
153: for (int i = 0; i < params.length; i++) {
154: inputArgs[i] = new StringBuffer("");
155: }
156: arguments = processArgs(args, params, flags);
157: }
158:
159: public String getUsage() {
160: return getUsage(appName, params, flags, extra);
161: }
162:
163: public String getUsage(String appName, String[] params,
164: String[] flags, String extra) {
165: extra = extra == null ? "" : extra;
166: return getUsage0(appName, params, flags) + extra;
167: }
168:
169: private String getUsage0(String appName, String[] params,
170: String[] flags) {
171: String usage = "USAGE: \n"
172: + (appName == null ? "<appClass>" : appName);
173: if (params != null && params.length > 0) {
174: for (int i = 0; i < params.length; i++) {
175: String name = params[i];
176: if (name != null && name.startsWith("-")) {
177: name = name.substring(1);
178: }
179: usage += " [" + params[i] + " <" + name + "_value>]";
180: }
181: }
182: if (flags != null && flags.length > 0) {
183: for (int i = 0; i < flags.length; i++) {
184: usage += " [" + flags[i] + "]";
185: }
186: }
187: return usage;
188: }
189:
190: private Map processArgs(String args[], String[] params,
191: String[] flags) {
192: ArgProcessor processor = new ArgProcessor(args);
193: if (params != null) {
194: for (int i = 0; i < params.length; i++) {
195: if (DEBUG)
196: System.out.println("CmdLine::processArgs: "
197: + "; inputArgs[" + i + "]=" + inputArgs[i]
198: + "; params[" + i + "]=" + params[i]);
199: add(processor, new NamedArg(params[i], inputArgs[i]));
200: }
201: }
202: if (flags != null) {
203: FlagArg[] flagArg = new FlagArg[flags.length];
204: for (int i = 0; i < flags.length; i++) {
205: flagArg[i] = new FlagArg(flags[i], true);
206: add(processor, flagArg[i]);
207: }
208: }
209: Map arguments = processor.process();
210: checkArgs(params, flags);
211: return arguments;
212: }
213:
214: public static String[] properties2args(Properties properties,
215: String[] labels, String[] flags) {
216: String[] args = new String[labels.length * 2 + flags.length];
217: int k = 0;
218: for (int i = 0; i < labels.length; i++, k = i * 2) {
219: args[k] = labels[i];
220: args[k + 1] = (String) properties.get(labels[i]);
221: System.out.println("args[ " + (k + 1) + "] = "
222: + args[k + 1]);
223: }
224: for (int i = 0; i < flags.length; i++, k++) {
225: System.out.println("args[ " + (k) + "] = " + args[k]);
226: args[k] = flags[i];
227: }
228: return args;
229: }
230:
231: public static void main(String args[]) {
232: int rc = 0;
233: String labels[] = { "-host", "-port", "-message", "-threads" };
234: String flags[] = { "-debug", "-verbose" };
235: CmdLine cline;
236: try {
237: cline = new CmdLine(args, labels, flags);
238: String host = cline.getParam("-host");
239: String port = cline.getParam("-port", true);
240: String message = cline.getParam("-message");
241: String threads = cline.getParam("-threads");
242: boolean debug = cline.getFlag("-debug");
243: boolean verbose = cline.getFlag("-verbose");
244: System.out.println("host=" + host);
245: System.out.println("port=" + port);
246: System.out.println("message=" + message);
247: System.out.println("threads=" + threads);
248: System.out.println("debug=" + debug);
249: System.out.println("verbose=" + verbose);
250: } catch (Exception e) {
251: e.printStackTrace();
252: rc = 1;
253: }
254: System.exit(rc);
255: }
256:
257: }
|