Package: Persistierer$1

Persistierer$1

name	instruction	branch	complexity	line	method
{...}	M: 0 C: 42 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 4 100%	M: 0 C: 1 100%

Coverage

1: package persist;
2:
3: import com.thoughtworks.xstream.XStream;
4: import com.thoughtworks.xstream.converters.Converter;
5:
6: import java.io.File;
7: import java.io.IOException;
8: import java.nio.file.Files;
9: import java.util.Arrays;
10:
11: /**
12: * Zu verwendende Schnittstelle, um Objekte zu speichern und wieder zu laden.
13: */
14: public final class Persistierer {
15:         /**
16:          * Das XStream-Objekt, welches für das (De-)Serialisieren zuständig ist. Es verwaltet ebenso alle weiteren
17:          * relevanten Einstellungen (Security, verarbeitung von Annotations, CustomConverters, Referenzmodi).
18:          */
19:         private static final XStream X_BACH = new XStream() {
20:                 {
21:                         //TODO Art: unidentified; entscheiden, wie mit der nächsten Zeile umgegangen wird (security-mäßig)
22:                         // XStream.setupDefaultSecurity(this);
23:                         this.allowTypesByWildcard(
24:                                         new String[]{"example.**", "ablaeufe.**", "maschine.**", "material.**", "mensch.**", "util.**",
25:                                                         "zeit.**", "schnittstelle.**", });
26:                         this.setMode(XStream.ID_REFERENCES);
27:                 }
28:         };
29:         
30:         private Persistierer() {
31:         }
32:         
33:         /**
34:          * Erstellt ein gültiges XML, welches wieder zu einem Objekt geparst werden kann.
35:          *
36:          * @param obj
37:          * Objekt, welches gespeichert werden soll.
38:          * @return Liefert einen gültigen String, welcher {@code obj} repräsentiert
39:          */
40:         public static String zuXML(final Object obj) {
41:                 return Persistierer.X_BACH.toXML(obj);
42:         }
43:         
44:         /**
45:          * Erstellt ein gültiges XML, welches wieder zu einem Objekt geparst werden kann. Dieser String wird direkt in
46:          * {@code location} gespeichert.
47:          *
48:          * @param obj
49:          * Objekt, welches gespeichert werden soll.
50:          * @param location
51:          * Dateipfad, in welchem die Datei gespeichert werden soll.<br>
52:          * Beispiel: "./src/test/resources/dateiname.xml"
53:          * @return Liefert einen gültigen String, welcher {@code obj} repräsentiert
54:          * @throws IOException
55:          * wenn ein Fehler beim schreiben der Datei auftritt.
56:          */
57:         public static String persistiere(final Object obj, final File location) throws IOException {
58:                 final String objectXML = Persistierer.X_BACH.toXML(obj);
59:                 Files.write(location.toPath(), objectXML.getBytes());
60:                 return objectXML;
61:         }
62:         
63:         /**
64:          * Zaubert aus einem Objekt-XML String ein Objekt.
65:          *
66:          * @param xml
67:          * Ein String, welcher ein Objekt beinhaltet.
68:          * @return Liefert das geparste Objekt aus {@code xml}.
69:          */
70:         public static Object vonXML(final String xml) {
71:                 return Persistierer.X_BACH.fromXML(xml);
72:         }
73:         
74:         /**
75:          * Zaubert aus einer Datei, welche ein Objekt-XML enthält, ein Objekt.
76:          *
77:          * @param xml
78:          * File mit dem Pfad zu einer XML-Datei.<br>
79:          * Beispiel: new File("./src/test/resources/dateiname.xml")
80:          * @return Liefert das geparste Objekt aus {@code xml}.
81:          */
82:         public static Object lade(final File xml) {
83:                 return Persistierer.X_BACH.fromXML(xml);
84:         }
85:         
86:         /**
87:          * @param konvertierer
88:          * Array der Konvertierer, welche Sonderhandling für das Speichern/ Laden bestimmter Objekte (wie bspw.
89:          * Singletons) übernehmen. Die hier übergebenen Konvertierer bleiben permanent im Persistierer enthalten.
90:          */
91:         public static void addKonvertierer(final Converter... konvertierer) {
92:                 Arrays.stream(konvertierer).forEach(Persistierer.X_BACH::registerConverter);
93:         }
94:         
95:         /**
96:          * @param klassen
97:          * Klassen, zu welchen Annotationen wie bspw {@code @XStreamAlias("lulu")} verarbeitet werden sollen.
98:          * Diese müssen bereits vor dem Speichern/ Laden gesetzt werden.
99:          */
100:         public static void verarbeiteAnnotationen(final Class<?>... klassen) {
101:                 Persistierer.X_BACH.processAnnotations(klassen);
102:         }
103:         
104:         // TODO: Art: unidentified; Vielleicht missbrauchen wir den Persistiere hier ein bisschen.
105:         /**
106:          * Erstellt eine Kopie des übergebenen Objekts.
107:          *
108:          * @param original
109:          * Objekt, das kopiert wird.
110:          * @param <T>
111:          * Typ des Originals und der Kopie
112:          * @return die Kopie des Objekts.
113:          */
114:         @SuppressWarnings("unchecked")
115:         public static <T> T dupliziere(final T original) {
116:                 return (T) Persistierer.vonXML(Persistierer.zuXML(original));
117:         }
118:         
119: }