X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.application%2Fsrc%2Forg%2Fsimantics%2Fapplication%2Farguments%2FIArgumentFactory.java;h=856d604fe97c8951a56a21a603464a5e2cc48952;hb=0ae2b770234dfc3cbb18bd38f324125cf0faca07;hp=df854bb3436f35f9ae7ada64178e342f68a4c019;hpb=969bd23cab98a79ca9101af33334000879fb60c5;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
index df854bb34..856d604fe 100644
--- a/bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java
+++ b/bundles/org.simantics.application/src/org/simantics/application/arguments/IArgumentFactory.java
@@ -1,202 +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;
-        }
-    }
-
-}
+/*******************************************************************************
+ * 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;
+        }
+    }
+
+}