Index: /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustNode.java
===================================================================
--- /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustNode.java	(revision 26053)
+++ /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustNode.java	(revision 26053)
@@ -0,0 +1,65 @@
+package org.openstreetmap.josm.plugins.trustosm.data;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bouncycastle.openpgp.PGPSignature;
+import org.openstreetmap.josm.data.coor.CoordinateFormat;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+
+public class TrustNode extends TrustOsmPrimitive {
+
+
+	public static Node generateNodeFromSigtext(String sigtext) {
+		Pattern p = Pattern.compile("^(\\d*)\\((\\d*\\.?\\d*),(\\d*\\.?\\d*)\\)");
+		Matcher m = p.matcher(sigtext);
+		if (m.matches()) {
+			Node node = new Node(Long.parseLong(m.group(1)));
+			node.setCoor(new LatLon(Double.parseDouble(m.group(2)),Double.parseDouble(m.group(3))));
+			return node;
+		}
+		return null;
+	}
+
+	public static String generateNodeSigtext(Node node) {
+		LatLon point = node.getCoor();
+		String sigtext = node.getUniqueId() + "(";
+		sigtext += point.latToString(CoordinateFormat.DECIMAL_DEGREES) + ",";
+		sigtext += point.lonToString(CoordinateFormat.DECIMAL_DEGREES) + ")";
+		return sigtext;
+	}
+
+	private TrustSignatures ratings;
+
+	public TrustNode(Node osmItem) {
+		super(osmItem);
+	}
+
+	@Override
+	public void setOsmPrimitive(OsmPrimitive osmItem) {
+		if(osmItem instanceof Node) {
+			osm = osmItem;
+		} else {
+			System.err.println("Error while creating TrustNode: OsmPrimitive "+osmItem.getUniqueId()+" is not a Node!");
+		}
+	}
+
+	public void storeNodeSig(PGPSignature sig) {
+		if (ratings == null) {
+			ratings = new TrustSignatures(sig, TrustNode.generateNodeSigtext((Node) osm), TrustSignatures.SIG_VALID);
+		} else {
+			ratings.addSignature(sig, TrustNode.generateNodeSigtext((Node) osm));
+		}
+	}
+
+	public void setNodeRatings(TrustSignatures ratings) {
+		this.ratings =ratings;
+	}
+
+	public TrustSignatures getNodeSigs() {
+		return ratings;
+	}
+
+}
Index: /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustOsmPrimitive.java
===================================================================
--- /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustOsmPrimitive.java	(revision 26053)
+++ /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustOsmPrimitive.java	(revision 26053)
@@ -0,0 +1,128 @@
+package org.openstreetmap.josm.plugins.trustosm.data;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.bouncycastle.openpgp.PGPSignature;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+
+abstract public class TrustOsmPrimitive {
+
+	public static String createUniqueObjectIdentifier(OsmPrimitive osm) {
+		String id = "";
+		if(osm instanceof Node) {
+			id = "n";
+		} else if(osm instanceof Way) {
+			id = "w";
+		} else if(osm instanceof Relation) {
+			id = "r";
+		}
+		id += osm.getUniqueId();
+		return id;
+	}
+
+	public static OsmPrimitive createOsmPrimitiveFromUniqueObjectIdentifier(String oid) {
+		char type = oid.charAt(0);
+		long id = Long.parseLong(oid.substring(1));
+		switch (type) {
+		case 'n': return new Node(id);
+		case 'w': return new Way(id);
+		case 'r': return new Relation(id);
+		}
+		return null;
+	}
+
+	public static TrustOsmPrimitive createTrustOsmPrimitive(OsmPrimitive osm) {
+		if(osm instanceof Node) {
+			return new TrustNode((Node) osm);
+		} else if(osm instanceof Way) {
+			return new TrustWay(osm);
+		} else if(osm instanceof Relation) {
+			return new TrustRelation(osm);
+		}
+		return null;
+	}
+
+	protected OsmPrimitive osm;
+	private final Map<String, TrustSignatures> keySig = new HashMap<String, TrustSignatures>();
+
+	public TrustOsmPrimitive(OsmPrimitive osmItem) {
+		setOsmPrimitive(osmItem);
+	}
+
+	public OsmPrimitive getOsmPrimitive() {
+		return osm;
+	}
+
+	public abstract void setOsmPrimitive(OsmPrimitive osmItem);
+
+
+	public static String[] generateTagsFromSigtext(String sigtext) {
+		String[] keyValue = sigtext.substring(sigtext.indexOf('\n')+1).split("=");
+		return keyValue;
+	}
+
+	public static String generateTagSigtext(OsmPrimitive osm, String key) {
+		String sigtext = "ID=" + osm.getUniqueId() + "\n";
+		sigtext += key + "=" + osm.get(key);
+		return sigtext;
+	}
+
+	public void storeTagSig(String key, PGPSignature sig) {
+		if (keySig.containsKey(key)) {
+			keySig.get(key).addSignature(sig, TrustOsmPrimitive.generateTagSigtext(osm, key));
+			return;
+		} else if (osm.keySet().contains(key)) {
+			keySig.put(key, new TrustSignatures(sig, TrustOsmPrimitive.generateTagSigtext(osm, key), TrustSignatures.SIG_VALID));
+		}
+	}
+
+	public void setTagRatings(String key, TrustSignatures tsigs) {
+		keySig.put(key, tsigs);
+	}
+
+	/*
+	public Map<Node, TrustSignatures> getGeomSigs() {
+		return geomSig;
+	}
+
+	public TrustSignatures getSigsOnNode(Node node) {
+		return geomSig.get(node);
+	}*/
+
+	public Set<String> getSignedKeys() {
+		return keySig.keySet();
+	}
+
+	public Map<String, TrustSignatures> getTagSigs() {
+		return keySig;
+	}
+
+	public TrustSignatures getSigsOnKey(String key) {
+		return keySig.get(key);
+	}
+
+	public void updateTagSigStatus(String key, byte status) {
+		if (keySig.containsKey(key)) {
+			keySig.get(key).setStatus(status);
+		} else if (osm.keySet().contains(key)) {
+			TrustSignatures tsigs = new TrustSignatures();
+			tsigs.setStatus(status);
+			keySig.put(key, tsigs);
+		}
+	}
+	/*
+	public void updateNodeSigStatus(Node node, byte status) {
+		if (geomSig.containsKey(node)) {
+			geomSig.get(node).setStatus(status);
+		} else {
+			TrustSignatures tsigs = new TrustSignatures();
+			tsigs.setStatus(status);
+			geomSig.put(node, tsigs);
+		}
+	}*/
+}
Index: /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustRelation.java
===================================================================
--- /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustRelation.java	(revision 26053)
+++ /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustRelation.java	(revision 26053)
@@ -0,0 +1,76 @@
+package org.openstreetmap.josm.plugins.trustosm.data;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bouncycastle.openpgp.PGPSignature;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+
+public class TrustRelation extends TrustOsmPrimitive {
+
+
+	public static RelationMember generateRelationMemberFromSigtext(String sigtext) {
+		Pattern p = Pattern.compile("^RelID=(\\w*)\n(\\d*),(.*)");
+		Matcher m = p.matcher(sigtext);
+		if (m.matches()) {
+			OsmPrimitive osm = createOsmPrimitiveFromUniqueObjectIdentifier(m.group(2));
+			return new RelationMember(m.group(3),osm);
+		}
+		return null;
+	}
+
+	public static String generateRelationMemberSigtext(TrustRelation trust, String memID) {
+		Relation r = (Relation)trust.getOsmPrimitive();
+		List<RelationMember> members = r.getMembers();
+		RelationMember member = null;
+		for (RelationMember m : members) {
+			if (TrustOsmPrimitive.createUniqueObjectIdentifier(m.getMember()).equals(memID)) {
+				member = m;
+				break;
+			}
+		}
+		if (member == null) return "";
+		String sigtext = "RelID=" + r.getUniqueId() + "\n";
+		sigtext += TrustOsmPrimitive.createUniqueObjectIdentifier(member.getMember())+","+member.getRole();
+		return sigtext;
+	}
+
+	private final Map<String, TrustSignatures> memberSig = new HashMap<String, TrustSignatures>();
+
+	public TrustRelation(OsmPrimitive osmItem) {
+		super(osmItem);
+	}
+
+	@Override
+	public void setOsmPrimitive(OsmPrimitive osmItem) {
+		if(osmItem instanceof Relation) {
+			osm = osmItem;
+		} else {
+			System.err.println("Error while creating TrustRelation: OsmPrimitive "+osmItem.getUniqueId()+" is not a Relation!");
+		}
+	}
+
+
+	public void storeMemberSig(String memID, PGPSignature sig) {
+		if (memberSig.containsKey(memID)) {
+			memberSig.get(memID).addSignature(sig, TrustRelation.generateRelationMemberSigtext(this, memID));
+			return;
+		} else {
+			memberSig.put(memID, new TrustSignatures(sig, TrustRelation.generateRelationMemberSigtext(this, memID), TrustSignatures.SIG_VALID));
+		}
+	}
+
+	public void setMemberRating(String memID, TrustSignatures tsigs) {
+		memberSig.put(memID, tsigs);
+	}
+
+	public Map<String, TrustSignatures> getMemberSigs() {
+		return memberSig;
+	}
+
+}
Index: /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustWay.java
===================================================================
--- /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustWay.java	(revision 26053)
+++ /applications/editors/josm/plugins/trustosm/src/org/openstreetmap/josm/plugins/trustosm/data/TrustWay.java	(revision 26053)
@@ -0,0 +1,87 @@
+package org.openstreetmap.josm.plugins.trustosm.data;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bouncycastle.openpgp.PGPSignature;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.WaySegment;
+
+public class TrustWay extends TrustOsmPrimitive {
+
+	/*
+	public static List<WaySegment> generateSegmentListFromWay(Way w) {
+		List<WaySegment> segList = new ArrayList<WaySegment>();
+		for (int i = 0; i < w.getNodesCount()-1; i++) {
+			segList.add(new WaySegment(w,i));
+		}
+		return segList;
+	}
+	 */
+
+	public static List<Node> generateSegmentFromSigtext(String sigtext) {
+		String[] lines = sigtext.split("\n");
+		List<Node> nodes = new ArrayList<Node>();
+		for (int i=1; i<lines.length; i++){
+			nodes.add(TrustNode.generateNodeFromSigtext(lines[i]));
+		}
+		return nodes;
+	}
+
+	public static String generateSegmentSigtext(TrustWay trust, List<Node> nodes) {
+		String sigtext = "WayID=" + trust.getOsmPrimitive().getUniqueId();
+		for (Node n : nodes) {
+			sigtext += "\n" + TrustNode.generateNodeSigtext(n);
+		}
+		return sigtext;
+	}
+
+
+	private final Map<List<Node>, TrustSignatures> segmentSig = new HashMap<List<Node>, TrustSignatures>();
+
+	public TrustWay(OsmPrimitive osmItem) {
+		super(osmItem);
+	}
+
+	@Override
+	public void setOsmPrimitive(OsmPrimitive osmItem) {
+		if(osmItem instanceof Way) {
+			osm = osmItem;
+		} else {
+			System.err.println("Error while creating TrustWay: OsmPrimitive "+osmItem.getUniqueId()+" is not a Way!");
+		}
+	}
+
+
+	public void storeSegmentSig(List<Node> nodes, PGPSignature sig) {
+		if (segmentSig.containsKey(nodes)) {
+			segmentSig.get(nodes).addSignature(sig, TrustWay.generateSegmentSigtext(this,nodes));
+		} else {
+			segmentSig.put(nodes, new TrustSignatures(sig, TrustWay.generateSegmentSigtext(this,nodes), TrustSignatures.SIG_VALID));
+		}
+	}
+
+	public void setSegmentRatings(List<Node> nodes, TrustSignatures tsigs) {
+		segmentSig.put(nodes, tsigs);
+	}
+
+	public Map<List<Node>, TrustSignatures> getSegmentSigs() {
+		return segmentSig;
+	}
+
+	public TrustSignatures getSigsOnSegment(WaySegment seg) {
+		List<Node> nodes = new ArrayList<Node>();
+		nodes.add(seg.getFirstNode());
+		nodes.add(seg.getSecondNode());
+		return getSigsOnSegment(nodes);
+	}
+
+	public TrustSignatures getSigsOnSegment(List<Node> nodes) {
+		return segmentSig.get(nodes);
+	}
+
+}