Fixed all line endings of the repository

[simantics/platform.git] / bundles / org.simantics.backup.db / src / org / simantics / backup / db / ModelledBackup.java

diff --git a/bundles/org.simantics.backup.db/src/org/simantics/backup/db/ModelledBackup.java b/bundles/org.simantics.backup.db/src/org/simantics/backup/db/ModelledBackup.java
index 258915ce8fad04e1865bb67281335c753a0bce0b..f349723262c2a09ba88a7a9d16aacf728b808c1b 100644 (file)
--- a/bundles/org.simantics.backup.db/src/org/simantics/backup/db/ModelledBackup.java
+++ b/bundles/org.simantics.backup.db/src/org/simantics/backup/db/ModelledBackup.java
@@ -1,82 +1,82 @@
-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);
+    }
+}