Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Text;

using System.IO;

using System.Text.RegularExpressions;

using System.Threading.Tasks;

using Pithos.Network;

namespace Pithos.Core.Agents

{

    static class FileInfoExtensions

    {

        public static  string AsRelativeTo(this FileInfo fileInfo,string path )

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");            

            Contract.EndContractBlock();

            if (!path.EndsWith("\\"))

                path=path.ToLower() + "\\";

            int pathLength = path.Length;            

            var filePath = fileInfo.FullName;

            if (!filePath.StartsWith(path,StringComparison.InvariantCultureIgnoreCase))

                throw new ArgumentException(String.Format("The path {0} doesn't contain the file {1}",path,filePath));

            var relativePath = filePath.Substring(pathLength, filePath.Length - pathLength);

            return relativePath;

        }

        public static string AsRelativeUrlTo(this FileInfo fileInfo,string path )

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            Contract.EndContractBlock();

            var relativePath = fileInfo.AsRelativeTo(path);

            var replacedSlashes = relativePath.Replace("\\","/");

            var escaped = Uri.EscapeUriString(replacedSlashes);

            return escaped;

        }

        public static string RelativeUriToFilePath(this Uri uri)

        {

            var unescaped = Uri.UnescapeDataString(uri.ToString());

            var path = unescaped.Replace("/", "\\");

            return path;

        }

        public static int Read(this FileInfo fileInfo,byte[] buffer,int offset,int count)

        {            

            //Open the stream only long enough to read a block

            using (var stream = fileInfo.OpenRead())

            {

                stream.Seek(offset, SeekOrigin.Begin);

                return  stream.Read(buffer, 0, count);                

            }

        }

        public static Task<int> ReadAsync(this FileInfo fileInfo, byte[] buffer, int offset, int count)

        {

            //The using statement is not used because we will work asyncronously

            var stream = FileAsync.OpenRead(fileInfo.FullName);

            try

            {

                stream.Seek(offset, SeekOrigin.Begin);

                var read = stream.ReadAsync(buffer, offset, count);

                return read.ContinueWith(t =>

                {

                    //Make sure the stream closes

                    stream.Close();

                    stream = null;

                    t.PropagateExceptions();

                    return t.Result;

                });

            }

            catch (Exception)

            {

                //In case of error make sure we close the stream                

                //The stream may have been 

                if (stream!=null)

                    stream.Close();

                throw;

            }

        }

        public static string CalculateHash(this FileInfo info,int blockSize,string algorithm)

        {

            if (info==null)

                throw new ArgumentNullException("info");

            if (String.IsNullOrWhiteSpace(info.FullName))

                throw new ArgumentException("info");

            if (blockSize<=0)

                throw new ArgumentOutOfRangeException("blockSize",blockSize,"blockSize must be greater than 0");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            if (info.Length <= blockSize)

                return Signature.CalculateMD5(info.FullName);

            else

                return Signature.CalculateTreeHash(info.FullName, blockSize, algorithm).TopHash.ToHashString();

        }

    }

}