Synnefo » Pithos MS Client

                new ObjectInfo { Account = "acc1", Container = "Cont1", Name = "Name4", Bytes = 1234, Hash = "aa45", PreviousHash="aa4", Version = 1 },

                new ObjectInfo { Account = "acc1", Container = "Cont2", Name = "Name4", Bytes = 1234, Hash = "aa45", PreviousHash="aa4", Version = 1 },

            Comparison<ObjectInfo> comparer = (x, y) =>

                                                  {

                                                      if (x.Account == y.Account

                                                          && x.Container == y.Container

                                                          && x.Name == y.Name

                                                          && x.Hash == y.Hash

                                                          && x.PreviousHash == y.PreviousHash)

                                                          return 0;

                                                      return 1;

                                                  };

            Assert.That(differencer.Changed.ToList(), Is.EquivalentTo(changed).Using(comparer));

using System;

using System.Collections.Generic;

using System.Linq;

    /// Calculates the differences between two ObjectInfo snapshots.

        /// <summary>

        /// Contains the previous and current listings.

        /// Using a separate class for the state simplifies the Post method

        /// which has to modify the listings

        /// </summary>

        private class State

        {

            /// <summary>

            /// The previous snapshot listing

            /// </summary>

            public readonly IEnumerable<ObjectInfo> Previous;

            /// <summary>

            /// The current snapshot listing

            /// </summary>

            public readonly IEnumerable<ObjectInfo> Current;

            /// <summary>

            /// Common objects, lazily evalueated. 

            /// The common objects are used to calculate both the Changed and Unchanged objects

            /// </summary>

            public readonly Lazy<IEnumerable<ObjectInfo>> Common;

            public State(IEnumerable<ObjectInfo> previous, IEnumerable<ObjectInfo> current)

            {

                Previous = previous ?? new List<ObjectInfo>();

                Current = current ?? new List<ObjectInfo>();

                Common=new Lazy<IEnumerable<ObjectInfo>>(() =>

                    Current.Join(Previous,

                                outKey => new { outKey.Account, outKey.Container, outKey.Name },

                                inKey => new { inKey.Account, inKey.Container, inKey.Name },

                                (outer, inner) =>

                                {

                                    outer.PreviousHash = inner.Hash;

                                    return outer;

                                }));            

            }

        }

        private State _state;

        /// <summary>

        /// The comparer used to identify common objects.

        /// Objects are considered common when they have the same Account, Container and Name

        /// </summary>

        private readonly ObjectInfoComparer _comparer = new ObjectInfoComparer();

        /// <summary>

        /// Default constructor. Initializes the Current and Previous listings to empty lists

        /// </summary>

            :this(new List<ObjectInfo>(),new List<ObjectInfo>())

        /// <summary>

        /// Creates a new differencer using the specified previous and current list. Null lists

        /// are replaced with empty lists

        /// </summary>

        /// <param name="previous"></param>

        /// <param name="current"></param>

            _state=new State(previous,current);

        /// <summary>

        /// Posts a new listing

        /// </summary>

        /// <param name="list"></param>

        /// <returns></returns>

            List<ObjectInfo> newCurrent=null;

            if (list != null)

                //The state field holds the old state

                var oldState = _state;

                //Replace any NoModification entries with previous values that have

                //the same account, container and possibly, folder

                newCurrent = list.Replace(

                    info => info is NoModificationInfo,

                    noMod => oldState.Current.Where(noMod.CorrespondsTo))

                    .ToList();

            //Set the new state

            _state = new State(_state.Current, newCurrent);

            get { return _state.Previous.Except(_state.Current,_comparer); }

            get { return _state.Current.Except(_state.Previous,_comparer); }

        }

        public IEnumerable<ObjectInfo> Common

        {

            get { return _state.Common.Value; }

            get{return Common.Where(i=>i.PreviousHash!=i.Hash);}

            get{ return Common.Where(i => i.PreviousHash == i.Hash);}

        readonly ConcurrentDictionary<string, SnapshotDifferencer> _differencers = new ConcurrentDictionary<string, SnapshotDifferencer>();

        public string PreviousHash { get; set; }

        //The previous values that correspond to a NoModification object

        //have the same account, container and possibly the same folder

        public bool CorrespondsTo(ObjectInfo other)

        {

            return other.Account == this.Account

                   && other.Container == this.Container

                   && (this.Name == null || other.Name.StartsWith(this.Name));

        }