Exemple #1
0
        public async Task <Diff> GetDiffAsync(DiffOptions options, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
        {
            Verify.Argument.IsNotNull(options, nameof(options));
            Verify.State.IsFalse(IsDisposed, "Object is disposed.");

            if (progress != null)
            {
                progress.Report(new OperationProgress(Resources.StrLoadingDiff.AddEllipsis()));
                var result = await GetDiffCoreAsync(options, progress, cancellationToken);

                progress.Report(OperationProgress.Completed);
                return(result);
                //return GetDiffCoreAsync(options, progress, cancellationToken)
                //	.ContinueWith(t =>
                //		{
                //			progress.Report(OperationProgress.Completed);
                //			return TaskUtility.UnwrapResult(t);
                //		},
                //		cancellationToken, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
            }
            else
            {
                return(await GetDiffCoreAsync(options, progress, cancellationToken));
            }
        }
Exemple #2
0
        public Diff GetDiff(DiffOptions options)
        {
            Verify.Argument.IsNotNull(options, nameof(options));
            Verify.State.IsFalse(IsDisposed, "Object is disposed.");

            return(GetDiffCore(options));
        }
Exemple #3
0
        protected override Diff GetDiffCore(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = GetParameters(options);

            return(Repository.Accessor.QueryRevisionDiff.Invoke(parameters));
        }
Exemple #4
0
        protected override Task <Diff> GetDiffCoreAsync(DiffOptions options, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
        {
            Assert.IsNotNull(options);

            var parameters = GetParameters(options);

            return(Repository.Accessor.QueryRevisionDiff.InvokeAsync(parameters, progress, cancellationToken));
        }
Exemple #5
0
        private QueryRevisionDiffParameters GetParameters(DiffOptions options)
        {
            var parameters = new QueryRevisionDiffParameters(_revision.Pointer)
            {
                Paths = _paths,
            };

            ApplyCommonDiffOptions(parameters, options);
            return(parameters);
        }
        private QueryRevisionDiffParameters GetParameters(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = new QueryRevisionDiffParameters(_stashedState.Name)
            {
                Paths = _paths,
            };

            ApplyCommonDiffOptions(parameters, options);
            return(parameters);
        }
        private QueryDiffParameters GetParameters(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = new QueryDiffParameters()
            {
                Cached = _cached,
                Paths  = _paths,
            };

            ApplyCommonDiffOptions(parameters, options);
            return(parameters);
        }
        private QueryDiffParameters GetParameters(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = new QueryDiffParameters()
            {
                Revision1 = _revision1.Pointer,
                Revision2 = _revision2.Pointer,
                Paths     = _paths,
            };

            ApplyCommonDiffOptions(parameters, options);
            return(parameters);
        }
Exemple #9
0
        protected static void ApplyCommonDiffOptions(BaseQueryDiffParameters queryParameters, DiffOptions options)
        {
            Assert.IsNotNull(queryParameters);
            Assert.IsNotNull(options);

            queryParameters.Context           = options.Context;
            queryParameters.Patience          = options.UsePatienceAlgorithm;
            queryParameters.IgnoreSpaceChange = options.IgnoreWhitespace;
            queryParameters.Binary            = options.Binary;
        }
Exemple #10
0
        private QueryDiffParameters GetParameters(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = new QueryDiffParameters()
            {
                Cached = _cached,
                Paths = _paths,
            };
            ApplyCommonDiffOptions(parameters, options);
            return parameters;
        }
        protected override Task<Diff> GetDiffCoreAsync(DiffOptions options, IProgress<OperationProgress> progress, CancellationToken cancellationToken)
        {
            Assert.IsNotNull(options);

            var parameters = GetParameters(options);
            return Repository.Accessor.QueryRevisionDiff.InvokeAsync(parameters, progress, cancellationToken);
        }
 private QueryRevisionDiffParameters GetParameters(DiffOptions options)
 {
     var parameters = new QueryRevisionDiffParameters(_revision.Pointer)
     {
         Paths = _paths,
     };
     ApplyCommonDiffOptions(parameters, options);
     return parameters;
 }
Exemple #13
0
        public Diff GetDiff(DiffOptions options)
        {
            Verify.Argument.IsNotNull(options, "options");
            Verify.State.IsFalse(IsDisposed, "Object is disposed.");

            return GetDiffCore(options);
        }
        protected override Diff GetDiffCore(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = GetParameters(options);
            return Repository.Accessor.QueryRevisionDiff.Invoke(parameters);
        }
Exemple #15
0
 protected abstract Diff GetDiffCore(DiffOptions options);
Exemple #16
0
 protected abstract Task<Diff> GetDiffCoreAsync(DiffOptions options, IProgress<OperationProgress> progress, CancellationToken cancellationToken);
        private QueryDiffParameters GetParameters(DiffOptions options)
        {
            Assert.IsNotNull(options);

            var parameters = new QueryDiffParameters()
            {
                Revision1 = _revision1.Pointer,
                Revision2 = _revision2.Pointer,
                Paths = _paths,
            };
            ApplyCommonDiffOptions(parameters, options);
            return parameters;
        }
Exemple #18
0
        public Task<Diff> GetDiffAsync(DiffOptions options, IProgress<OperationProgress> progress, CancellationToken cancellationToken)
        {
            Verify.Argument.IsNotNull(options, "options");
            Verify.State.IsFalse(IsDisposed, "Object is disposed.");

            if(progress != null)
            {
                progress.Report(new OperationProgress(Resources.StrLoadingDiff.AddEllipsis()));
                return GetDiffCoreAsync(options, progress, cancellationToken)
                    .ContinueWith(t =>
                        {
                            progress.Report(OperationProgress.Completed);
                            return TaskUtility.UnwrapResult(t);
                        },
                        cancellationToken, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
            }
            else
            {
                return GetDiffCoreAsync(options, progress, cancellationToken);
            }
        }
Exemple #19
0
        protected static void ApplyCommonDiffOptions(BaseQueryDiffParameters queryParameters, DiffOptions options)
        {
            Assert.IsNotNull(queryParameters);
            Assert.IsNotNull(options);

            queryParameters.Context           = options.Context;
            queryParameters.Patience          = options.UsePatienceAlgorithm;
            queryParameters.IgnoreSpaceChange = options.IgnoreWhitespace;
            queryParameters.Binary            = options.Binary;
        }
Exemple #20
0
 protected abstract Diff GetDiffCore(DiffOptions options);
Exemple #21
0
 protected abstract Task <Diff> GetDiffCoreAsync(DiffOptions options, IProgress <OperationProgress> progress, CancellationToken cancellationToken);