Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Threading;

using Pithos.Interfaces;

namespace Pithos.Core

{

    [ContractClass(typeof(IStatusKeeperContract))]

    public interface IStatusKeeper

    {

        void SetFileOverlayStatus(string path,FileOverlayStatus status);

        void UpdateFileChecksum(string path, string checksum);

        void SetFileStatus(string path, FileStatus status);

        FileStatus GetFileStatus(string path);

        void ClearFileStatus(string path);

        void SetPithosStatus(PithosStatus status);

        FileOverlayStatus GetFileOverlayStatus(string path);

        void ProcessExistingFiles(IEnumerable<FileInfo> paths);

        void Stop();

        void SetFileState(string path, FileStatus fileStatus, FileOverlayStatus overlayStatus);

        void StoreInfo(string path, ObjectInfo objectInfo);

        //T GetStatus<T>(string path,Func<FileState,T> getter,T defaultValue );

        //void SetStatus(string path, Action<FileState> setter);        

        void StartProcessing(CancellationToken token);

        string BlockHash { get; set; }

        int BlockSize { get; set; }

        void ChangeRoots(string oldPath, string newPath);

        FileState GetStateByFilePath(string path);

        void ClearFolderStatus(string path);

        IEnumerable<FileState> GetChildren(FileState fileState);

    }

    [ContractClassFor(typeof(IStatusKeeper))]

    public abstract class IStatusKeeperContract : IStatusKeeper

    {

        public void SetFileOverlayStatus(string path, FileOverlayStatus status)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public void UpdateFileChecksum(string path, string checksum)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(checksum!=null);

            Contract.Requires(Path.IsPathRooted(path));

        }

     /*   public void RemoveFileOverlayStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }*/

        public void RenameFileOverlayStatus(string oldPath, string newPath)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(oldPath));

            Contract.Requires(Path.IsPathRooted(oldPath));

            Contract.Requires(!String.IsNullOrWhiteSpace(newPath));

            Contract.Requires(Path.IsPathRooted(newPath));

        }

        public void SetFileStatus(string path, FileStatus status)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public FileStatus GetFileStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

            return default(FileStatus);

        }

        public FileOverlayStatus GetFileOverlayStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

            return default(FileOverlayStatus);

        }

        public void ProcessExistingFiles(IEnumerable<FileInfo> paths)

        {

            Contract.Requires(paths!=null);

        }

        public void Stop()

        {

        }

        public void SetFileState(string path, FileStatus fileStatus, FileOverlayStatus overlayStatus)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public void StoreInfo(string path, ObjectInfo objectInfo)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(objectInfo!=null);

            Contract.Requires(Path.IsPathRooted(path));

        }

        public T GetStatus<T>(string path, Func<FileState, T> getter, T defaultValue)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(getter!=null);

            Contract.Requires(Path.IsPathRooted(path));

            return default(T);

        }

        public void SetStatus(string path, Action<FileState> setter)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(setter != null);

            Contract.Requires(Path.IsPathRooted(path));

        }

        public void SetNetworkState(string path, NetworkOperation operation)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public NetworkOperation GetNetworkState(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

            return default(NetworkOperation);

        }

        public void ClearFileStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public void SetPithosStatus(PithosStatus status)

        {

        }

        public void StartProcessing(CancellationToken token)

        {

            Contract.Requires(token != null, "token can't be empty");

        }

        public abstract string BlockHash { get; set; }

        public abstract int BlockSize { get; set; }

        public void ChangeRoots(string oldPath, string newPath)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(oldPath));

            Contract.Requires(Path.IsPathRooted(oldPath));

            Contract.Requires(!string.IsNullOrWhiteSpace(newPath));

            Contract.Requires(Path.IsPathRooted(newPath));            

        }

        public FileState GetStateByFilePath(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

            return null;

        }

        public void ClearFolderStatus(string path)

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(path));

            Contract.Requires(Path.IsPathRooted(path));

        }

        public IEnumerable<FileState> GetChildren(FileState fileState)

        {

            Contract.Requires(fileState!=null);

            Contract.Ensures(Contract.Result<IEnumerable<FileState>>()!=null);

            return default(IEnumerable<FileState>);

        }

    }

}