TPPRATICO_SO

README.md

@@ -0,0 +1,5 @@
+TRABALHO PRATICO SISTEMAS OPERACIONAIS;
+
+GRUPO: ARTHUR ANGONESI MENDES, BERNARDO ALVAREZ, BRUNO FERRAZ
+
+ENTREGA FINAL: 20/06

filesys/Block.java

@@ -0,0 +1,45 @@
+package filesys;
+
+public class Block {
+    private byte[] data;
+    private int currentSize;
+    private final int capacity;
+
+    public Block(int capacity) {
+        this.capacity = capacity;
+        this.data = new byte[capacity];
+        this.currentSize = 0;
+    }
+
+    public int getCapacity() {
+        return capacity;
+    }
+
+    public int getCurrentSize() {
+        return currentSize;
+    }
+
+    public void setCurrentSize(int size) {
+        this.currentSize = size;
+    }
+
+    public byte[] getData() {
+        return data;
+    }
+
+    // Escreve até 'length' bytes de 'src' começando em 'srcOffset' para o bloco a partir de 'blockOffset'
+    public int write(byte[] src, int srcOffset, int length, int blockOffset) {
+        if (blockOffset >= capacity) return 0;
+        int bytesToWrite = Math.min(length, capacity - blockOffset);
+        System.arraycopy(src, srcOffset, data, blockOffset, bytesToWrite);
+        return bytesToWrite;
+    }
+
+    // Lê até 'length' bytes do bloco a partir de 'blockOffset' para 'dest' começando em 'destOffset'
+    public int read(byte[] dest, int destOffset, int length, int blockOffset) {
+        if (blockOffset >= currentSize) return 0;
+        int bytesToRead = Math.min(length, currentSize - blockOffset);
+        System.arraycopy(data, blockOffset, dest, destOffset, bytesToRead);
+        return bytesToRead;
+    }
+}

filesys/Directory.java

@@ -0,0 +1,67 @@
+package filesys;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class Directory {
+    private MetaData metaData;
+    private Map<String, Directory> subdirectories;
+    private Map<String, File> files;
+
+    public Directory(String name, String owner) {
+        this.metaData = new MetaData(name, owner, true);
+        this.subdirectories = new LinkedHashMap<>();
+        this.files = new LinkedHashMap<>();
+    }
+
+    public MetaData getMetaData() { return metaData; }
+
+    public Map<String, Directory> getSubdirectories() { return subdirectories; }
+    public Map<String, File> getFiles() { return files; }
+
+    public boolean containsSubdirectory(String name) {
+        return subdirectories.containsKey(name);
+    }
+
+    public boolean containsFile(String name) {
+        return files.containsKey(name);
+    }
+
+    public Directory getSubdirectory(String name) {
+        return subdirectories.get(name);
+    }
+
+    public File getFile(String name) {
+        return files.get(name);
+    }
+
+    public void addSubdirectory(Directory dir) {
+        subdirectories.put(dir.getMetaData().getName(), dir);
+    }
+
+    public void addFile(File file) {
+        files.put(file.getMetaData().getName(), file);
+    }
+
+    public void removeSubdirectory(String name) {
+        subdirectories.remove(name);
+    }
+
+    public void removeFile(String name) {
+        files.remove(name);
+    }
+
+    public boolean isEmpty() {
+        return subdirectories.isEmpty() && files.isEmpty();
+    }
+
+    // Cópia profunda da estrutura (sem arquivos e subdirs)
+    public Directory deepCopyStructure(String newName, String newOwner) {
+        Directory newDir = new Directory(newName, newOwner);
+        newDir.getMetaData().setPermission(newOwner, this.metaData.getPermissions().get(this.metaData.getOwner()));
+        if (this.metaData.getPermissions().containsKey("other")) {
+            newDir.getMetaData().setPermission("other", this.metaData.getPermissions().get("other"));
+        }
+        return newDir;
+    }
+}