예제 #1
0
        public IPath InitPath(string rootPath, IPath path)
        {
            //Computes absolute path
            path = ComputeAbsolute(rootPath, path);

            // If path does not exist a new file or directory will be created
            if (path.IsDirectory)
            {
                if (!_fs.Directory.Exists(path.AbsolutePath))
                {
                    _fs.Directory.CreateDirectory(path.AbsolutePath);
                    _log.Verbose("Created directory at {absolutePath}", path.AbsolutePath);
                }
            }
            else
            {
                if (!_fs.File.Exists(path.AbsolutePath))
                {
                    _fs.File.Create(path.AbsolutePath).Close();
                    _log.Verbose("Created file at {absolutePath}", path.AbsolutePath);
                }
            }

            // Every path where RecursiveInit is true will be initialized
            foreach (var child in path.Children.Where(child => child.RecursiveInit))
            {
                InitPath(path.AbsolutePath, child);
            }

            return(path);
        }
예제 #2
0
        /// <summary>
        ///     Creates a new path. It will not be initialized
        /// </summary>
        /// <param name="relativePath">relative path of path. This will be used with a root path to compute an absolute path</param>
        /// <param name="parent">the parent path that will be added to the front</param>
        /// <param name="isDirectory">
        ///     if true the path will be a directory and create one. Otherwise it would be a file and create
        ///     one
        /// </param>
        /// <param name="recursiveInit">if true the path will be initialized by its parent</param>
        public Path(string relativePath = "", IPath parent = null, bool isDirectory = true, bool recursiveInit = true)
        {
            RelativePath  = relativePath;
            Parent        = parent;
            IsDirectory   = isDirectory;
            RecursiveInit = recursiveInit;

            //Add to parent
            Children = new List <IPath>();
            parent?.Children.Add(this);
        }
예제 #3
0
        public StreamReader FileReader(IPath path)
        {
            // Validate file
            if (!Validate(path))
            {
                return(null);
            }

            // If path is file then return stream reader
            if (!path.IsDirectory)
            {
                return(new StreamReader(_fs.File.OpenRead(path.AbsolutePath)));
            }

            //Else path is a directory = return null
            _log.Warning("Path {absolutePath} is not a file. It can not be read", path.AbsolutePath);
            return(null);
        }
예제 #4
0
        public bool Validate(IPath path)
        {
            // Test if absolute path is null then path is not valid
            if (path.AbsolutePath == null)
            {
                _log.Warning("Path {relativePath} is not valid: No absolute path was initialized", path.RelativePath);
                return(false);
            }

            //Test if path exists if not path is not valid
            if (!Exists(path))
            {
                return(false);
            }

            _log.Verbose("Path {absolutePath} is valid", path.AbsolutePath);
            return(true);
        }
예제 #5
0
        public IEnumerable <string> GetFiles(IPath path, string searchPattern = "*")
        {
            //Validate path
            if (!Validate(path))
            {
                return(null);
            }

            //If path is a directory get the children paths
            if (path.IsDirectory)
            {
                return(_fs.Directory.GetFileSystemEntries(path.AbsolutePath, searchPattern));
            }

            //If it's an file return null
            _log.Warning("Path {absolutePath} is not a directory. Can not get files", path.AbsolutePath);
            return(null);
        }
예제 #6
0
        /*public IPath Path(string relativePath = "", IPath parent = null, bool isDirectory = true,
         *  bool recursiveInit = true)
         * {
         *  //Creates new path
         *  var path = new Path(relativePath, parent, isDirectory, recursiveInit);
         *
         *  //Add children to parent
         *  parent?.Children.Add(path);
         *
         *  return path;
         * }*/

        public IPath ComputeAbsolute(string rootPath, IPath path)
        {
            // Check if absolute path is already computed and return it
            if (path.AbsolutePath != null)
            {
                _log.Warning("Path {absolutePath} is already computed", path.AbsolutePath);
                return(path);
            }

            // Combines root path with relative path and gets the full path (absolute)
            var absolutePath = _fs.Path.GetFullPath(
                _fs.Path.Combine(rootPath, path.RelativePath));

            _log.Debug("Resolve path {relativePath} to {absolutePath}", path.RelativePath, absolutePath);

            path.AbsolutePath = absolutePath;

            return(path);
        }
예제 #7
0
        public void Delete(IPath path)
        {
            // Validate path
            if (!Validate(path))
            {
                return;
            }

            //Delete file or directory
            if (path.IsDirectory)
            {
                _log.Verbose("Deleting directory {absolutePath}", path.AbsolutePath);
                _fs.Directory.Delete(path.AbsolutePath);
            }
            else
            {
                _log.Verbose("Deleting file {absolutePath}", path.AbsolutePath);
                _fs.File.Delete(path.AbsolutePath);
            }
        }
예제 #8
0
 public bool Exists(IPath path)
 {
     // True if directory of file exists
     return(path.IsDirectory ? _fs.Directory.Exists(path.AbsolutePath) : _fs.File.Exists(path.AbsolutePath));
 }