X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.application%2Fsrc%2Forg%2Fsimantics%2Fapplication%2Farguments%2FIArgumentFactory.java;fp=bundles%2Forg.simantics.application%2Fsrc%2Forg%2Fsimantics%2Fapplication%2Farguments%2FIArgumentFactory.java;h=df854bb3436f35f9ae7ada64178e342f68a4c019;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java b/bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java
new file mode 100644
index 000000000..df854bb34
--- /dev/null
+++ b/bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java
@@ -0,0 +1,202 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.application.arguments;
+
+import java.util.ListIterator;
+
+/**
+ * @author Tuukka Lehtonen
+ *
+ * @param <T>
+ */
+public interface IArgumentFactory<T> {
+
+    String getArgument();
+
+    IArgument<T> parse(String arg, ListIterator<String> tail);
+    
+    abstract class ArgumentFactory<V> implements IArgumentFactory<V> {
+        String arg;
+        protected IArgumentValidator<V> validator;
+        public ArgumentFactory(String arg) {
+            this(arg, null);
+        }
+        public ArgumentFactory(String arg, IArgumentValidator<V> validator) {
+            this.arg = arg;
+            this.validator = validator;
+        }
+        public String getArgument() {
+            return arg;
+        }
+        protected IArgumentValidator<V> getValidator() {
+            return validator;
+        }
+    }
+    
+    abstract class Argument<T> implements IArgument<T> {
+        String key;
+
+        public Argument(String key) {
+            assert key != null;
+            this.key = key;
+        }
+
+        @Override
+        public String getArgument() {
+            return key;
+        }
+
+        public abstract T getValue();
+
+        @Override
+        public String toString() {
+            return "(" + getValue().getClass().getSimpleName() + ") " + getValue().toString();
+        }
+    }
+    
+    class BooleanArgument extends Argument<Boolean> {
+        Boolean value;
+        public BooleanArgument(String key, Boolean value) {
+            super(key);
+            this.value = value;
+        }
+        public Boolean getValue() {
+            return value;
+        }
+    };
+    
+    class StringArgument extends Argument<String> {
+        String value;
+        public StringArgument(String key, String value) {
+            super(key);
+            this.value = value;
+        }
+        public String getValue() {
+            return value;
+        }
+    };
+    
+    class IntegerArgument extends Argument<Integer> {
+        Integer value;
+        public IntegerArgument(String key, Integer value) {
+            super(key);
+            this.value = value;
+        }
+        public Integer getValue() {
+            return value;
+        }
+    };
+
+    class LongArgument extends Argument<Long> {
+        Long value;
+        public LongArgument(String key, Long value) {
+            super(key);
+            this.value = value;
+        }
+        public Long getValue() {
+            return value;
+        }
+    };
+
+    
+    class StringArgumentFactory extends ArgumentFactory<String> {
+        public StringArgumentFactory(String key) {
+            super(key);
+        }
+        public StringArgumentFactory(String key, IArgumentValidator<String> validator) {
+            super(key, validator);
+        }
+        @Override
+        public IArgument<String> parse(String key, ListIterator<String> tail) {
+            if (getArgument().equalsIgnoreCase(key)) {
+                if (tail.hasNext()) {
+                    String next = tail.next();
+                    IArgumentValidator<String> validator = getValidator();
+                    if(validator != null) {
+	                    String valid = validator.isValid(next);
+	                    if (valid != null) {
+	                        tail.previous();
+	                        throw new IllegalArgumentException(valid);
+	                    }
+                    }
+                    return new StringArgument(getArgument(), next);
+                }
+            }
+            return null;
+        }
+    }
+    
+    class IntegerArgumentFactory extends ArgumentFactory<Integer> {
+        private Integer lowLimit;
+        private Integer highLimit;
+        public IntegerArgumentFactory(String key) {
+            this(key, null, null);
+        }
+        public IntegerArgumentFactory(String key, Integer lowLimit, Integer highLimit) {
+            super(key);
+            this.lowLimit = lowLimit;
+            this.highLimit = highLimit;
+        }
+        @Override
+        public IArgument<Integer> parse(String key, ListIterator<String> tail) {
+            if (getArgument().equalsIgnoreCase(key)) {
+                if (tail.hasNext()) {
+                    try {
+                        Integer l = Integer.valueOf(tail.next());
+                        if (lowLimit != null && lowLimit > l)
+                            throw new IllegalArgumentException("value is less than low limit, " + l + " < " + lowLimit);
+                        if (highLimit != null && highLimit < l)
+                            throw new IllegalArgumentException("value is greater than high limit, " + l + " > " + highLimit);
+                        return new IntegerArgument(getArgument(), l);
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException(e);
+                    }
+                }
+            }
+            return null;
+        }
+    }
+    
+    class LongArgumentFactory extends ArgumentFactory<Long> {
+        public LongArgumentFactory(String key) {
+            super(key);
+        }
+        @Override
+        public IArgument<Long> parse(String key, ListIterator<String> tail) {
+            if (getArgument().equalsIgnoreCase(key)) {
+                if (tail.hasNext()) {
+                    try {
+                        Long l = Long.valueOf(tail.next());
+                        return new LongArgument(getArgument(), l);
+                    } catch (NumberFormatException e) {
+                        throw new IllegalArgumentException(e);
+                    }
+                }
+            }
+            return null;
+        }
+    }
+    
+    class NoValueArgumentFactory extends ArgumentFactory<Boolean> {
+        public NoValueArgumentFactory(String key) {
+            super(key);
+        }
+        @Override
+        public IArgument<Boolean> parse(String key, ListIterator<String> tail) {
+            if (getArgument().equalsIgnoreCase(key)) {
+                return new BooleanArgument(getArgument(), Boolean.TRUE);
+            }
+            return null;
+        }
+    }
+
+}