public LibraryFileInfo(ISDataClient client, bool formMode, IDirectoryInfo directory, LibraryDocument document)
     : base(directory)
 {
     _client = client;
     _formMode = formMode;
     _document = document;
 }

        private static IDirectoryInfo CopyDirectory(IDirectoryInfo source, IDirectoryInfo destination)
        {
            var targetDir = destination.GetDirectories().FirstOrDefault(dir => string.Equals(dir.Name, source.Name, StringComparison.OrdinalIgnoreCase))
                            ?? destination.CreateSubdirectory(source.Name);

            foreach (var sourceFile in source.GetFiles())
            {
                var name = sourceFile.Name;
                var targetFile = targetDir.GetFiles().FirstOrDefault(item => string.Equals(item.Name, name, StringComparison.OrdinalIgnoreCase))
                                 ?? destination.DriveInfo.GetFileInfo(Path.Combine(targetDir.FullName, name));

                using (var input = sourceFile.Open(FileMode.Open, FileAccess.Read))
                using (var output = targetFile.Open(FileMode.OpenOrCreate, FileAccess.Write))
                {
                    input.CopyTo(output);
                }
            }

            foreach (var subSource in source.GetDirectories())
            {
                CopyDirectory(subSource, targetDir);
            }

            return targetDir;
        }

 public AttachmentFileInfo(ISDataClient client, bool formMode, IDirectoryInfo directory, Attachment attachment)
     : base(directory)
 {
     _client = client;
     _formMode = formMode;
     _attachment = attachment;
 }

        /// <summary>
        /// Creates the specified directory in the target directory.
        /// </summary>
        /// <param name="sourceDirectory">The source directory.</param>
        /// <param name="targetDirectory">The target directory.</param>
        /// <exception cref="AccessException">The directory could not be accessed.</exception>
        public void CreateDirectory(IDirectoryInfo sourceDirectory, IDirectoryInfo targetDirectory)
        {
            sourceDirectory.ThrowIfNull(() => sourceDirectory);
            targetDirectory.ThrowIfNull(() => targetDirectory);

            try
            {
                Directory.CreateDirectory(this.CombinePath(targetDirectory.FullName, sourceDirectory.Name));
            }

            catch (DirectoryNotFoundException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }

            catch (PathTooLongException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }

            catch (IOException ex)
            {
                throw new AccessException("The file could not be accessed.", ex);
            }

            catch (UnauthorizedAccessException ex)
            {
                throw new AccessException(ex.Message, ex);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CmisSync.Lib.Producer.Crawler.DescendantsTreeBuilder"/> class.
        /// </summary>
        /// <param name='storage'>
        /// The MetadataStorage.
        /// </param>
        /// <param name='remoteFolder'>
        /// Remote folder.
        /// </param>
        /// <param name='localFolder'>
        /// Local folder.
        /// </param>
        /// <param name='filter'>
        /// Aggregated Filters.
        /// </param>
        /// <exception cref='ArgumentNullException'>
        /// <attribution license="cc4" from="Microsoft" modified="false" /><para>The exception that is thrown when a
        /// null reference (Nothing in Visual Basic) is passed to a method that does not accept it as a valid argument. </para>
        /// </exception>
        public DescendantsTreeBuilder(
            IMetaDataStorage storage,
            IFolder remoteFolder,
            IDirectoryInfo localFolder,
            IFilterAggregator filter,
            IIgnoredEntitiesStorage ignoredStorage)
        {
            if (remoteFolder == null) {
                throw new ArgumentNullException("remoteFolder");
            }

            if (localFolder == null) {
                throw new ArgumentNullException("localFolder");
            }

            if (storage == null) {
                throw new ArgumentNullException("storage");
            }

            if (filter == null) {
                throw new ArgumentNullException("filter");
            }

            if (ignoredStorage == null) {
                throw new ArgumentNullException("ignoredStorage");
            }

            this.storage = storage;
            this.remoteFolder = remoteFolder;
            this.localFolder = localFolder;
            this.filter = filter;
            this.matcher = new PathMatcher(localFolder.FullName, remoteFolder.Path);
            this.ignoredStorage = ignoredStorage;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DescendantsCrawler"/> class.
        /// </summary>
        /// <param name="queue">Sync Event Queue.</param>
        /// <param name="remoteFolder">Remote folder.</param>
        /// <param name="localFolder">Local folder.</param>
        /// <param name="storage">Meta data storage.</param>
        /// <param name="filter">Aggregated filter.</param>
        /// <param name="activityListener">Activity listner.</param>
        public DescendantsCrawler(
            ISyncEventQueue queue,
            IFolder remoteFolder,
            IDirectoryInfo localFolder,
            IMetaDataStorage storage,
            IFilterAggregator filter,
            IActivityListener activityListener,
            IIgnoredEntitiesStorage ignoredStorage)
            : base(queue)
        {
            if (remoteFolder == null) {
                throw new ArgumentNullException("remoteFolder");
            }

            if (localFolder == null) {
                throw new ArgumentNullException("localFolder");
            }

            if (storage == null) {
                throw new ArgumentNullException("storage");
            }

            if (filter == null) {
                throw new ArgumentNullException("filter");
            }

            if (activityListener == null) {
                throw new ArgumentNullException("activityListener");
            }

            this.activityListener = activityListener;
            this.treebuilder = new DescendantsTreeBuilder(storage, remoteFolder, localFolder, filter, ignoredStorage);
            this.eventGenerator = new CrawlEventGenerator(storage);
            this.notifier = new CrawlEventNotifier(queue);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DirectoryCreationEventArgs"/> class.
        /// </summary>
        /// <param name="directory">The directory.</param>
        /// <param name="targetDirectory">The target directory.</param>
        public DirectoryCreationEventArgs(IDirectoryInfo directory, IDirectoryInfo targetDirectory)
        {
            directory.ThrowIfNull(() => directory);
            targetDirectory.ThrowIfNull(() => targetDirectory);

            this.Directory = directory;
            this.TargetDirectory = targetDirectory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CmisSync.Lib.Events.CrawlRequestEvent"/> class.
        /// </summary>
        /// <param name='localFolder'>
        /// Local folder.
        /// </param>
        /// <param name='remoteFolder'>
        /// Remote folder.
        /// </param>
        public CrawlRequestEvent(IDirectoryInfo localFolder, IFolder remoteFolder) {
            if (localFolder == null) {
                throw new ArgumentNullException("localFolder");
            }

            this.RemoteFolder = remoteFolder;
            this.LocalFolder = localFolder;
        }

        public bool TryToCreateDirectory(IDirectoryInfo directory)
        {
            if (directory.Exists)
                return false;

            directory.Create();
            return true;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileCopyErrorEventArgs"/> class.
        /// </summary>
        /// <param name="file">The file.</param>
        /// <param name="targetDirectory">The target directory.</param>
        public FileCopyErrorEventArgs(IFileInfo file, IDirectoryInfo targetDirectory)
        {
            file.ThrowIfNull(() => file);
            targetDirectory.ThrowIfNull(() => targetDirectory);

            this.File = file;
            this.TargetDirectory = targetDirectory;
        }

 public ZipFileInfo(IDirectoryInfo parentDir, string zipPath, ZipEntry entry)
 {
     _parentDir = parentDir;
     _zipPath = zipPath;
     _fullPath = entry.Name;
     _lastModifiedTime = entry.DateTime;
     _size = entry.Size;
 }

 public RarFileInfo(IDirectoryInfo parentDir, string rarPath, Schematrix.RARFileInfo rarFileInfo)
 {
     _parentDir = parentDir;
     _rarPath = rarPath; //The rar archive file path
     _lastModifiedTime = rarFileInfo.FileTime;
     _size = rarFileInfo.UnpackedSize;
     _filePath = rarFileInfo.FileName; //Path of the file within the rar archive
 }

        /// <summary>
        /// Gets the directories of the original instance wrapped by new DirectoryInfoWrapper instances.
        /// </summary>
        /// <returns>The directories.</returns>
        public IDirectoryInfo[] GetDirectories() {
            DirectoryInfo[] originalDirs = this.original.GetDirectories();
            IDirectoryInfo[] wrappedDirs = new IDirectoryInfo[originalDirs.Length];
            for (int i = 0; i < originalDirs.Length; i++) {
                wrappedDirs[i] = new DirectoryInfoWrapper(originalDirs[i]);
            }

            return wrappedDirs;
        }

    public ExtractedZipEntryAsFileInfo (ZipFile zipFile, ZipEntry zipEntry, IDirectoryInfo directory)
    {
      ArgumentUtility.CheckNotNull ("zipFile", zipFile);
      ArgumentUtility.CheckNotNull ("zipEntry", zipEntry);

      _zipFile = zipFile;
      _zipEntry = zipEntry;
      _directory = directory;
    }

        public RepositoryRootDeletedDetection(IDirectoryInfo localRootPath) {
            if (localRootPath == null) {
                throw new ArgumentNullException();
            }

            this.path = localRootPath;
            this.absolutePath = this.path.FullName;
            this.isRootFolderAvailable = this.IsRootFolderAvailable();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="CmisSync.Lib.Events.FolderMovedEvent"/> class.
 /// </summary>
 /// <param name="oldLocalFolder">Old local folder.</param>
 /// <param name="newLocalFolder">New local folder.</param>
 /// <param name="oldRemoteFolderPath">Old remote folder path.</param>
 /// <param name="newRemoteFolder">New remote folder.</param>
 /// <param name="src">Creator of the event.</param>
 public FolderMovedEvent(
     IDirectoryInfo oldLocalFolder,
     IDirectoryInfo newLocalFolder,
     string oldRemoteFolderPath,
     IFolder newRemoteFolder,
     object src = null) : base(newLocalFolder, newRemoteFolder, src) {
     this.OldLocalFolder = oldLocalFolder;
     this.OldRemoteFolderPath = oldRemoteFolderPath;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileSystemScanner"/> class.
        /// </summary>
        /// <param name="rootDirectory">The root directory.</param>
        /// <exception cref="System.ArgumentException">
        /// The exception that is thrown, if the root directory doesn't exists
        /// </exception>
        public FileSystemScanner(IDirectoryInfo rootDirectory)
        {
            rootDirectory.ThrowIfNull(() => rootDirectory);

            if (!rootDirectory.Exists)
                throw new ArgumentException("The root directory must exist!");

            this.rootDirectory = rootDirectory;
        }

 public void SetUp ()
 {
   _directoryName = "Parent\\Directory";
   _parentDirectory = MockRepository.GenerateStub<IDirectoryInfo>();
   _creationTime = new DateTime (2009, 10, 1);
   _lastAccessTime = new DateTime (2009, 10, 2);
   _lastWriteTime = new DateTime (2009, 10, 3);
   _inMemoryDirectoryInfo = new InMemoryDirectoryInfo (_directoryName, _parentDirectory, _creationTime, _lastAccessTime, _lastWriteTime);
 }

 public SevenZipFileInfo(IDirectoryInfo parentDir, string sevenZipPath, uint fileIndex, FileItem fileItem)
 {
     _parentDir = parentDir;
     _sevenZipPath = sevenZipPath;
     _fileIndex = fileIndex;
     _fileItem = fileItem;
     _fullPath = fileItem.Name.Replace("\0", "");
     _size = (long)fileItem.Size;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CmisSync.Lib.Events.FolderEvent"/> class.
        /// </summary>
        /// <param name="localFolder">Local folder.</param>
        /// <param name="remoteFolder">Remote folder.</param>
        /// <param name="src">Event creator.</param>
        public FolderEvent(IDirectoryInfo localFolder = null, IFolder remoteFolder = null, object src = null) {
            if (localFolder == null && remoteFolder == null) {
                throw new ArgumentNullException("One of the given folders must not be null");
            }

            this.LocalFolder = localFolder;
            this.RemoteFolder = remoteFolder;
            this.Source = src;
        }