public code v1

plugins/afryca.parametervalueconverterhelper/src/afryca/parametervalueconverterhelper/AbstractParameterValueConverterHelper.java

@@ -0,0 +1,28 @@
+package afryca.parametervalueconverterhelper;
+
+import org.eclipse.core.commands.AbstractParameterValueConverter;
+import org.eclipse.core.commands.ParameterValueConversionException;
+
+public abstract class AbstractParameterValueConverterHelper extends AbstractParameterValueConverter {
+	
+	protected ParameterValueConverterHelper helper;
+	
+	@Override
+	public Object convertToObject(String parameterValue) throws ParameterValueConversionException {
+		try {
+			return helper.convertToObject(parameterValue);
+		} catch (ParameterValueConverterHelperException e) {
+			throw new ParameterValueConversionException(e.getMessage());
+		}
+	}
+
+	@Override
+	public String convertToString(Object parameterValue) throws ParameterValueConversionException {
+		try {
+			return helper.convertToString(parameterValue);
+		} catch (ParameterValueConverterHelperException e) {
+			throw new ParameterValueConversionException(e.getMessage());
+		}
+	}
+
+}

plugins/afryca.parametervalueconverterhelper/src/afryca/parametervalueconverterhelper/ParameterValueConverterHelper.java

@@ -0,0 +1,486 @@
+package afryca.parametervalueconverterhelper;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Abstract class for serialize/deserialize parameters
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public abstract class ParameterValueConverterHelper {
+
+	public static final String DISABLE_FORMAT = "DISABLE_FORMAT"; //$NON-NLS-1$
+
+	private static class Element implements Comparable<Element> {
+		int pos;
+		boolean open;
+
+		Element(int pos, boolean open) {
+			this.pos = pos;
+			this.open = open;
+		}
+
+		static List<Element> merge(List<Integer> o, List<Integer> c) {
+			List<Element> result = new ArrayList<Element>();
+			for (Integer m : o) {
+				result.add(new Element(m, true));
+			}
+			for (Integer m : c) {
+				result.add(new Element(m, false));
+			}
+			Collections.sort(result);
+			return result;
+		}
+
+		static int[] reduce(List<Integer> o, List<Integer> c) {
+			List<Element> elements = merge(o, c);
+			List<Integer> heap = new ArrayList<Integer>();
+			for (Element element : elements) {
+				if (element.open) {
+					heap.add(element.pos);
+				} else {
+					if (heap.size() == 1) {
+						return new int[] { heap.get(0), element.pos };
+					} else {
+						heap.remove(heap.size() - 1);
+					}
+				}
+			}
+			return null;
+		}
+
+		@Override
+		public int compareTo(Element o) {
+			return Integer.compare(pos, o.pos);
+		}
+	}
+
+	public static String plural(String value) {
+		return value + "S"; //$NON-NLS-1$
+	}
+
+	public static String singular(String value) {
+		return value.substring(0, value.length() - 1);
+	}
+
+	public static String extractElement(String value, String mark) {
+		String openMark = openMark(mark);
+		String closeMark = closeMark(mark);
+		List<Integer> openMarks = findMarksPositions(value, openMark);
+		List<Integer> closeMarks = findMarksPositions(value, closeMark);
+		if (openMarks.isEmpty() && closeMarks.isEmpty()) {
+			return ""; //$NON-NLS-1$
+		} else if (openMarks.size() != closeMarks.size()) {
+			return ""; //$NON-NLS-1$
+		} else {
+			int[] pos = Element.reduce(openMarks, closeMarks);
+			if (pos != null) {
+				return value.substring(pos[0], pos[1] + closeMark.length());
+			} else {
+				return ""; //$NON-NLS-1$
+			}
+		}
+	}
+
+	public static String extractElementValue(String value, String mark) {
+		String result = extractElement(value, mark);
+		if (!result.isEmpty()) {
+			result = removeMarks(result, mark);
+		}
+		return result;
+	}
+
+	public static List<Integer> findMarksPositions(String value, String mark) {
+		List<Integer> result = new ArrayList<Integer>();
+		int pos = 0;
+		int index;
+		int length = mark.length();
+		while (value.indexOf(mark) != -1) {
+			index = value.indexOf(mark);
+			pos += index;
+			result.add(pos);
+			pos += length;
+			value = value.substring(index + length);
+		}
+		return result;
+	}
+
+	public static Integer getInteger(Map<String, String> fields, String mark) {
+		return Integer.parseInt(fields.get(mark));
+	}
+
+	public static Boolean getBoolean(Map<String, String> fields, String mark) {
+		return Boolean.parseBoolean(fields.get(mark));
+	}
+
+	public static String getString(Map<String, String> fields, String mark) {
+		return fields.get(mark);
+	}
+
+	public static String getStringWithoutFormat(Map<String, String> fields, String mark) {
+		return readDisabledFormat(fields.get(mark));
+	}
+
+	public <T> T getInstanceOfThis(Map<String, String> fields, String mark, Class<T> type)
+			throws ParameterValueConverterHelperException {
+		String value = getString(fields, mark);
+		if (value == null) {
+			return null;
+		} else if (value.isEmpty()) {
+			return null;
+		} else {
+			return type.cast(convertToObject(value));
+		}
+	}
+
+	public static <T> List<T> getList(Map<String, String> fields, String mark, String elementMark, Class<?> helper,
+			Class<T> type) throws ParameterValueConverterHelperException {
+		try {
+			return extract(fields.get(mark), elementMark, helper, type);
+		} catch (Exception e) {
+			return new ArrayList<T>();
+		}
+	}
+
+	public static List<String> getList(Map<String, String> fields, String mark, String elementMark)
+			throws ParameterValueConverterHelperException {
+		try {
+			return getMultipleEntriesValues(fields.get(mark), elementMark);
+		} catch (Exception e) {
+			return new ArrayList<>();
+		}
+	}
+
+	public static <T> T getObject(Map<String, String> fields, String mark, Class<?> helper, Class<T> type)
+			throws ParameterValueConverterHelperException {
+		try {
+			String value = getString(fields, mark);
+			if (value == null) {
+				return null;
+			} else if (value.isEmpty()) {
+				return null;
+			} else {
+				ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+				return type.cast(helperInstance.convertToObject(value));
+			}
+		} catch (InstantiationException | IllegalAccessException e) {
+			return null;
+		}
+	}
+
+	public static List<String> getMultipleEntries(String value, String mark) {
+		List<String> result = new ArrayList<String>();
+		String element;
+		do {
+			element = extractElement(value, mark);
+			int pos;
+			if (!element.isEmpty()) {
+				pos = value.indexOf(element);
+				value = value.substring(0, pos) + value.substring(pos + element.length());
+				result.add(element);
+			}
+		} while (!element.isEmpty());
+		return result;
+	}
+
+	public static List<String> getMultipleEntriesValues(String value, String mark) {
+		List<String> result = new ArrayList<String>();
+		String element;
+		do {
+			element = extractElement(value, mark);
+			int pos;
+			if (!element.isEmpty()) {
+				pos = value.indexOf(element);
+				value = value.substring(0, pos) + value.substring(pos + element.length());
+				result.add(extractElementValue(element, mark));
+			}
+		} while (!element.isEmpty());
+		return result;
+	}
+
+	public static Map<String, String> getMap(Map<String, String> fields, String mark, String entryMark, String keyMark,
+			String valueMark) throws ParameterValueConverterHelperException {
+		Map<String, String> result = new HashMap<>();
+		for (String entry : getMultipleEntries(fields.get(mark), entryMark)) {
+			result.put(extractElementValue(entry, keyMark), extractElementValue(entry, valueMark));
+		}
+		return result;
+	}
+
+	public static <T> Map<String, T> getObjectMap(Map<String, String> fields, String mark, String entryMark,
+			String keyMark, String valueMark, Class<?> helper, Class<T> type)
+			throws ParameterValueConverterHelperException {
+		Map<String, T> result = new HashMap<>();
+		try {
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			for (String entry : getMultipleEntries(fields.get(mark), entryMark)) {
+				result.put(extractElementValue(entry, keyMark),
+						type.cast(helperInstance.convertToObject(extractElement(entry, valueMark))));
+			}
+			return result;
+		} catch (InstantiationException | IllegalAccessException e) {
+		}
+		return result;
+	}
+
+	public static Map<String, Boolean> getBooleanMap(Map<String, String> fields, String mark, String entryMark,
+			String keyMark, String valueMark) throws ParameterValueConverterHelperException {
+		Map<String, Boolean> result = new HashMap<>();
+		for (String entry : getMultipleEntries(fields.get(mark), entryMark)) {
+			result.put(extractElementValue(entry, keyMark),
+					Boolean.parseBoolean(extractElementValue(entry, valueMark)));
+		}
+		return result;
+	}
+
+	public static Map<String, Integer> getIntegerMap(Map<String, String> fields, String mark, String entryMark,
+			String keyMark, String valueMark) throws ParameterValueConverterHelperException {
+		Map<String, Integer> result = new HashMap<>();
+		for (String entry : getMultipleEntries(fields.get(mark), entryMark)) {
+			result.put(extractElementValue(entry, keyMark), Integer.parseInt(extractElementValue(entry, valueMark)));
+		}
+		return result;
+	}
+
+	public static Map<String, String> extractFields(String value, String[] fields) {
+		Map<String, String> result = new HashMap<String, String>();
+		String element;
+		int pos;
+		for (String field : sortFields(value, fields)) {
+			element = extractElement(value, field);
+			pos = value.indexOf(element);
+			value = value.substring(0, pos) + value.substring(pos + element.length());
+			result.put(field, element);
+		}
+		return result;
+	}
+
+	public static Map<String, String> extractFieldsValue(String value, String[] fields) {
+		Map<String, String> result = new HashMap<String, String>();
+		String element;
+		int pos;
+		for (String field : sortFields(value, fields)) {
+			element = extractElement(value, field);
+			pos = value.indexOf(element);
+			value = value.substring(0, pos) + value.substring(pos + element.length());
+			result.put(field, removeMarks(element, field));
+		}
+		return result;
+	}
+
+	private static String[] sortFields(String value, String[] fields) {
+		String[] result = new String[fields.length];
+		Map<Integer, String> positions = new HashMap<Integer, String>();
+		List<Integer> orderedPositions = new ArrayList<Integer>();
+		for (String field : fields) {
+			orderedPositions.add(value.indexOf(field));
+			positions.put(orderedPositions.get(orderedPositions.size() - 1), field);
+		}
+		Collections.sort(orderedPositions);
+		for (int i = 0; i < orderedPositions.size(); i++) {
+			result[i] = positions.get(orderedPositions.get(i));
+		}
+		return result;
+	}
+
+	public static String removeMarks(String value, String mark) {
+		String open = openMark(mark);
+		int startPos = value.indexOf(open) + open.length();
+		String close = closeMark(mark);
+		int endPos = value.lastIndexOf(close);
+		return value.substring(startPos, endPos);
+	}
+
+	public static String openMark(String mark) {
+		return "<" + mark + ">"; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+	public static String closeMark(String mark) {
+		return "</" + mark + ">"; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+
+	public static String marker(String mark) {
+		return openMark(mark) + closeMark(mark);
+	}
+
+	public static String marker(Object value, String mark) {
+		return (value == null)
+				? marker(mark)
+				: openMark(mark) + value + closeMark(mark);
+	}
+
+	public static String markerWithoutFormat(Object value, String mark) {
+		return MessageFormat.format(
+				"{0}{1}", //$NON-NLS-1$
+				DISABLE_FORMAT,
+				MessageFormat.format(
+						"{0}\n{1}\n{2}", //$NON-NLS-1$
+						openMark(mark),
+						value == null ? "" : value, //$NON-NLS-1$
+						closeMark(mark)));
+	}
+	
+	private static String readDisabledFormat(String value) {
+		String result = (value != null) ? value : ""; //$NON-NLS-1$
+		if (result.startsWith("\n")) { //$NON-NLS-1$
+			result = result.substring(1);
+		}
+		while(result.endsWith("\t")) {//$NON-NLS-1$
+			result = result.substring(0, result.length() - 1);
+		}
+		if (result.endsWith("\n")) { //$NON-NLS-1$
+			result = result.substring(0, result.length() - 1);
+		}
+		return result;
+	}
+
+	public static String marker(String[] values, String mark) {
+		StringBuilder result = new StringBuilder("\n"); //$NON-NLS-1$
+		for (String value : values) {
+			result.append(tabulate(value));
+			result.append("\n"); //$NON-NLS-1$
+		}
+		return marker(result.toString(), mark);
+	}
+
+	private static String tabulate(String value) {
+		if (value != null) {
+			if (value.startsWith(DISABLE_FORMAT)) {
+				String buffer = value.substring(DISABLE_FORMAT.length());
+				String[] lines = buffer.split("\n"); //$NON-NLS-1$
+				lines[0] = "\t" + lines[0]; //$NON-NLS-1$
+				if (lines.length >= 2) {
+					lines[lines.length - 1] = "\t" + lines[lines.length - 1]; //$NON-NLS-1$
+				}
+				return String.join("\n", lines); //$NON-NLS-1$
+			} else {
+				return Arrays.stream(value.split("\n")) //$NON-NLS-1$
+						.map(line -> "\t" + line) //$NON-NLS-1$
+						.collect(Collectors.joining("\n"));//$NON-NLS-1$
+			}
+		}
+		return null;
+	}
+
+	public static <T> List<T> extract(String value, String mark, Class<?> helper, Class<T> type) {
+		List<T> result = new ArrayList<>();
+		try {
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			for (String entry : getMultipleEntries(value, mark)) {
+				result.add(type.cast(helperInstance.convertToObject(entry)));
+			}
+			return result;
+		} catch (Exception e) {
+			return result;
+		}
+	}
+
+	public static String marker(List<?> input, String mark, Class<?> helper) {
+		try {
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			String[] values = new String[input.size()];
+			for (int i = 0; i < values.length; i++) {
+				values[i] = nest(helperInstance.convertToString(input.get(i)));
+			}
+			return marker(values, mark);
+		} catch (Exception e) {
+			return marker(mark);
+		}
+	}
+
+	public static String markList(List<String> input, String mark, String entryMark) {
+		return markArray(input.toArray(new String[0]), mark, entryMark);
+	}
+
+	public static String markArray(String[] input, String mark, String entryMark) {
+		return marker(markMultiple(input, entryMark), mark);
+	}
+
+	public static String markMultiple(String[] input, String mark) {
+		StringBuilder result = new StringBuilder("\n"); //$NON-NLS-1$
+		for (String value : input) {
+			result.append(tabulate(marker(value, mark)));
+			result.append("\n"); //$NON-NLS-1$
+		}
+		return result.toString();
+	}
+
+	public static String marker(Object input, String mark, Class<?> helper) {
+		try {
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			return marker(nest(helperInstance.convertToString(input)), mark);
+		} catch (Exception e) {
+			return marker(mark);
+		}
+	}
+
+	public static String markArray(Object[] input, String mark, Class<?> helper) {
+		try {
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			String[] values = new String[input.length];
+			for (int i = 0; i < input.length; i++) {
+				values[i] = nest(helperInstance.convertToString(input[i]));
+			}
+			return marker(values, mark);
+		} catch (Exception e) {
+			return marker(mark);
+		}
+	}
+
+	public static String markMap(Map<?, ?> map, String mark, String entryMark, String keyMark, String valueMark) {
+		try {
+			List<String> result = new ArrayList<String>();
+			if (map != null) {
+				String[] values = new String[2];
+				for (Object key : map.keySet()) {
+					values[0] = marker(key, keyMark);
+					values[1] = marker(map.get(key), valueMark);
+					result.add(marker(values, entryMark));
+				}
+			}
+			return marker(result.toArray(new String[0]), mark);
+		} catch (Exception e) {
+			return marker(mark);
+		}
+	}
+
+	public static String markMap(Map<?, ?> map, String mark, String entryMark, String keyMark, String valueMark,
+			Class<?> helper) {
+		try {
+			List<String> result = new ArrayList<String>();
+			ParameterValueConverterHelper helperInstance = (ParameterValueConverterHelper) helper.newInstance();
+			if (map != null) {
+				String[] values = new String[2];
+				for (Object key : map.keySet()) {
+					values[0] = marker(key, keyMark);
+					values[1] = marker(nest(helperInstance.convertToString(map.get(key))), valueMark);
+					result.add(marker(values, entryMark));
+				}
+			}
+			return marker(result.toArray(new String[0]), mark);
+		} catch (Exception e) {
+			return marker(mark);
+		}
+	}
+
+	private static String nest(String value) {
+		if (value != null) {
+			return "\n" + tabulate(value) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
+		} else {
+			return null;
+		}
+	}
+
+	public abstract Object convertToObject(String parameterValue) throws ParameterValueConverterHelperException;
+
+	public abstract String convertToString(Object parameterValue) throws ParameterValueConverterHelperException;
+
+}

plugins/afryca.parametervalueconverterhelper/src/afryca/parametervalueconverterhelper/ParameterValueConverterHelperException.java

@@ -0,0 +1,16 @@
+package afryca.parametervalueconverterhelper;
+
+/**
+ * Parameter value converter helper exception
+ * 
+ * @author Sinbad²
+ * @version 3.0
+ */
+public class ParameterValueConverterHelperException extends Exception {
+	
+	private static final long serialVersionUID = -968475456041845652L;
+
+	public ParameterValueConverterHelperException(String message) {
+		super(message);
+	}
+}