/// <summary>
/// Visits the given file, returning the {@code Event} corresponding to that
/// visit.
///
/// The {@code ignoreSecurityException} parameter determines whether
/// any SecurityException should be ignored or not. If a SecurityException
/// is thrown, and is ignored, then this method returns {@code null} to
/// mean that there is no event corresponding to a visit to the file.
///
/// The {@code canUseCached} parameter determines whether cached attributes
/// for the file can be used or not.
/// </summary>
private Event Visit(Path entry, bool ignoreSecurityException, bool canUseCached)
{
// need the file attributes
BasicFileAttributes attrs;
try
{
attrs = GetAttributes(entry, canUseCached);
}
catch (IOException ioe)
{
return(new Event(EventType.ENTRY, entry, ioe));
}
catch (SecurityException se)
{
if (ignoreSecurityException)
{
return(null);
}
throw se;
}
// at maximum depth or file is not a directory
int depth = Stack.Size();
if (depth >= MaxDepth || !attrs.Directory)
{
return(new Event(EventType.ENTRY, entry, attrs));
}
// check for cycles when following links
if (FollowLinks && WouldLoop(entry, attrs.FileKey()))
{
return(new Event(EventType.ENTRY, entry, new FileSystemLoopException(entry.ToString())));
}
// file is a directory, attempt to open it
DirectoryStream <Path> stream = null;
try
{
stream = Files.NewDirectoryStream(entry);
}
catch (IOException ioe)
{
return(new Event(EventType.ENTRY, entry, ioe));
}
catch (SecurityException se)
{
if (ignoreSecurityException)
{
return(null);
}
throw se;
}
// push a directory node to the stack and return an event
Stack.Push(new DirectoryNode(entry, attrs.FileKey(), stream));
return(new Event(EventType.START_DIRECTORY, entry, attrs));
}
internal DirectoryNode(Path dir, Object key, DirectoryStream <Path> stream)
{
this.Dir = dir;
this.Key_Renamed = key;
this.Stream_Renamed = stream;
this.Iterator_Renamed = stream.Iterator();
}
public void LengthTest()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
//act
var length = ds.Length;
//assert
Assert.AreEqual(14L, length);
}
public void ReadByteTestUpdatesPosition()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
//act
ds.ReadByte();
//assert
Assert.AreEqual(1, ds.Position);
}
public void ReadByteTest()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
//act
byte b = (byte)ds.ReadByte();
//assert
Assert.AreEqual((byte)'0', b);
}
public void ReadByteTestAtPosition()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
ds.Position = 5;
byte b = (byte)ds.ReadByte();
//assert
Assert.AreEqual((byte)'A', b);
}
public void ReadTestDoesntGoBeyondFiles()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
byte[] buffer = new byte[32];
//act
int read = ds.Read(buffer, 0, 32);
//assert
Assert.AreEqual(14, read);
}
public void ReadTestUpdatesPosition()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
byte[] buffer = new byte[4];
ds.Position = 4;
//act
ds.Read(buffer, 0, 4);
//assert
Assert.AreEqual(8, ds.Position);
}
public void ReadTest()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
byte[] data = new byte[14];
//act
ds.Read(data, 0, 14);
//assert
byte[] expected = Encoding.ASCII.GetBytes("0000AABBBCCCCE");
CollectionAssert.AreEqual(expected, data);
}
public void SeekTestBegin()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
//act
ds.Seek(7, System.IO.SeekOrigin.Begin);
byte b = (byte)ds.ReadByte();
//assert
Assert.AreEqual((byte)'B', b);
}
public void SeekTestCurrent()
{
//arrange
DirectoryStream ds = new DirectoryStream("TestDirectory");
ds.Position = 4;
//act
ds.Seek(1, System.IO.SeekOrigin.Current);
byte b = (byte)ds.ReadByte();
//assert
Assert.AreEqual((byte)'A', b);
}
public void ReadTestAtFileBoundary()
{
//arrange
var ds = new DirectoryStream("TestDirSameSize");
const int bytesToRead = 10;
byte[] buffer = new byte[bytesToRead];
byte[] expected = Encoding.ASCII.GetBytes("2222222222");
ds.Seek(10, SeekOrigin.Begin);
//act
int read = ds.Read(buffer, 0, bytesToRead);
//assert
Assert.AreEqual(bytesToRead, read);
CollectionAssert.AreEqual(expected, buffer);
}
public void ReadTestWithOffset()
{
//arrange
var ds = new DirectoryStream("TestDirSameSize");
const int bytesToRead = 20;
byte[] buffer = new byte[bytesToRead];
byte[] expected = Encoding.ASCII.GetBytes("11222222222233333333");
ds.Position = 8;
//act
int read = ds.Read(buffer, 0, bytesToRead);
//assert
Assert.AreEqual(bytesToRead, read);
CollectionAssert.AreEqual(expected, buffer);
}
public void ReadTestLargeFileFromStreamHasTheSameContentAsFileOnDisk()
{
//arrange
int size = 1024 * 1024 * 2;
DirectoryStream ds = new DirectoryStream("TestDirLarge");
byte[] buffer = new byte[size];
byte[] expected = new byte[size];
using (var fs = File.Open(@"TestDirLarge\file0.bin", FileMode.Open))
{
fs.Read(expected, 0, size);
}
//act
ds.Read(buffer, 0, size);
//assert
CollectionAssert.AreEqual(expected, buffer);
}
/// <summary>
/// Check if directory is empty.
/// </summary>
/// <param name="directory"> - directory to check </param>
/// <returns> false if directory exists and empty, true otherwise. </returns>
/// <exception cref="IllegalArgumentException"> if specified directory represent a file </exception>
/// <exception cref="IOException"> if some problem encountered during reading directory content </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static boolean isEmptyDirectory(java.io.File directory) throws java.io.IOException
public static bool IsEmptyDirectory(File directory)
{
if (directory.exists())
{
if (!directory.Directory)
{
throw new System.ArgumentException("Expected directory, but was file: " + directory);
}
else
{
using (DirectoryStream <Path> directoryStream = Files.newDirectoryStream(directory.toPath()))
{
return(!directoryStream.GetEnumerator().hasNext());
}
}
}
return(true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void copyRecursively(java.nio.file.Path source, java.nio.file.Path target) throws java.io.IOException
private void CopyRecursively(Path source, Path target)
{
using (DirectoryStream <Path> directoryStream = Files.newDirectoryStream(source))
{
foreach (Path sourcePath in directoryStream)
{
Path targetPath = target.resolve(sourcePath.FileName);
if (Files.isDirectory(sourcePath))
{
Files.createDirectories(targetPath);
CopyRecursively(sourcePath, targetPath);
}
else
{
Files.copy(sourcePath, targetPath, REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);
}
}
}
}
/// <summary>
/// Return the complete list of files in a directory as strings.<p/>
/// This is better than File#listDir because it does not ignore IOExceptions.
/// </summary>
/// <param name="dir">The directory to list.</param>
/// <param name="filter">
/// If non-null, the filter to use when listing
/// this directory.
/// </param>
/// <returns>The list of files in the directory.</returns>
/// <exception cref="System.IO.IOException">On I/O error</exception>
public static IList <string> ListDirectory(FilePath dir, FilenameFilter filter)
{
AList <string> list = new AList <string>();
try
{
using (DirectoryStream <Path> stream = Files.NewDirectoryStream(dir.ToPath()))
{
foreach (Path entry in stream)
{
string fileName = entry.GetFileName().ToString();
if ((filter == null) || filter.Accept(dir, fileName))
{
list.AddItem(fileName);
}
}
}
}
catch (DirectoryIteratorException e)
{
throw ((IOException)e.InnerException);
}
return(list);
}
private EstimationResult EstimateDirectory(DirectoryInfo arg)
{
try
{
logger.Log("Starting: " + arg.Name);
DirectoryStream ds = new DirectoryStream(arg.FullName);
StreamEstimator se = new StreamEstimator();
var packedSize = se.EstimatePackedSize(ds, MAX_READ_SIZE, BLOCK_SIZE);
var result = new EstimationResult()
{
Directory = arg.FullName,
ShortName = arg.Name,
OriginalSize = ds.Length,
EstimatedSize = packedSize,
NtfsCompressed = arg.IsCompressed()
};
logger.Log("Finished: " + arg.Name + " - ratio: " + result.CompressionRatio);
return(result);
}
catch (Exception e)
{
return(new EstimationResult());
}
}
