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