private java.io.File file; //<--DO NOT USE DIRECTLY! Use getFile() instead.

private String name = "";

private String path = "";

//private boolean useCache = false;

private FileSystemWatcher FileSystemWatcher;

private File.FileAttributes attr;

private long lastAttrUpdate = 0;

public static final String PathSeparator = System.getProperty("file.separator");

protected static final boolean isWindows = System.getProperty("os.name").toLowerCase().startsWith("windows");

private static final boolean isMac = System.getProperty("os.name").toLowerCase().contains("mac");

private boolean directorySearchInitialized = false;

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of Directory using a path to a directory.

public Directory(String Path) {

if (Path==null) throw new NullPointerException();

if (Path.startsWith("\"") && Path.endsWith("\"")){

Path = Path.substring(1,Path.length()-1);

}

init(Path);

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of Directory using a java.io.File

public Directory(java.io.File File) {

init(File);

}

//**************************************************************************

//** init

//**************************************************************************

private void init(java.io.File File){

if (File==null) throw new NullPointerException();

if (File.exists() && !File.isDirectory()){

File = File.getParentFile();

}

attr = null;

String p = File.getAbsolutePath();

init(p);

if (p.equals(toString())){

this.file = File;

}

}

//**************************************************************************

//** init

//**************************************************************************

/** Used to parse the absolute path to the directory. For performance reasons,

private void init(String Path){

Path = Path.replace("\\", "/");

String[] arr = Path.split("/");

if (arr.length>1){

name = arr[arr.length-1];

path = Path.substring(0, Path.lastIndexOf(name));

}

else{

path = Path;

}

if (path.isEmpty()) path = PathSeparator;

else path = path.replace("/", PathSeparator);

if (!path.endsWith(PathSeparator)) path += PathSeparator;

//Special case for relative paths

if (path.startsWith(".")){

try{

init(new java.io.File(path + name).getCanonicalPath());

}

catch(Exception e){

throw new IllegalArgumentException("Invalid Path.");

}

}

}

//**************************************************************************

//** getFile

//**************************************************************************

/** Returns the java.io.File representation of this object. */

private java.io.File getFile(){

if (file==null) file = new java.io.File(path + name);

return file;

}

//**************************************************************************

//** getRootDirectories

//**************************************************************************

/** Returns an array of root directories on the filesystem (e.g. "/" or C:\").

public static Directory[] getRootDirectories(){

java.util.TreeSet<Directory> directories = new java.util.TreeSet<Directory>();

java.io.File[] files = java.io.File.listRoots();

if (files==null) return new Directory[0];

for (int i=0; i<files.length; i++){

directories.add(new Directory(files[i]));

}

//Pick up any windows mounted drives that might not have been returned

//from the listRoots() method (e.g. disconnected mounted drives).

if (isWindows){

boolean doNetUse = false;

if (File.loadDLL()){

try{

String drives = File.GetNetworkDrives();

if (drives!=null){

for (String drive : drives.split("\n")){

if (drive.trim().length()>0){

String[] arr = drive.split("\t");

String driveName = arr[0];

String driveType = arr[1];

directories.add(new Directory(driveName));

}

}

}

}

catch(Exception e){

doNetUse = true;

}

}

else{

doNetUse = true;

}

if (doNetUse){

javaxt.io.Shell cmd = new javaxt.io.Shell("net use");

try{cmd.run();}catch(Exception e){}

java.util.Iterator<String> it = cmd.getOutput().iterator();

boolean parse = false;

while (it.hasNext()){

String line = it.next();

if (line==null) break;

else line = line.trim();

if (!parse && line.startsWith("----")){

parse = true;

line = it.next();

if (line==null) break;

}

if (line.contains(":")){

line = line.substring(0, line.indexOf(":")+1);

line = line.substring(line.lastIndexOf(" ")+1);

directories.add(new Directory(line.trim()));

}

}

}

}

return directories.toArray(new Directory[directories.size()]);

}

//**************************************************************************

//** Exists

//**************************************************************************

/** Used to determine whether a directory exists on the file system.

public boolean exists(){

String path = this.path + name;

//Special case for a directory whose path represents a server name (e.g. "\\192.168.0.1")

if (isWindows && path.startsWith("\\\\")){

if (path.endsWith(PathSeparator)) path = path.substring(0, path.length()-1);

if (!path.substring(2).contains(PathSeparator)){

boolean doNetUse = false;

if (File.loadDLL()){

try{

File.GetSharedDrives(path.substring(2));

return true;

}

catch(Exception e){

if (e.getMessage().trim().equals("53")){

return false;

}

else{

doNetUse = true;

}

}

}

else{

doNetUse = true;

}

if (doNetUse){

javaxt.io.Shell cmd = new javaxt.io.Shell("net view " + path);

try{cmd.run();}catch(Exception e){}

java.util.List errors = cmd.getErrors();

errors.remove(null);

if (errors.isEmpty()){

return true;

}

else{

return false;

}

}

}

}

if (file!=null){

return (file.isDirectory() && file.exists());

}

try{

File.FileAttributes attr = getFileAttributes();

if (attr!=null) return true;

else{

getFile();

return (file.isDirectory() && file.exists());

}

}

catch(java.io.FileNotFoundException e){

return false;

}

}

//**************************************************************************

//** isEmpty

//**************************************************************************

/** Used to determine whether the directory is empty. Returns true if no

public boolean isEmpty(){

if (!exists()) return true;

Object[] files = listFiles(null);

return (files==null);

}

//**************************************************************************

//** Create Directory

//**************************************************************************

/** Used to create the directory. Returns true if the directory was

public boolean create(){

return getFile().mkdirs();

}

//**************************************************************************

//** Delete Directory

//**************************************************************************

/** Used to delete the directory. Returns true if the directory was

public boolean delete(){

//Delete files and generate an ordered list of subfolders

TreeMap<Integer, HashSet<java.io.File>> paths = new TreeMap<>();

List files = getChildren(true, null, false);

Object obj;

while (true){

synchronized (files) {

while (files.isEmpty()) {

try {

files.wait();

}

catch (InterruptedException e) {

break;

}

}

obj = files.remove(0);

files.notifyAll();

}

if (obj==null){ //file search is complete

break;

}

else{

if (obj instanceof javaxt.io.File){

javaxt.io.File f = (javaxt.io.File) obj;

f.delete();

}

else{

javaxt.io.Directory dir = (javaxt.io.Directory) obj;

int numFolders = 0;

javaxt.io.Directory d = dir.clone();

while (!d.equals(this)){

d = d.getParentDirectory();

numFolders++;

}

HashSet<java.io.File> set = paths.get(numFolders);

if (set==null){

set = new HashSet<>();

paths.put(numFolders, set);

}

set.add(dir.toFile());

}

}

}

//Delete subfolders

for (Integer numFolders : paths.descendingKeySet()){

for (java.io.File d : paths.get(numFolders)){

d.delete();

}

}

if (getFile().delete()){

attr = null;

return true;

}

else{

return false;

}

}

//**************************************************************************

//** Copy To

//**************************************************************************

/** Used to copy a directory to another directory. Preserves the last modified

public String[] copyTo(Directory Destination, boolean Overwrite){

return copyTo(Destination, null, Overwrite);

}

//**************************************************************************

//** Copy To

//**************************************************************************

/** Used to copy a directory to another directory. Provides a filter option

public String[] copyTo(Directory Destination, Object filter, boolean Overwrite){

int source = toString().length();

String destination = Destination.toString();

java.util.ArrayList<String> failures = new java.util.ArrayList<String>();

//Create new folder

if (!Destination.exists()) Destination.create();

//Initiate search

java.util.List results = this.getChildren(true, filter, false);

while (true){

Object item;

synchronized (results) {

//Wait for files/directories to be added to the list

while (results.isEmpty()) {

try {

results.wait();

}

catch (InterruptedException e) {

break;

}

}

//Grab the next available file/directory from the list. Note that

//we are INSIDE the synchronized block! This forces the directory

//search to insert only one record at a time. The primary motivation

//for this is to ensure that we don't run out of memory when

//copying a large number of files/directories.

item = results.get(0);

if (item!=null){

if (item instanceof javaxt.io.File){

javaxt.io.File file = (javaxt.io.File) item;

String FilePath = file.toString();

File out = new File(destination + FilePath.substring(source));

boolean success = file.copyTo(out, Overwrite);

if (!success) failures.add(FilePath);

}

else{

javaxt.io.Directory dir = (javaxt.io.Directory) item;

new Directory(destination + dir.toString().substring(source)).create();

}

}

else{

break;

}

results.remove(0);

results.notifyAll();

}

}

//Return list of failed copies

return failures.toArray(new String[failures.size()]);

}

//**************************************************************************

//** Move To

//**************************************************************************

/** Used to move a directory from one directory to another. */

public void moveTo(Directory Destination, boolean Overwrite){

if (Overwrite || !Destination.exists()){

java.io.File newFile = Destination.toFile();

if (getFile().renameTo(newFile)){

init(newFile);

}

}

}

//**************************************************************************

//** Rename

//**************************************************************************

/** Used to rename the directory. */

public void rename(String Name){

java.io.File newFile = new java.io.File(path + Name);

if (getFile().renameTo(newFile)){

init(newFile);

}

}

//**************************************************************************

//** getName

//**************************************************************************

/** Returns the name of the directory (excluding the path). */

public String getName(){

return name;

}

//**************************************************************************

//** getPath

//**************************************************************************

/** Returns the full path to this directory, including the directory name.

public String getPath(){

String path = this.path + name;

if (path.endsWith(PathSeparator)) return path;

else return path + PathSeparator;

}

//**************************************************************************

//** getDate

//**************************************************************************

/** Returns a timestamp of when the directory was last modified. This is

public java.util.Date getDate(){

if (file!=null) return getFileDate();

try{

File.FileAttributes attr = getFileAttributes();

if (attr!=null) return attr.getLastWriteTime();

else{

getFile();

return getFileDate();

}

}

catch(java.io.FileNotFoundException e){

return null;

}

}

private java.util.Date getFileDate(){

if (file.exists() && file.isDirectory()) return new java.util.Date(file.lastModified());

else return null;

}

//**************************************************************************

//** setDate

//**************************************************************************

/** Used to set the timestamp of when the directory was last modified.

public boolean setDate(java.util.Date lastModified){

if (lastModified!=null){

java.io.File file = getFile();

if (file.exists() && file.isDirectory()){

long t = lastModified.getTime();

if (getDate().getTime()!=t){

attr = null;

return getFile().setLastModified(t);

}

}

}

return false;

}

//**************************************************************************

//** getSize

//**************************************************************************

/** Returns the total size of all the files and folders found in this

public long getSize(){

long size = 0L;

//Initiate search

java.util.List results = getChildren(true, null, false);

while (true){

Object item;

synchronized (results) {

while (results.isEmpty()) {

try {

results.wait();

}

catch (InterruptedException e) {

break;

}

}

item = results.remove(0);

results.notifyAll();

}

if (item!=null){ //Do something with the item.

if (item instanceof javaxt.io.File){

javaxt.io.File file = (javaxt.io.File) item;

size += file.getSize();

}

else{

javaxt.io.Directory dir = (javaxt.io.Directory) item;

try{

//size += dir.getFileAttributes().getSize();

}

catch(Exception e){

}

}

}

else{ //item is null. This is our queue that the search is done!

return size;

}

}

}

//**************************************************************************

//** isHidden

//**************************************************************************

/** Used to determine whether this Directory is Hidden */

public boolean isHidden(){

if (file!=null){

return (file.isDirectory() && file.isHidden());

}

try{

File.FileAttributes attr = getFileAttributes();

if (attr!=null) return attr.isHidden();

else{

getFile();

return (file.isDirectory() && file.isHidden());

}

}

catch(java.io.FileNotFoundException e){

return false;

}

}

//**************************************************************************

//** isLink

//**************************************************************************

/** Used to determine whether the directory is actually a link to another

public boolean isLink(){

return getLink()!=null;

}

//**************************************************************************

//** getLink

//**************************************************************************

/** Returns the target of a symbolic link or Windows junction

public java.io.File getLink(){

try{

return getFileAttributes().getLink();

}

catch(Exception e){

return null;

}

}

//**************************************************************************

//** getLastModifiedTime

//**************************************************************************

/** Returns a timestamp of when the directory was last modified. This is

public java.util.Date getLastModifiedTime(){

return this.getDate();

}

//**************************************************************************

//** getCreationTime

//**************************************************************************

/** Returns a timestamp of when the directory was first created. Returns a

public java.util.Date getCreationTime(){

try{

return getFileAttributes().getCreationTime();

}

catch(Exception e){

return null;

}

}

//**************************************************************************

//** getLastAccessTime

//**************************************************************************

/** Returns a timestamp of when the directory was last accessed. Returns a

public java.util.Date getLastAccessTime(){

try{

return getFileAttributes().getLastAccessTime();

}

catch(Exception e){

return null;

}

}

//**************************************************************************

//** getFlags

//**************************************************************************

/** Returns keywords representing directory attributes. Returns an empty

public java.util.HashSet<String> getFlags(){

try{

return getFileAttributes().getFlags();

}

catch(Exception e){

return new java.util.HashSet<String>();

}

}

//**************************************************************************

//** getFileAttributes

//**************************************************************************

/** Returns file attributes such as when the file was first created and when

public File.FileAttributes getFileAttributes() throws java.io.FileNotFoundException {

if (attr==null) lastAttrUpdate = 0;

if (attr==null || (new java.util.Date().getTime()-lastAttrUpdate)>1000){

try{

//Get directory attributes

String pathToFile = toString();

attr = new File.FileAttributes(pathToFile);

if (!attr.isDirectory()) throw new java.io.FileNotFoundException(pathToFile);

//Set lastUpdate (used to cache file attributes)

lastAttrUpdate = new java.util.Date().getTime();

}

catch(java.io.FileNotFoundException e){

attr = null;

throw e;

}

catch(Exception e){

//e.printStackTrace();

attr = null;

}

}

return attr;

}

//**************************************************************************

//** getParentDirectory

//**************************************************************************

/** Used to retrieve this Directory's Parent. Returns null if there is no

public Directory getParentDirectory(){

if (name.isEmpty()){

return null;

}

else{

return new Directory(path);

}

}

//**************************************************************************

//** toFile

//**************************************************************************

/** Used to retrieve the java.io.File representation by this object. */

public java.io.File toFile(){

return getFile();

}

//**************************************************************************

//** getFiles

//**************************************************************************

/** Used to retrieve an array of files found in this directory. Returns an

public File[] getFiles(Object filter){

if (this.exists()){

FileFilter fileFilter = new FileFilter(filter);

Object[] files = listFiles(fileFilter);

if (files==null){

return new File[0];

}

else{

java.util.ArrayList<javaxt.io.File> list = new java.util.ArrayList<javaxt.io.File>();

for (int i=0; i<files.length; i++){

java.io.File file = null;

if (files[i] instanceof java.io.File){

file = (java.io.File) files[i];

}

else{

file = new java.io.File(files[i].toString());

}

if (file.exists() && file.isFile()){

list.add(new javaxt.io.File(file));

}

}

sort(list, this);

return list.toArray(new javaxt.io.File[list.size()]);

}

}

else{

return new File[0];

}

}

//**************************************************************************

//** getFiles

//**************************************************************************

/** Used to retrieve an array of files found in this directory. Returns an

public File[] getFiles(){

return getFiles(null);

}

//**************************************************************************

//** getFiles

//**************************************************************************

/** Used to retrieve an array of files found in this directory. Returns an

public File[] getFiles(Object filter, boolean RecursiveSearch){

if (this.exists()){

if (RecursiveSearch){

//Get list of all the files and folders in the directory

List items = getChildren(true, filter, false);

ArrayList<File> files = new ArrayList<File>();

try {

Object item;

while (true){

synchronized (items) {

while (items.isEmpty()) {

items.wait();

}

item = items.remove(0);

items.notifyAll();

}

if (item==null){

break;

}

else{

if (item instanceof File){

files.add((File) item);

}

}

}

}

catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

//Sort the list

sort(files, this);

//Convert the list into an array of files

return files.toArray(new File[files.size()]);

}

else{

return getFiles(filter);

}

}

else{

return new File[0];

}

}

//**************************************************************************

//** getFiles

//**************************************************************************

/** Used to retrieve an array of files found in this directory.

public File[] getFiles(boolean RecursiveSearch){

return getFiles(null, RecursiveSearch);

}

//**************************************************************************

//** getSubDirectories

//**************************************************************************

/** Used to retrieve an array of directories found in this directory.

public Directory[] getSubDirectories(){

return getSubDirectories(false);

}

//**************************************************************************