1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
\r
3 * in Industry THTH ry.
\r
4 * All rights reserved. This program and the accompanying materials
\r
5 * are made available under the terms of the Eclipse Public License v1.0
\r
6 * which accompanies this distribution, and is available at
\r
7 * http://www.eclipse.org/legal/epl-v10.html
\r
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.application.arguments;
\r
14 import java.util.ListIterator;
\r
17 * @author Tuukka Lehtonen
\r
21 public interface IArgumentFactory<T> {
\r
23 String getArgument();
\r
25 IArgument<T> parse(String arg, ListIterator<String> tail);
\r
27 abstract class ArgumentFactory<V> implements IArgumentFactory<V> {
\r
29 protected IArgumentValidator<V> validator;
\r
30 public ArgumentFactory(String arg) {
\r
33 public ArgumentFactory(String arg, IArgumentValidator<V> validator) {
\r
35 this.validator = validator;
\r
37 public String getArgument() {
\r
40 protected IArgumentValidator<V> getValidator() {
\r
45 abstract class Argument<T> implements IArgument<T> {
\r
48 public Argument(String key) {
\r
54 public String getArgument() {
\r
58 public abstract T getValue();
\r
61 public String toString() {
\r
62 return "(" + getValue().getClass().getSimpleName() + ") " + getValue().toString();
\r
66 class BooleanArgument extends Argument<Boolean> {
\r
68 public BooleanArgument(String key, Boolean value) {
\r
72 public Boolean getValue() {
\r
77 class StringArgument extends Argument<String> {
\r
79 public StringArgument(String key, String value) {
\r
83 public String getValue() {
\r
88 class IntegerArgument extends Argument<Integer> {
\r
90 public IntegerArgument(String key, Integer value) {
\r
94 public Integer getValue() {
\r
99 class LongArgument extends Argument<Long> {
\r
101 public LongArgument(String key, Long value) {
\r
103 this.value = value;
\r
105 public Long getValue() {
\r
111 class StringArgumentFactory extends ArgumentFactory<String> {
\r
112 public StringArgumentFactory(String key) {
\r
115 public StringArgumentFactory(String key, IArgumentValidator<String> validator) {
\r
116 super(key, validator);
\r
119 public IArgument<String> parse(String key, ListIterator<String> tail) {
\r
120 if (getArgument().equalsIgnoreCase(key)) {
\r
121 if (tail.hasNext()) {
\r
122 String next = tail.next();
\r
123 IArgumentValidator<String> validator = getValidator();
\r
124 if(validator != null) {
\r
125 String valid = validator.isValid(next);
\r
126 if (valid != null) {
\r
128 throw new IllegalArgumentException(valid);
\r
131 return new StringArgument(getArgument(), next);
\r
138 class IntegerArgumentFactory extends ArgumentFactory<Integer> {
\r
139 private Integer lowLimit;
\r
140 private Integer highLimit;
\r
141 public IntegerArgumentFactory(String key) {
\r
142 this(key, null, null);
\r
144 public IntegerArgumentFactory(String key, Integer lowLimit, Integer highLimit) {
\r
146 this.lowLimit = lowLimit;
\r
147 this.highLimit = highLimit;
\r
150 public IArgument<Integer> parse(String key, ListIterator<String> tail) {
\r
151 if (getArgument().equalsIgnoreCase(key)) {
\r
152 if (tail.hasNext()) {
\r
154 Integer l = Integer.valueOf(tail.next());
\r
155 if (lowLimit != null && lowLimit > l)
\r
156 throw new IllegalArgumentException("value is less than low limit, " + l + " < " + lowLimit);
\r
157 if (highLimit != null && highLimit < l)
\r
158 throw new IllegalArgumentException("value is greater than high limit, " + l + " > " + highLimit);
\r
159 return new IntegerArgument(getArgument(), l);
\r
160 } catch (NumberFormatException e) {
\r
161 throw new IllegalArgumentException(e);
\r
169 class LongArgumentFactory extends ArgumentFactory<Long> {
\r
170 public LongArgumentFactory(String key) {
\r
174 public IArgument<Long> parse(String key, ListIterator<String> tail) {
\r
175 if (getArgument().equalsIgnoreCase(key)) {
\r
176 if (tail.hasNext()) {
\r
178 Long l = Long.valueOf(tail.next());
\r
179 return new LongArgument(getArgument(), l);
\r
180 } catch (NumberFormatException e) {
\r
181 throw new IllegalArgumentException(e);
\r
189 class NoValueArgumentFactory extends ArgumentFactory<Boolean> {
\r
190 public NoValueArgumentFactory(String key) {
\r
194 public IArgument<Boolean> parse(String key, ListIterator<String> tail) {
\r
195 if (getArgument().equalsIgnoreCase(key)) {
\r
196 return new BooleanArgument(getArgument(), Boolean.TRUE);
\r