Exemple #1
0
 /// <summary>Erase the complete database. The database must be closed before this call.</summary>
 public static void drop()
 {
     string[] files = FindFiles.EnumerateAll(databasePath).ToArray();
     foreach (string f in files)
     {
         File.Delete(f);
     }
 }
Exemple #2
0
    public void FindFile(string dirPath)
    {
        List <string> dirs = new List <string>();

        //"UI/HPUI"
        FindFiles.FindObjPath(ref dirs, dirPath);
        foreach (string path in dirs)
        {
            ResMgr.GetInstance().LoadAsync <GameObject>(path, (obj) =>
            {
                //Debug.Log(obj.name);
                obj.transform.parent = transform;
            });
        }
    }
 private void loadPods()
 {
     podPlayList = new List <string>();
     if (Directory.Exists(configWindow.podPathTextBox.Text))
     {
         List <String> pl = new List <string>(FindFiles.FileSystemEnumerator(configWindow.podPathTextBox.Text, "*.mp3", SearchOption.AllDirectories));
         podsFoundCount = pl.Count;
         // suffle the podcasts
         pl = new List <String>(pl.OrderBy(item => rand.Next()));
         for (int ri = 0; ri < MAX_REPEATS; ri++)
         {
             foreach (String pc in pl)
             {
                 int rep = 0;
                 if (podsHeard != null)
                 {
                     foreach (string ph in podsHeard)
                     {
                         String[] tn = ph.Split(podsHeardSeperator);
                         if (tn[0].Equals(pc))
                         {
                             if (tn.Contains("DELETE"))
                             {
                                 rep = -1;  // this one due for deletion
                                 if (ri == 0 && rep == 0)
                                 {
                                     podsFoundCount--;
                                 }
                                 break;
                             }
                             if (ri == 0 && rep == 0 && podPlayList.Contains(ph))
                             {
                                 podsHeardCount++;
                             }
                             rep++;
                         }
                     }
                 }
                 if (rep < 0 || rep != ri)
                 {
                     continue;
                 }
                 podPlayList.Add(pc);
             }
         }
     }
 }
Exemple #4
0
        public static void SortScriptsAsPerFolder()
        {
            scriptsDict = new Dictionary <string, List <string> >();

            files = FindFiles.FindAllFiles("cs");

            for (int i = 0; i < files.Length; i++)
            {
                foldersList = new List <string>();
                string[] folders = files[i].Split('/');
                for (int j = 0; j < folders.Length - 1; j++)
                {
                    foldersList.Add(folders[j]);
                }

                scriptsDict.Add(folders[folders.Length - 1], foldersList);
            }
        }
Exemple #5
0
        private OperationState FindFilesMask(string stPath, string stMask, bool bRecurs) //ищет файлы 1 маски
        {
            string[]     files = null;
            SearchOption so    = SearchOption.AllDirectories;

            if (!bRecurs)
            {
                so = SearchOption.TopDirectoryOnly;
            }

            try
            {
                LogStateAdd("Поиск файлов " + stMask + "...", 0);
                //оказывается родная функция криво ищет файлы
                //принимает *.htm и *.html за одно и то же
                //более прямофикс
                files = FindFiles.Find(stPath, stMask, so);
                FoundFiles.AddRange(files);
            }
            catch (UnauthorizedAccessException UAEx)
            {
                LogStateAdd("Ошибка " + UAEx.Message, OperationState.IOError);
                return(OperationState.IOError);
            }
            catch (PathTooLongException PathEx)
            {
                LogStateAdd("Ошибка " + PathEx.Message, OperationState.IOError);
                return(OperationState.IOError);
            }
            catch (DirectoryNotFoundException DNFEx)
            {
                LogStateAdd("Ошибка " + DNFEx.Message, OperationState.IOError);
                return(OperationState.IOError);
            }
            catch (IOException IOEx)
            {
                LogStateAdd("Ошибка " + IOEx.Message, OperationState.IOError);
                return(OperationState.IOError);
            }

            LogStateAdd("Поиск файлов " + stMask + " завершен. Найдено " + files.Length + " файлов", 0);
            return(OperationState.Success);
        }
        /// <summary>
        /// Fill given list with components collected from assemblies specified by fullpath and pattern.
        /// </summary>
        /// <param name="result">Here are stored found components.</param>
        /// <param name="fullpath">Fullpath of directory where assemblies are searched.</param>
        /// <param name="pattern">Pattern for an assembly.</param>
        /// <returns>Error if any, null otherwise.</returns>
        private string fillWithComponents(List <Instance> result, string fullpath, string pattern)
        {
            var files         = Services.GetFiles(fullpath);
            var filteredFiles = FindFiles.Filter(files, pattern).ToArray();

            if (filteredFiles.Length == 0)
            {
                return("No files has been found");
            }

            foreach (var file in filteredFiles)
            {
                try
                {
                    var assembly = Services.LoadAssembly(file);

                    if (assembly == null)
                    {
                        return("Assembly " + file + " hasn't been loaded");
                    }

                    fillWithComponents(result, assembly);
                }
                catch (Exception)
                {
                    return("Assembly " + file + " loading failed");
                }
            }

            var uniqueIndex = new Dictionary <string, Instance>();

            foreach (var instance in Components.Value)
            {
                uniqueIndex[instance.Info.TypeName] = instance;
            }

            Components.Value.Clear();
            Components.Value.AddRange(uniqueIndex.Values);

            return(null);
        }
        // ----------------------------------------------------------------------

        Folder CreateFolder(
            FileData fd)
        {
            var fileDatas = new List <FileData>();

            using (var files = new FindFiles(
                       fd.FullName))
            {
                long totalSize = 0;
                long count     = 0;
                while (files.MoveNext())
                {
                    var currentFile = files.Current;

                    if (currentFile.Name == "." || currentFile.Name == "..")
                    {
                    }
                    else if (currentFile.IsDictionary)
                    {
                        fileDatas.Add(currentFile);
                    }
                    else
                    {
                        totalSize += currentFile.Length;
                        ++count;
                    }
                }

                var folder = new Folder(
                    fd.FullName,
                    fd.Name,
                    totalSize,
                    count);

                Traverse(folder, fileDatas);

                return(folder);
            }
        }