-package org.simantics.backup.db;\r
-\r
-import java.nio.file.Path;\r
-import java.util.concurrent.Callable;\r
-import java.util.concurrent.Future;\r
-import java.util.concurrent.FutureTask;\r
-\r
-import org.simantics.backup.BackupException;\r
-import org.simantics.backup.IBackupProvider;\r
-import org.simantics.scl.runtime.function.Function1;\r
-import org.simantics.scl.runtime.function.Function2;\r
-import org.simantics.scl.runtime.tuple.Tuple0;\r
-\r
-public class ModelledBackup implements IBackupProvider {\r
-\r
- private final Function1<Tuple0, Object> lockFunc;\r
- private final Function2<String, Integer, Function1<Tuple0, String>> backupFunc;\r
- private final Function1<Tuple0, Object> unlockFunc;\r
- private final Function2<String, Integer, Object> restoreFunc;\r
-\r
- private ModelledBackup(\r
- Function1<Tuple0, Object> lockFunc,\r
- Function2<String, Integer, Function1<Tuple0, String>> backupFunc,\r
- Function1<Tuple0, Object> unlockFunc,\r
- Function2<String, Integer, Object> restoreFunc) {\r
- this.lockFunc = lockFunc;\r
- this.backupFunc = backupFunc;\r
- this.unlockFunc = unlockFunc;\r
- this.restoreFunc = restoreFunc;\r
- }\r
-\r
- @Override\r
- public void lock() {\r
- lockFunc.apply(Tuple0.INSTANCE);\r
- }\r
-\r
- @Override\r
- public Future<BackupException> backup(Path targetPath, int revision) {\r
-\r
- final Function1<Tuple0, String> fn = backupFunc.apply(targetPath.toString(), revision);\r
- \r
- final FutureTask<BackupException> futureTask = new FutureTask<BackupException>(new Callable<BackupException>() {\r
- @Override\r
- public BackupException call() throws Exception {\r
- try {\r
- String error = fn.apply(Tuple0.INSTANCE);\r
- if (error != null) {\r
- return new BackupException(error);\r
- } else {\r
- return null;\r
- }\r
- } catch (Throwable t) {\r
- return new BackupException(t);\r
- }\r
- }\r
- });\r
- \r
- Thread thread = new Thread(futureTask, "Backup Provider Thread " + backupFunc.toString());\r
- thread.start();\r
-\r
- return futureTask;\r
- }\r
-\r
- @Override\r
- public void unlock() {\r
- unlockFunc.apply(Tuple0.INSTANCE);\r
- }\r
-\r
- @Override\r
- public void restore(Path fromPath, int revision) {\r
- restoreFunc.apply(fromPath.toString(), revision);\r
- }\r
-\r
- public static IBackupProvider modelledBackup(\r
- Function1<Tuple0, Object> lockFunc,\r
- Function2<String, Integer, Function1<Tuple0, String>> backupFunc,\r
- Function1<Tuple0, Object> unlockFunc,\r
- Function2<String, Integer, Object> restoreFunc) {\r
-\r
- return new ModelledBackup(lockFunc, backupFunc, unlockFunc, restoreFunc);\r
- }\r
-}\r
+package org.simantics.backup.db;
+
+import java.nio.file.Path;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+
+import org.simantics.backup.BackupException;
+import org.simantics.backup.IBackupProvider;
+import org.simantics.scl.runtime.function.Function1;
+import org.simantics.scl.runtime.function.Function2;
+import org.simantics.scl.runtime.tuple.Tuple0;
+
+public class ModelledBackup implements IBackupProvider {
+
+ private final Function1<Tuple0, Object> lockFunc;
+ private final Function2<String, Integer, Function1<Tuple0, String>> backupFunc;
+ private final Function1<Tuple0, Object> unlockFunc;
+ private final Function2<String, Integer, Object> restoreFunc;
+
+ private ModelledBackup(
+ Function1<Tuple0, Object> lockFunc,
+ Function2<String, Integer, Function1<Tuple0, String>> backupFunc,
+ Function1<Tuple0, Object> unlockFunc,
+ Function2<String, Integer, Object> restoreFunc) {
+ this.lockFunc = lockFunc;
+ this.backupFunc = backupFunc;
+ this.unlockFunc = unlockFunc;
+ this.restoreFunc = restoreFunc;
+ }
+
+ @Override
+ public void lock() {
+ lockFunc.apply(Tuple0.INSTANCE);
+ }
+
+ @Override
+ public Future<BackupException> backup(Path targetPath, int revision) {
+
+ final Function1<Tuple0, String> fn = backupFunc.apply(targetPath.toString(), revision);
+
+ final FutureTask<BackupException> futureTask = new FutureTask<BackupException>(new Callable<BackupException>() {
+ @Override
+ public BackupException call() throws Exception {
+ try {
+ String error = fn.apply(Tuple0.INSTANCE);
+ if (error != null) {
+ return new BackupException(error);
+ } else {
+ return null;
+ }
+ } catch (Throwable t) {
+ return new BackupException(t);
+ }
+ }
+ });
+
+ Thread thread = new Thread(futureTask, "Backup Provider Thread " + backupFunc.toString());
+ thread.start();
+
+ return futureTask;
+ }
+
+ @Override
+ public void unlock() {
+ unlockFunc.apply(Tuple0.INSTANCE);
+ }
+
+ @Override
+ public void restore(Path fromPath, int revision) {
+ restoreFunc.apply(fromPath.toString(), revision);
+ }
+
+ public static IBackupProvider modelledBackup(
+ Function1<Tuple0, Object> lockFunc,
+ Function2<String, Integer, Function1<Tuple0, String>> backupFunc,
+ Function1<Tuple0, Object> unlockFunc,
+ Function2<String, Integer, Object> restoreFunc) {
+
+ return new ModelledBackup(lockFunc, backupFunc, unlockFunc, restoreFunc);
+ }
+}