Migrated source code from Simantics SVN

[simantics/platform.git] / bundles / org.simantics.application / src / org / simantics / application / arguments / IArgumentFactory.java

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