Приложение для работы с файлами с функциональностью Проводника Windows

package ru.junior_progger.entity;
 
public enum Operation {
    Help, 
    DefaultPath, 
    ShowFiles,
    OpenFile,
    WriteToFile,
    ShowFileNames,
    ShowDirectoryNames,
    CreateFile,
    CreateDirectory,
    DeleteFile,
    DeleteDirectory,
    CopyFile,
    CopyDirectory,
    RenameFile,
    RenameDirectory,
    FindFile,
    FindDirectory,
    MoveFile,
    MoveDirectory,
    ShowSubDirectories,
    LookHiddenFiles,
    LookHiddenDirectories,
    HideDirectory,
    HideFile,
    Exit;
    
    public static Operation getValueOf(String text) {
        switch (text.toLowerCase()) {
        case "-1":
        case "?":
        case "/?":
        case "help":
            return Help;
        case "path":
        case "change default path":
        case "change path":
            return DefaultPath;
        case "files":
        case "show files":
        case "show all files":
            return ShowFiles;
        case "show file names":
        case "file names":
            return ShowFileNames;
        case "directory names":
        case "dir names":
        case "dirs":
            return ShowDirectoryNames;
        case "create file":
            return CreateFile;
        case "delete file":
            return DeleteFile;
        case "copy file":
            return CopyFile;
        case "rename file":
            return RenameFile;
        case "find file":
            return FindFile;
        case "move file":
            return MoveFile;
        case "show directories":
        case "show sub directories":
        case "directories":
            return ShowSubDirectories;
        case "create directory":
            return CreateDirectory;
        case "delete directory":
            return DeleteDirectory;
        case "copy directory":
            return CopyDirectory;
        case "find directory":
            return FindDirectory;
        case "rename directory":
            return RenameDirectory;
        case "move directory":
            return MoveDirectory;
        case "show hidden files":
            return LookHiddenFiles;
        case "show hidden directories":
            return LookHiddenDirectories;
        case "hide file":
            return HideFile;
        case "hide directory":
            return HideDirectory;
        case "open file":
            return OpenFile;
        case "write to file":
            return WriteToFile;         
        case "exit":
            return Exit;
        default:
            return null;
        }
    }
}

package core.systems;
 
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
 
/*
 * Author Gundarev Aleksey
 * Last fix : 07.10.2013 by 3jIo
 * 
 *Описание класса:
 *
 *Ядро программы , которое обеспечивает взаимодействие с файлами в 
 *Virtual File System. Различие между файлом и папкой (листом и узлом)
 *в том что папка может содеражать другие папки и файлы (листы или узлы) и тд.
 *Дял создания объекта типа File нужно воспользоваться методом  createFile или
 *createDir который принимают 2 параметра:
 *String name : Имя папки/файла (узла/листа)
 *File parent : Родитель папки/файла (это может быть каталог или дочерняя папка в какой-то иерархии,
 *если родителя нету (parent == null) , то это означает что мы создаем каталог.)
 *
 *
 *Используемый паттер :
 * Компоновщик
 *
 *Потоко безопастный класс (все методы синхронизированны)
 */
 
 
public class File extends Dir implements Comparable<File>
{
    private volatile String name;
    private List<File> contents;
    private volatile File parent;
    private boolean isFile;
    private Date createDate;
    private static SimpleDateFormat format = new SimpleDateFormat();
    private List<String> blockedList = new ArrayList<String>();
    private static Pattern fileCheck = Pattern.compile("[\\\\/:*?\"<>|]+");  //("[A_Za-z0-9_!~=+-.]+\\.[A_Za-z0-9_!~=+-]+");
    
    
    public List<String> getBlockedList()
    {
        return blockedList;
    }
    
    
    public static void main (String [] args)
    {
        
        /*
        Matcher match = fileCheck.matcher("fi.le.cpp");
        System.out.println(match.matches());
        
        
        List<File> list = new ArrayList<File>();
        
        for(int i = 10; i > 0; i--)
        {
            list.add(new File("Test " + i, true,null));
        }
        
        for(int i = 20; i > 10; i--)
        {
            list.add(new File("Test " + i, false,null));
        }
        
        System.out.println("Before sort: ");
        
        for(int i = 0; i < list.size(); i++)
        {
            System.out.println(list.get(i));
        }
        
        System.out.println("After sort: ");
        Collections.sort(list);
        
        for(int i = 0; i < list.size(); i++)
        {
            System.out.println(list.get(i));
        }
        */
        
        
        
        
        Pattern patt = Pattern.compile("^.:");
        Matcher match = patt.matcher("c:\\test");
        System.out.println(match.find());
        
        /*
        ------
        Catalogue catalogue = Catalogue.newCatalog("C:");
        
        //catalogue.newFile("operation.txt");
        //catalogue.newFile("localFile.cpp");
        //catalogue.newFile("javaFile.java");
        //catalogue.newFile("cppFile.h");
        
        boolean bol = catalogue.newDir("MyFiles");
        
        if(!bol)
        {
            System.out.println("Trouble");
            
            System.exit(111);
        }
        //catalogue.newDir("temp");
        //catalogue.newDir("LikeThis");
        
        catalogue.getFile("MyFiles").newFile("Test1.txt");
        catalogue.getFile("MyFiles").newFile("Test2.txt");
        catalogue.getFile("MyFiles").newFile("Test3.txt");
        catalogue.getFile("MyFiles").newDir("TestDir");
        
        catalogue.getFile("MyFiles").getFile("TestDir").newFile("MyFile.txt");
        catalogue.getFile("MyFiles").getFile("TestDir").newFile("MyFile2.txt");
        
        
        catalogue.getFile("MyFiles").getFile("TestDir").getFile("MyFile.txt").lockFile("System");
        catalogue.getFile("MyFiles").getFile("Test3.txt").lockFile("I am");
        
        System.out.println(catalogue.showTree());
        */
 
        
    }
    
    public static boolean checkFileName(String name)
    {
        Matcher match = fileCheck.matcher(name);
        
        if(match.find())
        {
            return false;
        }
        
        return true;
    }
    
    
    public String getAbsolutePath()
    {
        List<String> temp = new ArrayList<String>(3);
        temp.add(getName());
        
        File file = getParent();
        
        if(file != null)
        {
            temp.add(file.getName());
            
            while(((file = file.getParent()) != null))
            {
                temp.add(file.getName());
            }
            
            Collections.reverse(temp);
            
            StringBuilder builder = new StringBuilder();
            
            Iterator<String> iter = temp.iterator();
            
            while(iter.hasNext())
            {
                builder.append(iter.next()).
                append("\\");
            }
            
            return builder.toString();
        }
        
        //Каталог, парентов нету
        return temp.get(0);
    }
    
    @SuppressWarnings("unused")
    private Object sortHelper(Object [] obj)
    {
        Object [] temp = new Object[obj.length];
        
        for(int i = obj.length - 1, j = 0;  j < obj.length || i > 0;  j++, i--)
        {
            temp[j] = obj[i];
        }
        
        return temp;
    }
    
    
    //Возвращает кол-во всех элементов в иерархии
    public int treeLength()
    {
        File file = getParent();
        
        if(file != null)
        {
            //Текущий объект + парент = 2;
            int size = 2;
            
            for( ; ((file = file.getParent()) != null); size++);
            
            return size;
        }
        
        //Каталог, предков нету.
        return 1;
    }
    
    
    //Блокирует файл по имени
    //Thread safe
    public boolean lockFile(String blockerName)
    {
        synchronized (blockedList) 
        {
            Iterator<String> iter = blockedList.iterator();
            
            while(iter.hasNext())
            {
                //Не допускаем деад-локов
                if(iter.next().equals(blockerName))
                {
                    return false;
                }
            }
            blockedList.add(blockerName);
        }
        return true;
    }
    
    //разблокировка файла 
    //PS Папки может блокировать только Systems или же если имеются вложенные блок. файлы (как указанно заказчиком)
    public boolean unlockFile(String blockerName)
    {
        synchronized (blockedList)
        {
            return blockedList.remove(blockerName);
        }
    }
    
    //Возвращает true если имеються заблокированные файлы 
    //или текущий файл кем-то заблокирован
    public boolean isBlocked()
    {
        synchronized (blockedList) 
        {
            return !blockedList.isEmpty();
        }
    }
    
    
    public static File createFile(String name,File back)
    {
        
        if(checkFileName(name))
        {
            return new File(name,true,back);    
        }
        
        return null;
        
    }
    
    public static File createDir(String name,File back)
    {
        
        if(checkFileName(name))
        {
            return new File(name,false,back);   
        }
        
        return null;
    }
    
    
    protected File(String name,boolean isFile,File back)
    {
        setName(name);
        this.isFile = isFile;
        createDate = new Date();
        this.parent = back;
        
        if(!isFile)
        {
            contents = new LinkedList<File>();
        }
    }
    
    public void setParent(File file)
    {
        this.parent = file;
    }
    
    public boolean isFile()
    {
        return isFile;
    }
    
    public boolean isDir()
    {
        return !isFile;
    }
    
    private boolean addFile(String name,boolean isFile)
    {
            //Если Текущий объект папка
            if(isDir())
            {
                synchronized (contents)
                {
                    for(int i = 0; i < contents.size(); i++)
                    {
                        if(contents.get(i).getName().equalsIgnoreCase(name))
                        {
                            return false;
                        }
                    }
 
                    contents.add(new File(name,isFile,this));
                    //Так как операций на чтение больше. (Можно использовать дерево)
                    Collections.sort(contents);
                }
                return true;
            }
    
        return false;
    }
    
    public boolean newFile(String name)
    {
        return addFile(name, true);
    }
    
    public boolean newDir(String name)
    {
        return addFile(name, false);
    }
    
    private ReentrantReadWriteLock nameLock = new ReentrantReadWriteLock();
    private Lock writeLock = nameLock.writeLock();
    private Lock readLock = nameLock.readLock();
    
    public String getName()
    {
        readLock.lock();
        
        try
        {
            return name;
        }
        finally
        {
            readLock.unlock();
        }
        
    }
    
    private void setName(String name)
    {
        writeLock.lock();
        
        try
        {
            this.name = name;
        }
        finally
        {
            writeLock.unlock();
        }
        
    }
    
    public boolean rename(String name)
    {
        Matcher match = fileCheck.matcher(name);
        
        if(match.matches())
        {
            if(!isBlocked())
            {
                setName(name);
                
                return true;
            }
            
        }
        
        return false;
    }
    
    public String createDate()
    {
        return format.format(createDate);
    }
 
 
    @Override
    public int compareTo(File o) 
    {
        if(isFile && o.isFile)
        {
            return getName().compareTo(o.getName());
        }
        
        return isFile ? 1 : -1;
    }
    
    public String showContents()
    {
        if(isDir())
        {
            if(!isEmpty())
            {
                StringBuilder builder = new StringBuilder();
                
                synchronized (contents)
                {
                    //Collections.sort(contents);
                    Iterator<File> iter = contents.iterator();
                
                    while(iter.hasNext())
                    {
                        builder.append(iter.next());
                    }
                
                    return builder.toString();
                }
            }
            
            return "empty";
        }
        
        return null;
    }
    
    
    public List<File> getContents()
    {
        return contents;
    }
    
    /*
     * Возвращает файл по имени
     * если такого файла нету возврашает null
     */
    public File getFile(String name)
    {
        if(!contents.isEmpty())
        {
            synchronized (contents)
            {
                Iterator<File> iter = contents.iterator();
                File file;
                
                while(iter.hasNext())
                {
                    file = iter.next();
                    
                    if(file.getName().equalsIgnoreCase(name))
                    {
                        return file;
                    }
                }
            }
 
        }
        
        return null;
    }
 
    
    @Override
    public String toString() 
    {
        StringBuilder builder = new StringBuilder();
        
        builder.append(getName()).append("\t").append(isFile ? "File" : "Dir")
        .append("\t").append(createDate());
        
        return builder.toString();
    }
    
    public File getParent()
    {
        return parent;
    }
    
    
    //Используется при перемещение файлов
    public boolean add(File file)
    {
        if(isDir())
        {
            File fl = file.getParent();
            
            //Только у каталогов парент == null
            //Поэтому собственно мы не можем его добавить в другую директорию
                if(fl != null)
                {       
                    //Проверяем нужно ли переименновать файл
                    tryRename(file, this);
                    
                    synchronized (contents) 
                    {
                        if(contents.add(file))
                        {
                            fl.delete(file);
                            
                            file.setParent(this);
                            
                            return true;
                        }
                    }
                }
        }
        
        return false;
    }
    
    public boolean checkRename(File in,File out)
    {
        if(in == null || out == null)
        {
            return false;
        }
        
        return checkRename(in.getName(), out);
    }
    
    public boolean checkRename(String in,File out)
    {
        if(!out.isEmpty() && out.isDir())
        {
            synchronized (out.contents) 
            {
                Iterator<File> iter = out.contents.iterator();
                
                while(iter.hasNext())
                {
                    if(in.equalsIgnoreCase(iter.next().getName()))
                    {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }
    
    
    public void tryRename(File in,File out)
    {
        int tr = 1;
        while(checkRename(in,out))
        {
            in.setName(in.getName() + "_COPY(" + tr++ + ")");
        }
        
    }
 
    //Копирование реализованно рекурсией
    //System -- Система имя запрещенное для использования
    @Override
    public File clone() throws CloneNotSupportedException 
    {
        File file;
        
        lockFile("System");
        
        try
        {
            if(isFile())
            {
                file = new File(name, isFile, parent);
                file.blockedList = new ArrayList<String>();
                file.createDate = (Date) createDate.clone();
                return file;
            }
            else
            {
                return copyHelper(this);
            }
            
        }finally
        {
            unlockFile("System");
        }
    }
    
    //Fixed 3jIo (05.10.2013) : метод удалял оригинал
    //Вспомогательный метод для clone образующий рекурсию
    //Thread safe
    private File copyHelper(File file) throws CloneNotSupportedException
    {
        File fl = null;
        
        if(file.isDir())
        {
            fl = new File(file.getName(),false,file.parent);
            fl.createDate = (Date) file.createDate.clone();
            List<File> temp = file.contents;
            fl.contents = new ArrayList<File>(temp.size());
            fl.blockedList = new ArrayList<String>();
            
            synchronized (temp) 
            {
                Iterator<File> iter = temp.iterator();
                File tmp;
                
                while(iter.hasNext())
                {
                    tmp = iter.next().clone();
                    tmp.setParent(fl);
                    fl.contents.add(tmp);
                }
            }
            
        }
        
        return fl;
    }
    
    //Вешать блокировку на папку может только система или содеражищиеся файлы
    /*
     * Метод запускает рекурсивный метод который проверяет есть ли заблокированные
     * потомки 
     * Если вызван для файла то просто вызращает результат метода isBlocked файла
     * тоже самое и для пустой папки , так как она все равно может быть заблокированна
     */
    public boolean checkBlockedDir()
    {
        if(isDir() && !isBlocked())
        {
            return checkBlockedHelper(this);
        }
        
        return isBlocked();
    }
    
    public boolean checkBlockedDir(File file)
    {
        if(file.isDir() && !file.isBlocked())
        {
            return checkBlockedHelper(file);
        }
        
        return file.isBlocked();
    }
    
    //Рекурсивный метод проходящий по всем вложенным файлам
    //Возвращает true если есть заблокированные файлы
    //Папка может быть заблокированна системой или же если её кто-то использует или просматривает
    //то папку нельзя удалить, иначе возникнут коллизии и баги.
    
    private boolean checkBlockedHelper(File file)
    {
        if(file.isDir() && !file.isBlocked())
        {
            synchronized (file.getContents())
            {
                Iterator<File> iter = file.getContents().iterator();
                
                while(iter.hasNext())
                {
                    if(checkBlockedHelper(iter.next()))
                    {
                        return true;
                    }
                }
            }
            
            return false;
        }
       return file.isBlocked();
    }
    
    //Удаляет из contents ссылку,если есть вложенные заблокированные файлы 
    //То возвращает false
    //Thread Safe
    public boolean delete(File file)
    {
        if(!checkBlockedDir(file))
        {
            synchronized (contents) 
            {
                return contents.remove(file);
            }
        }
 
        return false;
    }
    
    
    
    //Удаляет из contents ссылку объекта, поле this.name которого ровна name
    public boolean delete(String name)
    {
        synchronized (contents)
        {
            Iterator<File> iter = contents.iterator();
            File file;
        
            while(iter.hasNext())
            {
                file = iter.next();
            
                if(file.getName().equalsIgnoreCase(name) && !file.checkBlockedDir())
                {
                    iter.remove();
                    return true;
                }
            }
        }
        
        return false;
    
    }
    
    //Вспомогательный метод который сообщает есть ли 
    // содержатся ли другие файлы в папке
    //Если текущий объект не папка то false
    public boolean isEmpty()
    {
        if(isDir())
        {
            synchronized (contents) 
            {
                return contents.isEmpty();
            }
        }
        
        return false;
    }
    
        
    /*
     * Проверяет не находится ли parent
     * выше по иерархии текущего файла
     * возвращает true если parent является 
     * предком текущего файла
     */
    
    public boolean checkParent(File parent)
    {
        return checkParent(this, parent);
    }
    
    /*
     * Проверяет не находится ли parent
     * выше по иерархии child.
     * возвращает true если parent является
     * предком child
     */
    
    public static boolean checkParent(File child,File parent)
    {
        if(child != null && parent != null)
        {
            synchronized (child) 
            {
                if(parent != child)
                {
                    return checkParent(child.getParent(), parent);
                }
            }
            
            return true;
        }   
        return false;
    }
    
}