Panov_I_A_task_3

commander/src/main/java/hse/java/commander/MainController.java

@@ -2,35 +2,111 @@
 
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
+import javafx.scene.control.Label;
 import javafx.scene.control.ListView;
 
-public class MainController {
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 
+public class MainController {
     @FXML
     public Button move;
+    @FXML
+    public ListView<String> left;
+    @FXML
+    public ListView<String> right;
+    @FXML
+    public Label leftPathLabel;
+    @FXML
+    public Label rightPathLabel;
+
+    private File leftDirectory = new File(System.getProperty("user.home"));
+    private File rightDirectory = new File(System.getProperty("user.home"));
 
     public void initialize() {
-        move.setOnMouseClicked(event -> {
+        refresh(left, leftDirectory);
+        refresh(right, rightDirectory);
 
+        left.setOnMouseClicked(event -> {
+            if (event.getClickCount() == 2) {
+                handleNavigation(left, true);
+            }
         });
-        System.out.println(System.getProperty("user.home"));
-       left.getItems().add("Kek");
-
-       left.setOnMouseClicked(event -> {
-           if (event.getClickCount() == 2) {
-               int index = left.getSelectionModel().getSelectedIndex();
-               if (index >= 0) {
-                   left.getItems().set(index, "clicked");
-               }
-           }
-       });
-   }
 
-    @FXML
-    public ListView<String> left;
+        right.setOnMouseClicked(event -> {
+            if (event.getClickCount() == 2) {
+                handleNavigation(right, false);
+            }
+        });
 
-    @FXML
-    public ListView<String> right;
+        move.setOnAction(event -> moveFile());
+    }
+
+    private void refresh(ListView<String> list, File directory) {
+        list.getItems().clear();
+        list.getItems().add("..");
+        File[] files = directory.listFiles();
+        if (files != null) {
+            for (File file : files) {
+                list.getItems().add(file.isDirectory() ? "[" + file.getName() + "]" : file.getName());
+            }
+        }
+        if (list == left) {
+            leftPathLabel.setText(directory.getAbsolutePath());
+        } else {
+            rightPathLabel.setText(directory.getAbsolutePath());
+        }
+    }
+
+    private void handleNavigation(ListView<String> list, boolean isLeft) {
+        String selected = list.getSelectionModel().getSelectedItem();
+        if (selected == null) return;
+
+        File currentDir = isLeft ? leftDirectory : rightDirectory;
+        File nextDirectory;
+
+        if (selected.equals("..")) {
+            nextDirectory = currentDir.getParentFile();
+        } else {
+            String name = selected.replace("[", "").replace("]", "");
+            nextDirectory = new File(currentDir, name);
+        }
+
+        if (nextDirectory != null && nextDirectory.isDirectory()) {
+            if (isLeft) {
+                leftDirectory = nextDirectory;
+            } else {
+                rightDirectory = nextDirectory;
+            }
+            refresh(list, nextDirectory);
+        }
+    }
+
+    private void moveFile() {
+        boolean moveFromLeft = left.getSelectionModel().getSelectedItem() != null;
+        ListView<String> fromList = moveFromLeft ? left : right;
+        File fromDirectory = moveFromLeft ? leftDirectory : rightDirectory;
+        File toDirectory = moveFromLeft ? rightDirectory : leftDirectory;
+
+        String selected = fromList.getSelectionModel().getSelectedItem();
+
+        if (selected == null || selected.equals("..")) {
+            return;
+        }
 
+        String name = selected.replace("[", "").replace("]", "");
+        Path source = new File(fromDirectory, name).toPath();
+        Path destination = new File(toDirectory, name).toPath();
 
-}
+        try {
+            Files.move(source, destination, StandardCopyOption.REPLACE_EXISTING);
+            refresh(left, leftDirectory);
+            refresh(right, rightDirectory);
+        } catch (IOException e) {
+            System.err.println("Анлак, не удалось перенести: " + e.getMessage());
+        }
+    }
+}

commander/src/main/resources/hse/java/commander/commander-ui.fxml

@@ -2,13 +2,26 @@
 
 <?import javafx.scene.control.*?>
 <?import javafx.scene.layout.*?>
+<?import javafx.geometry.Insets?>
 
-<VBox maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="421.0" prefWidth="627.0" xmlns="http://javafx.com/javafx/17.0.12" xmlns:fx="http://javafx.com/fxml/1" fx:controller="hse.java.commander.MainController">
-    <HBox prefHeight="370.0" prefWidth="627.0">
+<VBox prefHeight="500.0" prefWidth="700.0" spacing="10" xmlns="http://javafx.com/javafx/17.0.12" xmlns:fx="http://javafx.com/fxml/1" fx:controller="hse.java.commander.MainController">
+    <padding>
+        <Insets top="10" right="10" bottom="10" left="10"/>
+    </padding>
 
-        <ListView fx:id="left" prefHeight="318.0" prefWidth="311.0" />
-        <ListView fx:id="right" prefHeight="318.0" prefWidth="321.0" />
+    <HBox spacing="10" VBox.vgrow="ALWAYS">
+        <VBox HBox.hgrow="ALWAYS" spacing="5">
+            <Label fx:id="leftPathLabel" style="-fx-font-weight: bold;"/>
+            <ListView fx:id="left" VBox.vgrow="ALWAYS" />
+        </VBox>
 
+        <VBox HBox.hgrow="ALWAYS" spacing="5">
+            <Label fx:id="rightPathLabel" style="-fx-font-weight: bold;"/>
+            <ListView fx:id="right" VBox.vgrow="ALWAYS" />
+        </VBox>
     </HBox>
-   <Button fx:id="move" mnemonicParsing="false" text="Move" />
-</VBox>
+
+    <HBox spacing="10" alignment="CENTER_LEFT">
+        <Button fx:id="move" text="Move" prefWidth="120" />
+    </HBox>
+</VBox>

pom.xml

@@ -14,6 +14,8 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <junit.version>5.10.0</junit.version>
         <maven.surefire.version>3.1.2</maven.surefire.version>
+        <!-- Lombok version property to keep versions consistent -->
+        <lombok.version>1.18.38</lombok.version>
     </properties>
 
     <dependencies>
@@ -38,6 +40,12 @@
             <version>2.17.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -47,8 +55,18 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.11.0</version>
                 <configuration>
-                    <source>17</source>
-                    <target>17</target>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                    </annotationProcessorPaths>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                    <compilerArgs>
+                        <arg>-parameters</arg>
+                    </compilerArgs>
                 </configuration>
             </plugin>
             <plugin>

src/main/java/hse/java/lectures/lecture3/practice/randomSet/Node.java

@@ -0,0 +1,32 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class Node<T> {
+    @Setter
+    private T value;
+    @Setter
+    private Node<T> left;
+    @Setter
+    private Node<T> right;
+    private int size;
+
+    public Node(T value) {
+        size = 1;
+        this.value = value;
+        this.left = null;
+        this.right = null;
+    }
+
+    public void recalculateSize() {
+        size = 1;
+        if (left != null) {
+            size += left.getSize();
+        }
+        if (right != null) {
+            size += right.getSize();
+        }
+    }
+}

src/main/java/hse/java/lectures/lecture3/practice/randomSet/Pair.java

@@ -0,0 +1,4 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+public record Pair<L, R>(L left, R right) {
+}

src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java

@@ -1,21 +1,32 @@
 package hse.java.lectures.lecture3.practice.randomSet;
 
-public class RandomSet<T> {
+import java.util.Random;
+
+public class RandomSet<T extends Comparable<T>> {
+    private final Treap<T> treap;
+    private final Random random = new Random();
+
+    public RandomSet() {
+        treap = new Treap<>();
+    }
 
     public boolean insert(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        return treap.tryInsert(value);
     }
 
     public boolean remove(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        return treap.tryRemove(value);
     }
 
     public boolean contains(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        return treap.contains(value);
     }
 
     public T getRandom() {
-        throw new UnsupportedOperationException("Not implemented");
+        if (treap.getSize() == 0) {
+            throw new EmptySetException("Set is empty");
+        }
+        int randomIndex = random.nextInt(treap.getSize());
+        return treap.get(randomIndex);
     }
-
 }

src/main/java/hse/java/lectures/lecture3/practice/randomSet/Treap.java

@@ -0,0 +1,110 @@
+package hse.java.lectures.lecture3.practice.randomSet;
+
+import java.util.Optional;
+import java.util.Random;
+
+public class Treap<T extends  Comparable<T>> {
+    private Node<T> root;
+    private final Random random;
+
+    public Treap() {
+        root = null;
+        random = new Random();
+    }
+
+    private boolean findByValue(Node<T> node, T value) {
+        if (node == null) {
+            return false;
+        }
+        int compareResult = node.getValue().compareTo(value);
+        if (compareResult == 0) {
+            return true;
+        }
+        if (compareResult > 0) {
+            return findByValue(node.getLeft(), value);
+        }
+        return findByValue(node.getRight(), value);
+    }
+
+    private Optional<T> findByIndex(Node<T> currentNode, int index) {
+        if (currentNode == null) {
+            return Optional.empty();
+        }
+        int leftSize = currentNode.getLeft() != null ? currentNode.getLeft().getSize() : 0;
+        if (index < leftSize) {
+            return findByIndex(currentNode.getLeft(), index);
+        } else if (index == leftSize) {
+            return Optional.of(currentNode.getValue());
+        } else {
+            return findByIndex(currentNode.getRight(), index - leftSize - 1);
+        }
+    }
+
+    private Pair<Node<T>, Node<T>> split(Node<T> currentNode, T value) {
+        if (currentNode == null) {
+            return new Pair<>(null, null);
+        }
+        int compareResult = currentNode.getValue().compareTo(value);
+        if (compareResult == 0) {
+            return new Pair<>(currentNode.getLeft(), currentNode.getRight());
+        } else if (compareResult < 0) {
+            var splitResult = split(currentNode.getRight(), value);
+            currentNode.setRight(splitResult.left());
+            currentNode.recalculateSize();
+            return new Pair<>(currentNode, splitResult.right());
+        } else {
+            var splitResult = split(currentNode.getLeft(), value);
+            currentNode.setLeft(splitResult.right());
+            currentNode.recalculateSize();
+            return new Pair<>(splitResult.left(), currentNode);
+        }
+    }
+
+    private Node<T> merge(Node<T> leftNode, Node<T> rightNode) {
+        if (leftNode == null) {
+            return rightNode;
+        }
+        if (rightNode == null) {
+            return leftNode;
+        }
+        if (random.nextInt(leftNode.getSize() + rightNode.getSize()) < leftNode.getSize()) {
+            leftNode.setRight(merge(leftNode.getRight(), rightNode));
+            leftNode.recalculateSize();
+            return leftNode;
+        } else {
+            rightNode.setLeft(merge(leftNode, rightNode.getLeft()));
+            rightNode.recalculateSize();
+            return rightNode;
+        }
+    }
+
+    public int getSize() {
+        return root != null ? root.getSize() : 0;
+    }
+
+    public boolean contains(T value) {
+        return findByValue(root, value);
+    }
+
+    public boolean tryInsert(T value) {
+        if (contains(value)) {
+            return false;
+        }
+        var splitResult = split(root, value);
+        root = merge(merge(splitResult.left(), new Node<>(value)), splitResult.right());
+        return true;
+    }
+
+    public boolean tryRemove(T value) {
+        if (!contains(value)) {
+            return false;
+        }
+        var splitResult = split(root, value);
+        root = merge(splitResult.left(), splitResult.right());
+        return true;
+    }
+
+    public T get(int index) {
+        return findByIndex(root, index).orElseThrow(() -> new IllegalArgumentException("Index out of bounds"));
+    }
+}