[New] Added SetParameterValueFromStringVisitor

li.strolch.model/src/main/java/li/strolch/model/json/ResourceSystemStateFromJson.java

@@ -1,5 +1,7 @@
 package li.strolch.model.json;
 
+import static li.strolch.model.StrolchModelConstants.INTERPRETATION_NONE;
+import static li.strolch.model.StrolchModelConstants.UOM_NONE;
 import static li.strolch.model.StrolchValueType.DATE;
 import static li.strolch.model.StrolchValueType.*;
 import static li.strolch.model.Tags.Json.*;
@@ -13,10 +15,16 @@ import li.strolch.model.Resource;
 import li.strolch.model.StrolchValueType;
 import li.strolch.model.timedstate.StrolchTimedState;
 import li.strolch.model.timevalue.IValue;
+import li.strolch.model.visitor.SetStateValueVisitor;
+import li.strolch.utils.DataUnit;
 
 public class ResourceSystemStateFromJson {
 
 	private long stateTime = System.currentTimeMillis();
+
+	private DataUnit memoryRoundingUnit = DataUnit.Bytes;
+	private DataUnit storageSpaceRoundingUnit = DataUnit.Bytes;
+
 	private boolean systemLoadAverageState;
 	private boolean usableSpaceState;
 	private boolean usedSpaceState;
@@ -30,6 +38,16 @@ public class ResourceSystemStateFromJson {
 	private boolean heapMemoryUsageCommittedState;
 	private boolean compactStates;
 
+	public ResourceSystemStateFromJson withMemoryRounding(DataUnit dataUnit) {
+		this.memoryRoundingUnit = dataUnit;
+		return this;
+	}
+
+	public ResourceSystemStateFromJson withStorageSpaceRounding(DataUnit dataUnit) {
+		this.storageSpaceRoundingUnit = dataUnit;
+		return this;
+	}
+
 	public ResourceSystemStateFromJson compactStates() {
 		this.compactStates = true;
 		return this;
@@ -97,155 +115,211 @@ public class ResourceSystemStateFromJson {
 
 	public void fillElement(JsonObject systemStateJ, Resource resource) {
 
-		if (systemStateJ.has(OPERATING_SYSTEM)) {
+		if (systemStateJ.has(OPERATING_SYSTEM))
-			JsonObject osJ = systemStateJ.get(OPERATING_SYSTEM).getAsJsonObject();
+			handleOperatingSystem(systemStateJ, resource);
 
-			String bagId = OPERATING_SYSTEM;
+		if (systemStateJ.has(MEMORY))
-			String bagName = "Operating System";
+			handleMemory(systemStateJ, resource);
-			String bagType = "OperatingSystem";
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_NAME, "OS Name", STRING, true);
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_ARCH, "OS Arch", STRING, true);
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_VERSION, "OS Version", STRING, true);
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, JAVA_VENDOR, "Java Vendor", STRING, true);
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, JAVA_VERSION, "Java Version", STRING,
-					true);
 
-			//
+		if (systemStateJ.has(ROOTS))
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, AVAILABLE_PROCESSORS,
+			handleRoots(systemStateJ, resource);
-					"Available Processors", INTEGER, true);
+	}
 
-			//
+	private void handleOperatingSystem(JsonObject systemStateJ, Resource resource) {
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, SYSTEM_LOAD_AVERAGE, "System Load Average",
+		JsonObject osJ = systemStateJ.get(OPERATING_SYSTEM).getAsJsonObject();
-					FLOAT, true);
+
+		String bagId = OPERATING_SYSTEM;
+		String bagName = "Operating System";
+		String bagType = "OperatingSystem";
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_NAME, "OS Name", STRING, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_ARCH, "OS Arch", STRING, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, OS_VERSION, "OS Version", STRING, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, JAVA_VENDOR, "Java Vendor", STRING, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, JAVA_VERSION, "Java Version", STRING, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, START_TIME, "Start Time", DATE, true);
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, UPTIME, "Uptime", LONG, true);
+
+		//
+		resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, AVAILABLE_PROCESSORS, "Available Processors",
+				INTEGER, true);
+
+		//
+		if (osJ.has(SYSTEM_LOAD_AVERAGE) && !osJ.get(SYSTEM_LOAD_AVERAGE).isJsonNull()) {
+			double value = osJ.get(SYSTEM_LOAD_AVERAGE).getAsDouble();
+			resource.setOrAddParam(bagId, bagName, bagType, SYSTEM_LOAD_AVERAGE, "System Load Average", "SystemLoad",
+					"SystemLoad", FLOAT, value, true);
 			if (this.systemLoadAverageState)
-				setOrAddState(osJ, resource, SYSTEM_LOAD_AVERAGE, SYSTEM_LOAD_AVERAGE + "State", "System Load Average",
+				setOrAddState(resource, SYSTEM_LOAD_AVERAGE + "State", "System Load Average", INTERPRETATION_NONE,
-						FLOAT);
+						UOM_NONE, FLOAT, value);
+		}
+	}
 
-			//
+	private void handleMemory(JsonObject systemStateJ, Resource resource) {
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, START_TIME, "Start Time", DATE, true);
+		JsonObject memoryJ = systemStateJ.get(MEMORY).getAsJsonObject();
 
-			//
+		String bagId = MEMORY;
-			resource.setOrAddParamFromFlatJson(osJ, bagId, bagName, bagType, UPTIME, "Uptime", LONG, true);
+		String bagName = "Memory";
+		String bagType = "Memory";
+
+		//
+		if (memoryJ.has(TOTAL_PHYSICAL_MEMORY_SIZE) && !memoryJ.get(TOTAL_PHYSICAL_MEMORY_SIZE).isJsonNull()) {
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(TOTAL_PHYSICAL_MEMORY_SIZE).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, TOTAL_PHYSICAL_MEMORY_SIZE, "Total Physical Memory Size",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
 		}
 
-		if (systemStateJ.has(MEMORY)) {
+		//
-			JsonObject memoryJ = systemStateJ.get(MEMORY).getAsJsonObject();
+		if (memoryJ.has(FREE_PHYSICAL_MEMORY_SIZE) && !memoryJ.get(FREE_PHYSICAL_MEMORY_SIZE).isJsonNull()) {
-
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(FREE_PHYSICAL_MEMORY_SIZE).getAsLong());
-			String bagId = MEMORY;
+			resource.setOrAddParam(bagId, bagName, bagType, FREE_PHYSICAL_MEMORY_SIZE, "Free Physical Memory Size",
-			String bagName = "Memory";
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
-			String bagType = "Memory";
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, TOTAL_PHYSICAL_MEMORY_SIZE,
-					"Total Physical Memory Size", LONG, true);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, FREE_PHYSICAL_MEMORY_SIZE,
-					"Free Physical Memory Size", LONG, true);
 			if (this.freePhysicalMemorySizeState)
-				setOrAddState(memoryJ, resource, FREE_PHYSICAL_MEMORY_SIZE, FREE_PHYSICAL_MEMORY_SIZE + "State",
+				setOrAddState(resource, FREE_PHYSICAL_MEMORY_SIZE + "State", "Free Physical Memory Size",
-						"Free Physical Memory Size", LONG);
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, FREE_SWAP_SPACE_SIZE,
-					"Free Swap Space Size", LONG, true);
-			if (this.freeSwapSpaceSizeState)
-				setOrAddState(memoryJ, resource, FREE_SWAP_SPACE_SIZE, FREE_SWAP_SPACE_SIZE + "State",
-						"Free Swap Space Size", LONG);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, COMMITTED_VIRTUAL_MEMORY_SIZE,
-					"Committed Virtual Memory Size", LONG, true);
-			if (this.committedVirtualMemorySizeState)
-				setOrAddState(memoryJ, resource, COMMITTED_VIRTUAL_MEMORY_SIZE, COMMITTED_VIRTUAL_MEMORY_SIZE + "State",
-						"Committed Virtual Memory Size", LONG);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, HEAP_MEMORY_USAGE_INIT,
-					"Heap Memory Usage Init", LONG, true);
-			if (this.heapMemoryUsageInitState)
-				setOrAddState(memoryJ, resource, HEAP_MEMORY_USAGE_INIT, HEAP_MEMORY_USAGE_INIT + "State",
-						"Heap Memory Usage Init", LONG);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, HEAP_MEMORY_USAGE_USED,
-					"Heap Memory Usage Used", LONG, true);
-			if (this.heapMemoryUsageUsedState)
-				setOrAddState(memoryJ, resource, HEAP_MEMORY_USAGE_USED, HEAP_MEMORY_USAGE_USED + "State",
-						"Heap Memory Usage Used", LONG);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, HEAP_MEMORY_USAGE_MAX,
-					"Heap Memory Usage Max", LONG, true);
-			if (this.heapMemoryUsageMaxState)
-				setOrAddState(memoryJ, resource, HEAP_MEMORY_USAGE_MAX, HEAP_MEMORY_USAGE_MAX + "State",
-						"Heap Memory Usage Max", LONG);
-
-			//
-			resource.setOrAddParamFromFlatJson(memoryJ, bagId, bagName, bagType, HEAP_MEMORY_USAGE_COMMITTED,
-					"Heap Memory Usage Committed", LONG, true);
-			if (this.heapMemoryUsageCommittedState)
-				setOrAddState(memoryJ, resource, HEAP_MEMORY_USAGE_COMMITTED, HEAP_MEMORY_USAGE_COMMITTED + "State",
-						"Heap Memory Usage Committed", LONG);
 		}
 
-		if (systemStateJ.has(ROOTS)) {
+		//
-			JsonArray rootsJ = systemStateJ.get(ROOTS).getAsJsonArray();
+		if (memoryJ.has(FREE_SWAP_SPACE_SIZE) && !memoryJ.get(FREE_SWAP_SPACE_SIZE).isJsonNull()) {
-			for (JsonElement rootE : rootsJ) {
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(FREE_SWAP_SPACE_SIZE).getAsLong());
-				JsonObject rootJ = rootE.getAsJsonObject();
+			resource.setOrAddParam(bagId, bagName, bagType, FREE_SWAP_SPACE_SIZE, "Free Swap Space Size",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.freeSwapSpaceSizeState)
+				setOrAddState(resource, FREE_SWAP_SPACE_SIZE + "State", "Free Swap Space Size",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
 
-				String path = rootJ.get(PATH).getAsString();
+		//
-				if (path.equals("/"))
+		if (memoryJ.has(COMMITTED_VIRTUAL_MEMORY_SIZE) && !memoryJ.get(COMMITTED_VIRTUAL_MEMORY_SIZE).isJsonNull()) {
-					path = "root";
+			long value = this.memoryRoundingUnit
+					.roundBytesToUnit(memoryJ.get(COMMITTED_VIRTUAL_MEMORY_SIZE).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, COMMITTED_VIRTUAL_MEMORY_SIZE,
+					"Committed Virtual Memory Size", this.memoryRoundingUnit.getInterpretation(),
+					this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.committedVirtualMemorySizeState)
+				setOrAddState(resource, COMMITTED_VIRTUAL_MEMORY_SIZE + "State", "Committed Virtual Memory Size",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
 
-				String bagId = path;
+		//
-				String bagName = "Root " + path;
+		if (memoryJ.has(HEAP_MEMORY_USAGE_INIT) && !memoryJ.get(HEAP_MEMORY_USAGE_INIT).isJsonNull()) {
-				String bagType = "Root";
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(HEAP_MEMORY_USAGE_INIT).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, HEAP_MEMORY_USAGE_INIT, "Heap Memory Usage Init",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.heapMemoryUsageInitState)
+				setOrAddState(resource, HEAP_MEMORY_USAGE_INIT + "State", "Heap Memory Usage Init",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
 
-				resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, PATH, "Path", STRING, true);
+		//
+		if (memoryJ.has(HEAP_MEMORY_USAGE_USED) && !memoryJ.get(HEAP_MEMORY_USAGE_USED).isJsonNull()) {
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(HEAP_MEMORY_USAGE_USED).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, HEAP_MEMORY_USAGE_USED, "Heap Memory Usage Used",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.heapMemoryUsageUsedState)
+				setOrAddState(resource, HEAP_MEMORY_USAGE_USED + "State", "Heap Memory Usage Used",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
 
-				//
+		//
-				resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, USABLE_SPACE, "Usable Space", LONG,
+		if (memoryJ.has(HEAP_MEMORY_USAGE_MAX) && !memoryJ.get(HEAP_MEMORY_USAGE_MAX).isJsonNull()) {
-						true);
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(HEAP_MEMORY_USAGE_MAX).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, HEAP_MEMORY_USAGE_MAX, "Heap Memory Usage Max",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.heapMemoryUsageMaxState)
+				setOrAddState(resource, HEAP_MEMORY_USAGE_MAX + "State", "Heap Memory Usage Max",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
+
+		//
+		if (memoryJ.has(HEAP_MEMORY_USAGE_COMMITTED) && !memoryJ.get(HEAP_MEMORY_USAGE_COMMITTED).isJsonNull()) {
+			long value = this.memoryRoundingUnit.roundBytesToUnit(memoryJ.get(HEAP_MEMORY_USAGE_COMMITTED).getAsLong());
+			resource.setOrAddParam(bagId, bagName, bagType, HEAP_MEMORY_USAGE_COMMITTED, "Heap Memory Usage Committed",
+					this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value, true);
+			if (this.heapMemoryUsageCommittedState)
+				setOrAddState(resource, HEAP_MEMORY_USAGE_COMMITTED + "State", "Heap Memory Usage Committed",
+						this.memoryRoundingUnit.getInterpretation(), this.memoryRoundingUnit.getUom(), LONG, value);
+		}
+	}
+
+	private void handleRoots(JsonObject systemStateJ, Resource resource) {
+		JsonArray rootsJ = systemStateJ.get(ROOTS).getAsJsonArray();
+		for (JsonElement rootE : rootsJ) {
+			JsonObject rootJ = rootE.getAsJsonObject();
+
+			String path = rootJ.get(PATH).getAsString();
+			if (path.equals("/"))
+				path = "root";
+
+			String bagId = path;
+			String bagName = "Root " + path;
+			String bagType = "Root";
+
+			resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, PATH, "Path", STRING, true);
+
+			//
+			if (rootJ.has(TOTAL_SPACE) && !rootJ.get(TOTAL_SPACE).isJsonNull()) {
+				long value = this.storageSpaceRoundingUnit.roundBytesToUnit(rootJ.get(TOTAL_SPACE).getAsLong());
+				resource.setOrAddParam(bagId, bagName, bagType, TOTAL_SPACE, "Total Space",
+						this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(), LONG,
+						value, true);
+			}
+
+			//
+			if (rootJ.has(USABLE_SPACE) && !rootJ.get(USABLE_SPACE).isJsonNull()) {
+				long value = this.storageSpaceRoundingUnit.roundBytesToUnit(rootJ.get(USABLE_SPACE).getAsLong());
+				resource.setOrAddParam(bagId, bagName, bagType, USABLE_SPACE, "Usable Space",
+						this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(), LONG,
+						value, true);
 				if (this.usableSpaceState)
-					setOrAddState(rootJ, resource, USABLE_SPACE, bagId + USABLE_SPACE + "State", "Usable Space", LONG);
+					setOrAddState(resource, bagId + USABLE_SPACE + "State", "Usable Space",
+							this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(),
+							LONG, value);
+			}
 
-				//
+			//
-				resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, USED_SPACE, "Used Space", LONG,
+			if (rootJ.has(USED_SPACE) && !rootJ.get(USED_SPACE).isJsonNull()) {
-						true);
+				long value = this.storageSpaceRoundingUnit.roundBytesToUnit(rootJ.get(USED_SPACE).getAsLong());
+				resource.setOrAddParam(bagId, bagName, bagType, USED_SPACE, "Used Space",
+						this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(), LONG,
+						value, true);
 				if (this.usedSpaceState)
-					setOrAddState(rootJ, resource, USED_SPACE, bagId + USED_SPACE + "State", "Used Space", LONG);
+					setOrAddState(resource, bagId + USED_SPACE + "State", "Used Space",
+							this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(),
+							LONG, value);
+			}
 
-				//
+			//
-				resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, FREE_SPACE, "Free Space", LONG,
+			if (rootJ.has(FREE_SPACE) && !rootJ.get(FREE_SPACE).isJsonNull()) {
-						true);
+				long value = this.storageSpaceRoundingUnit.roundBytesToUnit(rootJ.get(FREE_SPACE).getAsLong());
+				resource.setOrAddParam(bagId, bagName, bagType, FREE_SPACE, "Free Space",
+						this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(), LONG,
+						value, true);
 				if (this.freeSpaceState)
-					setOrAddState(rootJ, resource, FREE_SPACE, bagId + FREE_SPACE + "State", "Free Space", LONG);
+					setOrAddState(resource, bagId + FREE_SPACE + "State", "Free Space",
-
+							this.storageSpaceRoundingUnit.getInterpretation(), this.storageSpaceRoundingUnit.getUom(),
-				//
+							LONG, value);
-				resource.setOrAddParamFromFlatJson(rootJ, bagId, bagName, bagType, TOTAL_SPACE, "Total Space", LONG,
-						true);
 			}
 		}
 	}
 
-	private void setOrAddState(JsonObject jsonObject, Resource resource, String jsonId, String stateId,
+	private void setOrAddState(Resource resource, String stateId, String stateName, String interpretation, String uom,
-			String stateName, StrolchValueType type) {
+			StrolchValueType type, Object value) {
+
+		if (value == null)
+			return;
 
 		StrolchTimedState<? extends IValue<?>> state = resource.getTimedState(stateId);
 		if (state == null) {
 			state = type.timedStateInstance();
 			state.setId(stateId);
 			state.setName(stateName);
+			state.setInterpretation(interpretation);
+			state.setUom(uom);
 
 			resource.addTimedState(state);
 		}
 
-		boolean valueNotSet = !jsonObject.has(jsonId) || jsonObject.get(jsonId).isJsonNull();
+		state.accept(new SetStateValueVisitor(this.stateTime, value));
-		if (valueNotSet)
-			return;
-
-		state.setStateFromStringAt(this.stateTime, jsonObject.get(jsonId).getAsString());
 
 		if (this.compactStates)
 			state.getTimeEvolution().compact();

li.strolch.model/src/main/java/li/strolch/model/visitor/SetParameterValueFromStringVisitor.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2013 Robert von Burg <eitch@eitchnet.ch>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package li.strolch.model.visitor;
+
+import li.strolch.model.parameter.*;
+
+/**
+ * @author Robert von Burg <eitch@eitchnet.ch>
+ */
+public class SetParameterValueFromStringVisitor implements ParameterVisitor<Void> {
+
+	private String value;
+
+	public SetParameterValueFromStringVisitor(String value) {
+		this.value = value;
+	}
+
+	@Override
+	public Void visitBooleanParam(BooleanParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitDateParam(DateParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitDurationParam(DurationParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitFloatParam(FloatParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitIntegerParam(IntegerParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitLongParam(LongParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitStringParam(StringParameter param) {
+		param.setValue(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitStringListParam(StringListParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitFloatListParam(FloatListParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitIntegerListParam(IntegerListParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+
+	@Override
+	public Void visitLongListParam(LongListParameter param) {
+		param.setValueFromString(this.value);
+		return null;
+	}
+}

li.strolch.model/src/main/java/li/strolch/model/visitor/SetParameterValueVisitor.java

@@ -15,6 +15,9 @@
  */
 package li.strolch.model.visitor;
 
+import java.util.Date;
+import java.util.List;
+
 import li.strolch.model.parameter.*;
 
 /**
@@ -22,75 +25,79 @@ import li.strolch.model.parameter.*;
  */
 public class SetParameterValueVisitor implements ParameterVisitor<Void> {
 
-	private String value;
+	private Object value;
 
-	public SetParameterValueVisitor(String value) {
+	public SetParameterValueVisitor(Object value) {
 		this.value = value;
 	}
 
 	@Override
 	public Void visitBooleanParam(BooleanParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Boolean) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitDateParam(DateParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Date) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitDurationParam(DurationParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Long) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitFloatParam(FloatParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Double) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitIntegerParam(IntegerParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Integer) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitLongParam(LongParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((Long) this.value);
 		return null;
 	}
 
 	@Override
 	public Void visitStringParam(StringParameter param) {
-		param.setValue(this.value);
+		param.setValue((String) this.value);
 		return null;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Void visitStringListParam(StringListParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((List<String>) this.value);
 		return null;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Void visitFloatListParam(FloatListParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((List<Double>) this.value);
 		return null;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Void visitIntegerListParam(IntegerListParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((List<Integer>) this.value);
 		return null;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Void visitLongListParam(LongListParameter param) {
-		param.setValueFromString(this.value);
+		param.setValue((List<Long>) this.value);
 		return null;
 	}
 }