bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   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
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.application.arguments;
  13
  14 import java.util.ListIterator;
  15
  16 /**
  17  * @author Tuukka Lehtonen
  18  *
  19  * @param <T>
  20  */
  21 public interface IArgumentFactory<T> {
  22
  23     String getArgument();
  24
  25     IArgument<T> parse(String arg, ListIterator<String> tail);
  26
  27     abstract class ArgumentFactory<V> implements IArgumentFactory<V> {
  28         String arg;
  29         protected IArgumentValidator<V> validator;
  30         public ArgumentFactory(String arg) {
  31             this(arg, null);
  32         }
  33         public ArgumentFactory(String arg, IArgumentValidator<V> validator) {
  34             this.arg = arg;
  35             this.validator = validator;
  36         }
  37         public String getArgument() {
  38             return arg;
  39         }
  40         protected IArgumentValidator<V> getValidator() {
  41             return validator;
  42         }
  43     }
  44
  45     abstract class Argument<T> implements IArgument<T> {
  46         String key;
  47
  48         public Argument(String key) {
  49             assert key != null;
  50             this.key = key;
  51         }
  52
  53         @Override
  54         public String getArgument() {
  55             return key;
  56         }
  57
  58         public abstract T getValue();
  59
  60         @Override
  61         public String toString() {
  62             return "(" + getValue().getClass().getSimpleName() + ") " + getValue().toString();
  63         }
  64     }
  65
  66     class BooleanArgument extends Argument<Boolean> {
  67         Boolean value;
  68         public BooleanArgument(String key, Boolean value) {
  69             super(key);
  70             this.value = value;
  71         }
  72         public Boolean getValue() {
  73             return value;
  74         }
  75     };
  76
  77     class StringArgument extends Argument<String> {
  78         String value;
  79         public StringArgument(String key, String value) {
  80             super(key);
  81             this.value = value;
  82         }
  83         public String getValue() {
  84             return value;
  85         }
  86     };
  87
  88     class IntegerArgument extends Argument<Integer> {
  89         Integer value;
  90         public IntegerArgument(String key, Integer value) {
  91             super(key);
  92             this.value = value;
  93         }
  94         public Integer getValue() {
  95             return value;
  96         }
  97     };
  98
  99     class LongArgument extends Argument<Long> {
 100         Long value;
 101         public LongArgument(String key, Long value) {
 102             super(key);
 103             this.value = value;
 104         }
 105         public Long getValue() {
 106             return value;
 107         }
 108     };
 109
 110
 111     class StringArgumentFactory extends ArgumentFactory<String> {
 112         public StringArgumentFactory(String key) {
 113             super(key);
 114         }
 115         public StringArgumentFactory(String key, IArgumentValidator<String> validator) {
 116             super(key, validator);
 117         }
 118         @Override
 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);
 126                             if (valid != null) {
 127                                 tail.previous();
 128                                 throw new IllegalArgumentException(valid);
 129                             }
 130                     }
 131                     return new StringArgument(getArgument(), next);
 132                 }
 133             }
 134             return null;
 135         }
 136     }
 137
 138     class IntegerArgumentFactory extends ArgumentFactory<Integer> {
 139         private Integer lowLimit;
 140         private Integer highLimit;
 141         public IntegerArgumentFactory(String key) {
 142             this(key, null, null);
 143         }
 144         public IntegerArgumentFactory(String key, Integer lowLimit, Integer highLimit) {
 145             super(key);
 146             this.lowLimit = lowLimit;
 147             this.highLimit = highLimit;
 148         }
 149         @Override
 150         public IArgument<Integer> parse(String key, ListIterator<String> tail) {
 151             if (getArgument().equalsIgnoreCase(key)) {
 152                 if (tail.hasNext()) {
 153                     try {
 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);
 162                     }
 163                 }
 164             }
 165             return null;
 166         }
 167     }
 168
 169     class LongArgumentFactory extends ArgumentFactory<Long> {
 170         public LongArgumentFactory(String key) {
 171             super(key);
 172         }
 173         @Override
 174         public IArgument<Long> parse(String key, ListIterator<String> tail) {
 175             if (getArgument().equalsIgnoreCase(key)) {
 176                 if (tail.hasNext()) {
 177                     try {
 178                         Long l = Long.valueOf(tail.next());
 179                         return new LongArgument(getArgument(), l);
 180                     } catch (NumberFormatException e) {
 181                         throw new IllegalArgumentException(e);
 182                     }
 183                 }
 184             }
 185             return null;
 186         }
 187     }
 188
 189     class NoValueArgumentFactory extends ArgumentFactory<Boolean> {
 190         public NoValueArgumentFactory(String key) {
 191             super(key);
 192         }
 193         @Override
 194         public IArgument<Boolean> parse(String key, ListIterator<String> tail) {
 195             if (getArgument().equalsIgnoreCase(key)) {
 196                 return new BooleanArgument(getArgument(), Boolean.TRUE);
 197             }
 198             return null;
 199         }
 200     }
 201
 202 }