/// <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);
        }

        public NodeTreeParserConfig With(IFolder folder)
        {
            this.folders.Add(folder);
            this.locators.Add(new LinkedTextLocator(folder));

            return this;
        }

 private  static async Task<IFolder> _EnsureFolderExistsAsync(string name, IFolder parent)
 {
     if (parent == null) throw new ArgumentNullException("parent");
     return
         await
             parent.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
 }

        /// <summary>
        /// Create a new MessageListCommand for the specified folder
        /// </summary>
        /// <param name="folder"></param>
        /// <param name="callback"></param>
        public MessageListCommand(IFolder folder, CommandDataReceivedCallback callback)
            : base(callback)
        {
            _parameterObjs.Add(folder);

            CommandString = String.Format("UID SEARCH all");
        }

 /// <summary>
 /// Search for messages within the specified folders. The NewMessageRequestCompleted event will be fired once for each folder.
 /// </summary>
 /// <param name="folders"></param>
 public void Start(IFolder[] folders)
 {
     foreach (IFolder folder in folders)
     {
         Start(folder);
     }
 }

        private static void UploadRandomDocumentTo(IFolder folder)
        {
            string filename = "file_" + Guid.NewGuid() + ".bin";

            //byte[] content = UTF8Encoding.UTF8.GetBytes("Hello World!");
            int sizeInMb = 40;
            byte[] data = new byte[sizeInMb * 1024 * 1024];
            Random rng = new Random();
            rng.NextBytes(data);

            IDictionary<string, object> properties = new Dictionary<string, object>();
            properties[PropertyIds.Name] = filename;
            properties[PropertyIds.ObjectTypeId] = "cmis:document";

            ContentStream contentStream = new ContentStream();
            contentStream.FileName = filename;
            contentStream.MimeType = "application/octet-stream";
            contentStream.Length = data.Length;
            contentStream.Stream = new MemoryStream(data);

            Console.Write("Uploading " + filename + " ... ");
            folder.CreateDocument(properties, contentStream, null);
            Console.WriteLine(" Done.");

            contentStream.Stream.Close();
            contentStream.Stream.Dispose();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MoveMessageRequest"/> class.
 /// </summary>
 /// <param name="message">The messagy to copy.</param>
 /// <param name="destFolder">The destination folder.</param>
 /// <param name="callback">The callback to call when copy operation is completed.</param>
 public CopyMessageRequest(IMessage message, IFolder destFolder, RequestCompletedCallback callback)
     : base(callback)
 {
     PreCommand = new SelectFolderCommand(message.Folder, null);
     Command = new CopyMessageCommand(message, destFolder, null);
     ProcessorType = typeof(CopyMessageProcessor);
 }

            /// <summary>
            /// Synchronize by checking all folders/files one-by-one.
            /// This strategy is used if the CMIS server does not support the ChangeLog feature.
            /// 
            /// for all remote folders:
            ///     if exists locally:
            ///       recurse
            ///     else
            ///       if in database:
            ///         delete recursively from server // if BIDIRECTIONAL
            ///       else
            ///         download recursively
            /// for all remote files:
            ///     if exists locally:
            ///       if remote is more recent than local:
            ///         download
            ///       else
            ///         upload                         // if BIDIRECTIONAL
            ///     else:
            ///       if in database:
            ///         delete from server             // if BIDIRECTIONAL
            ///       else
            ///         download
            /// for all local files:
            ///   if not present remotely:
            ///     if in database:
            ///       delete
            ///     else:
            ///       upload                           // if BIDIRECTIONAL
            ///   else:
            ///     if has changed locally:
            ///       upload                           // if BIDIRECTIONAL
            /// for all local folders:
            ///   if not present remotely:
            ///     if in database:
            ///       delete recursively from local
            ///     else:
            ///       upload recursively               // if BIDIRECTIONAL
            /// </summary>
            private void CrawlSync(IFolder remoteFolder, string localFolder)
            {
                sleepWhileSuspended();

                // Lists of files/folders, to delete those that have been removed on the server.
                IList remoteFiles = new ArrayList();
                IList remoteSubfolders = new ArrayList();

                try
                {
                    // Crawl remote children.
                    // Logger.LogInfo("Sync", String.Format("Crawl remote folder {0}", this.remoteFolderPath));
                    CrawlRemote(remoteFolder, localFolder, remoteFiles, remoteSubfolders);

                    // Crawl local files.
                    // Logger.LogInfo("Sync", String.Format("Crawl local files in the local folder {0}", localFolder));
                    CrawlLocalFiles(localFolder, remoteFolder, remoteFiles);

                    // Crawl local folders.
                    // Logger.LogInfo("Sync", String.Format("Crawl local folder {0}", localFolder));
                    CrawlLocalFolders(localFolder, remoteFolder, remoteSubfolders);
                }
                catch (CmisBaseException e)
                {
                    ProcessRecoverableException("Could not crawl folder: " + remoteFolder.Path, e);
                }
            }

 public DeleteFolderRequest(IFolder folder, RequestCompletedCallback callback)
     : base(callback)
 {
     /*
      * Process for deleting a folder:
      * the IMAP spec states that deleting a folder should NOT delete any sub folders.
      * So in that case we must rename any and all sub folders to include the name of the 
      * parent folder that is being deleted. for example:
      * 
      * INBOX/Sub1/SubSub1
      *           /SubSub2
      *           /SubSub3
      *           
      * if we delete Sub1, Sub1's sub folders become:
      * 
      * INBOX/Sub1_SubSub1
      * INBOX/Sub1_SubSub2
      * INBOX/Sub1_SubSub3
      * 
      * This request is ONLY for deleting the folder on the server. A higher level construct
      * is needed to facilitate the renaming of sub folders.
      * 
      * */
     Command = new DeleteFolderCommand(folder, null);
     ProcessorType = typeof (DeleteFolderProcessor);
 }

 public static Task MoveAsync( this IFile file, IFolder destinationFolder )
 {
     Arg.NotNull( file, nameof( file ) );
     Arg.NotNull( destinationFolder, nameof( destinationFolder ) );
     Contract.Ensures( Contract.Result<Task>() != null );
     return file.MoveAsync( destinationFolder, file.Name );
 }

 /// <summary>
 /// Retreives the list of message UIDs for the specified folder from the server.
 /// </summary>
 /// <param name="folder"></param>
 /// <param name="callback"></param>
 public MessageListRequest(IFolder folder, RequestCompletedCallback callback)
     : base(callback)
 {
     PreCommand = new ExamineFolderCommand(folder, null);
     Command = new MessageListCommand(folder, null);
     ProcessorType = typeof (MessageListProcessor);
 }

 public SearchRequest(IFolder folder, SearchCriteria criteria, RequestCompletedCallback callback)
     : base(callback)
 {
     PreCommand = new SelectFolderCommand(folder, null);
     Command = new SearchCommand(criteria, null);
     ProcessorType = typeof (SearchProcessor);
 }

        public CreateFolderCommand(string folderName, IFolder parentFolder, CommandDataReceivedCallback callback)
            : base(callback)
        {
            System.Text.StringBuilder b = new System.Text.StringBuilder(folderName);
            for (int i = 0; i < b.Length; ++i)
            {
                if (b[i] == '+')
                    b[i] = '&';
                else if (b[i] == '&')
                    b[i] = '+';
            }
            folderName = b.ToString();
            byte[] utf7String = System.Text.Encoding.UTF7.GetBytes(folderName);
            folderName = System.Text.Encoding.ASCII.GetString(utf7String);
            folderName = folderName.Replace('/', ',').Replace('+', '&');

            string fullFolder = parentFolder != null
                                    ? String.Format("{0}/{1}", parentFolder.FullEncodedPath, folderName)
                                    : folderName;

            fullFolder = fullFolder.Replace("\"", "");

            _parameters.Add(fullFolder);
            CommandString = String.Format("CREATE \"{0}\"", fullFolder);
        }

        public bool ValidateFileNames(string folderName, IFolder folder, IScriptBaseObject thisLevelRootObject, out IEnumerable<FilenameInfo> duplicates)
        {
            log.Info("Validating generated files.");

            List<FilenameInfo> generatedPaths = new List<FilenameInfo>();

            ValidateFileNames(generatedPaths, folder, thisLevelRootObject, folderName);

            Dictionary<string, FilenameInfo> generatedPathSet = new Dictionary<string, FilenameInfo>();
            HashSet<FilenameInfo> tempduplicates = new HashSet<FilenameInfo>();

            foreach (var path in generatedPaths)
            {
                if (generatedPathSet.ContainsKey(path.ProcessedFilename) == false)
                {
                    generatedPathSet.Add(path.ProcessedFilename, path);
                }
                else
                {
                    tempduplicates.Add(generatedPathSet[path.ProcessedFilename]);
                    tempduplicates.Add(path);
                }
            }

            if (tempduplicates.Count > 0)
            {
                duplicates = tempduplicates;
                return false;
            }
            duplicates = new List<FilenameInfo>();
            return true;
        }

 /// <summary>
 /// Create a new SelectFolderCommand for the specified folder
 /// </summary>
 /// <param name="folder"></param>
 /// <param name="callback"></param>
 public SelectFolderCommand(IFolder folder, CommandDataReceivedCallback callback)
     : base(callback)
 {
     _parameters.Add(folder.FullPath);
     _parameterObjs.Add(folder);
     CommandString = String.Format("SELECT \"{0}\"", Parameters);
 }

        /// <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>
 /// Create a new ExamineFolderCommand for the specified folder
 /// </summary>
 /// <param name="folder"></param>
 /// <param name="callback"></param>
 public ExamineFolderCommand(IFolder folder, CommandDataReceivedCallback callback)
     : base(callback)
 {
     _parameters.Add(folder.FullPath);
     _parameterObjs.Add(folder);
     CommandString = String.Format("EXAMINE \"{0}\"", Parameters);
 }

        public static File CreateByBinary(IFolder parent, BinaryData binaryData)
        {
            if (parent == null)
                throw new ArgumentNullException("parent");

            if (binaryData == null)
                return new File(parent as Node);

            File file;
            // Resolve filetype by binary-config matching
            BinaryTypeResolver resolver = new BinaryTypeResolver();
            if (!resolver.ParseBinary(binaryData))
            {
                // Unknown file type
                file = new File(parent as Node);
            }
            else
            {
                // Specific File subtype has been found
                file = TypeHandler.CreateInstance<File>(resolver.NodeType.ClassName, parent);

                var fname = binaryData.FileName.FileNameWithoutExtension;
                if (string.IsNullOrEmpty(fname))
                    fname = file.Name;
                else if (fname.Contains("\\"))
                    fname = System.IO.Path.GetFileNameWithoutExtension(fname);

                binaryData.FileName = new BinaryFileName(fname, resolver.FileNameExtension);
                binaryData.ContentType = resolver.ContentType;
            }

            file.Binary = binaryData;
            return file;
        }

	public WixScriptBuilder(XmlWriter writer, IFolder basePath, WixBuilderParameters parameters)
	{
		parameters.Validate();
		_writer = writer;
		_basePath = basePath;
		_parameters = parameters;
		InitializeFileIdMappings(parameters);
	}

        /// <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;
        }