String format = (String)STRING_SERIALIZER.deserialize(input);
int version = (Integer)INTEGER_SERIALIZER.deserialize(input);
@SuppressWarnings("unchecked")
- TreeMap<String,Variant> metadata = (TreeMap<String,Variant>)METADATA_SERIALIZER.deserialize(input);
+ TreeMap<String,Variant> metadata = (TreeMap<String,Variant>)METADATA_SERIALIZER.deserialize(input);
return new DataContainer(format, version, metadata, null);
}
-
+
/**
* Consumes a header from a given stream and checks that the header satisfies the given format and version.
* Returns the obtained header if the check fails and null on success.
* @throws IOException
*/
public static DataContainer requireHeader(DataInput input, String format, int version) {
- try {
- DataContainer header = readHeader(input);
- if(!format.equals(header.format) || version != header.version)
- return header;
- else return null;
- } catch (Throwable t) {
- return new DataContainer("unknown", 0, null, null);
- }
+ try {
+ DataContainer header = readHeader(input);
+ if(!format.equals(header.format) || version != header.version)
+ return header;
+ else return null;
+ } catch (Throwable t) {
+ return new DataContainer("unknown", 0, null, null);
+ }
}
/**
* @throws IOException
*/
public static DataContainer validateHeader(File file, String format, int version) throws IOException {
-
- InputStream stream = new FileInputStream( file );
- try {
- return DataContainers.requireHeader(new DataInputStream(stream), format, version);
- } finally {
- stream.close();
- }
-
+ try (InputStream stream = new FileInputStream( file )) {
+ return DataContainers.requireHeader(new DataInputStream(stream), format, version);
+ }
}
/**
* @throws IOException
*/
public static DataContainer validateHeader(File file, String... allowedFormatStrings) throws IOException {
-
- InputStream stream = new FileInputStream( file );
- try {
+ try (InputStream stream = new FileInputStream( file )) {
return DataContainers.requireHeader(new DataInputStream(stream), allowedFormatStrings);
- } finally {
- stream.close();
}
-
}
/**
* @throws IOException
*/
public static DataContainer readHeader(File input) throws IOException {
- BinaryFile rf = new BinaryFile( input, "r" );
- try {
+ try (BinaryFile rf = new BinaryFile( input, "r" )) {
return readHeader(rf);
- } finally {
- rf.close();
- }
+ }
}
-
+
/**
* Reads a data container including the content data.
* @throws IOException
return result;
}
+ /**
+ * Reads a data container including the content data.
+ * @throws IOException
+ */
+ public static DataContainer readFile(DataInput input, Binding expectedBinding) throws IOException, DataFormatException {
+ DataContainer result = readHeader(input);
+ Datatype contentType = (Datatype) DATATYPE_SERIALIZER.deserialize(input);
+ if (!expectedBinding.type().equals(contentType))
+ throw new DataFormatException(
+ "Content type didn't match the type expected for the binding " + expectedBinding
+ + ":\nexpected type: " + expectedBinding.type()
+ + "\nactual type: " + contentType);
+ Object value = Bindings.getSerializerUnchecked(expectedBinding).deserialize(input);
+ result.content = new Variant(expectedBinding, value);
+ return result;
+ }
+
/**
* Process a data container using a format handler matching the format and version
* of the file.
*/
public static <T> T readFile(DataInput input, Map<String, FormatHandler<T>> handlers) throws Exception {
DataContainer result = readHeader(input);
-
+
FormatHandler<T> handler = handlers.get(result.format + ":" + result.version);
if(handler == null)
throw new DataFormatException("Unknown data format " + result.format + " version " + result.version + ".");
Binding binding = handler.getBinding();
-
+
Datatype contentType = (Datatype)DATATYPE_SERIALIZER.deserialize(input);
if(!binding.type().equals(contentType))
throw new DataFormatException("Content type didn't match the type expected for the format " + result.format + " version " + result.version + ".");
-
+
Object value = Bindings.getSerializerUnchecked(binding).deserialize(input);
-
+
result.content = new Variant(binding, value);
return handler.process(result);
}
-
+
/**
* Reads a data container including the content data.
* @throws IOException
*/
public static DataContainer readFile(File input) throws IOException {
- BinaryFile rf = new BinaryFile( input, "r" );
- try {
+ try (BinaryFile rf = new BinaryFile( input, "r" )) {
return readFile(rf);
- } finally {
- rf.close();
- }
+ }
+ }
+
+ /**
+ * Reads a data container including the content data.
+ * @throws IOException
+ * @throws DataFormatException
+ */
+ public static DataContainer readFile(File input, Binding expectedBinding) throws IOException, DataFormatException {
+ try (BinaryFile rf = new BinaryFile( input, "r" )) {
+ return readFile(rf, expectedBinding);
+ }
}
-
+
/**
* Process a data container using a format handler matching the format and version
* of the file.
* @param handlers Map of handlers. Keys are strings of form "format:version".
*/
public static <T> T readFile(File input, Map<String, FormatHandler<T>> handlers) throws Exception {
- BinaryFile rf = new BinaryFile( input, "r" );
- try {
+ try (BinaryFile rf = new BinaryFile( input, "r" )) {
return readFile(rf, handlers);
- } finally {
- rf.close();
- }
+ }
}
-
+
/**
* Writes header fields of a container to the given output. Content field is
* ignored.
INTEGER_SERIALIZER.serialize(output, container.version);
METADATA_SERIALIZER.serialize(output, container.metadata);
}
-
+
/**
* Writes a data container to the given output.
* @throws IOException
writeHeader(output, container);
VARIANT_SERIALIZER.serialize(output, container.content);
}
-
+
/**
* Writes a data container to the given file
* @throws IOException
*/
public static void writeFile(File output, DataContainer container) throws IOException {
- BinaryFile wf = new BinaryFile( output);
- try {
+ try (BinaryFile wf = new BinaryFile(output)) {
writeFile(wf, container);
wf.setLength(wf.position());
- } finally {
- wf.close();
- }
+ }
}
-
+
public static byte[] writeFile(DataContainer container) throws IOException {
return DATA_CONTAINER_SERIALIZER.serialize(container);
}
+
}
package org.simantics.graph.refactoring;
import java.io.BufferedInputStream;
-import java.io.DataInput;
import java.io.DataInputStream;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import org.simantics.databoard.binding.Binding;
-import org.simantics.databoard.binding.mutable.Variant;
import org.simantics.databoard.container.DataContainer;
import org.simantics.databoard.container.DataContainers;
import org.simantics.graph.representation.PrettyPrintTG;
static TransferableGraph1 convertExportedSharedOntologyIntoBundleOntology(Path input, Path output) throws Exception {
System.out.format("Converting exported shared ontology%n\t" + input.toString() + "%nto bundle-compatible ontology%n\t" + output.toString());
try (InputStream is = new BufferedInputStream(Files.newInputStream(input), 128*1024)) {
- DataInput dis = new DataInputStream(is);
- org.simantics.databoard.container.DataContainer container =
- DataContainers.readFile(dis);
- Binding binding = TransferableGraph1.BINDING;
- TransferableGraph1 graph = (TransferableGraph1)container.content.getValue(binding);
+ Binding tgBinding = TransferableGraph1.BINDING;
+ DataContainer container = DataContainers.readFile(new DataInputStream(is), tgBinding);
+ TransferableGraph1 graph = (TransferableGraph1) container.content.getValue(tgBinding);
+
GraphRefactoringUtils.fixOntologyExport(graph);
+ container = TransferableGraphHasher.addHashToTG(container, graph);
- DataContainers.writeFile(output.toFile(), new DataContainer(
- container.format, container.version,
- container.metadata, new Variant(TransferableGraph1.BINDING, graph)));
-
+ DataContainers.writeFile(output.toFile(), container);
return graph;
-
}
}
--- /dev/null
+package org.simantics.graph.refactoring;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.simantics.databoard.Bindings;
+import org.simantics.databoard.adapter.AdaptException;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.binding.error.BindingException;
+import org.simantics.databoard.binding.mutable.Variant;
+import org.simantics.databoard.container.DataContainer;
+import org.simantics.databoard.container.DataContainers;
+import org.simantics.graph.representation.Extensions;
+import org.simantics.graph.representation.TransferableGraph1;
+
+/**
+ * @author Tuukka Lehtonen
+ * @since 1.34.0
+ */
+public class TransferableGraphHasher {
+
+ public static int hashTG(TransferableGraph1 tg) throws BindingException {
+ return TransferableGraph1.BINDING.hashValue(tg);
+ }
+
+ public static DataContainer addHashToTG(DataContainer tgContainer, TransferableGraph1 tg) throws BindingException {
+ Binding tgb = TransferableGraph1.BINDING;
+ tgContainer.metadata.put(Extensions.CACHED_HASHCODE, new Variant(Bindings.INTEGER, hashTG(tg)));
+ tgContainer.content = new Variant(tgb, tg);
+ return tgContainer;
+ }
+
+ public static DataContainer addHashToTG(DataContainer tgContainer) throws BindingException, AdaptException {
+ return addHashToTG(tgContainer, (TransferableGraph1) tgContainer.content.getValue(TransferableGraph1.BINDING));
+ }
+
+ public static void hashTG(Path input, Path output) throws Exception {
+ System.out.format("Adding cached hash value to transferable graph%n\t" + input.toString() + "%nto%n\t" + output.toString());
+ DataContainers.writeFile(output.toFile(),
+ addHashToTG(
+ DataContainers.readFile(input.toFile(), TransferableGraph1.BINDING) ));
+ }
+
+ public static void main(String[] args) throws Exception {
+ if (args.length == 0) {
+ System.out.println("Required arguments: <input graph.tg file> [<output .tg file>]");
+ } else if (args.length == 1) {
+ // In-place hash
+ Path p = Paths.get(args[0]);
+ hashTG(p, p);
+ } else {
+ hashTG(Paths.get(args[0]), Paths.get(args[1]));
+ }
+ }
+
+}
Code Review / simantics / platform.git / commitdiff