public virtual VectorClockSyncResult <T> Acknowledge(VectorClockNode <T> vectorClock)
        {
            vectorClock = NormalizeVectors(vectorClock);

            VectorClockNode <T> winner =
                this.IsDescendantOf(vectorClock) ? this :
                vectorClock.IsDescendantOf(this) ? vectorClock :
                null;

            if (winner != null)
            {
                Payload = winner.Payload;

                foreach (var version in Revision)
                {
                    while (version.Version < winner.VersionOf(version.NodeID))
                    {
                        version.Increment();
                    }
                }

                latestSyncResult = VectorClockSyncResult <T> .Successfull(this, winner);

                return(latestSyncResult);
            }

            latestSyncResult = VectorClockSyncResult <T> .Conflictual(this, new VectorClockConflict <T>(this, vectorClock));

            return(latestSyncResult);
        }
        private void ChewRequestQueue()
        {
            VectorClockNode <T> queueHead;

            if (!syncRequestQueue.TryDequeue(out queueHead))
            {
                return;
            }
            Head = Head ?? queueHead;

            VectorClockSyncResult <T> syncResult = Head.Acknowledge(queueHead);

            if (syncResult.IsSuccessfull)
            {
                Head = syncResult.Solution;
                TryToAknowledgeOthers(Head);
                return;
            }

            syncResult = conflictResolver.ResolveConflict(syncResult);

            if (syncResult.IsSuccessfull)
            {
                Head = syncResult.Solution;
                TryToAknowledgeOthers(Head);
                return;
            }

            //Delegate conflict to node
            nodeMesh[queueHead.NodeID].Acknowledge(Head);
            //TryToAknowledgeOthers(Head);
        }