[Serializable]
    public abstract class LoaderStateBase<TState, T>
        where T : IEquatable<T>
        where TState : LoaderStateBase<TState, T>
    {
        HashSet<T> _failure;
        HashSet<T> _noResults;
        HashSet<T> _partial;
        HashSet<T> _queue;
        HashSet<T> _success;

        protected LoaderStateBase()
        {
        }

        protected LoaderStateBase(HashSet<T> queue, HashSet<T> success, HashSet<T> failure, HashSet<T> noResults,
            HashSet<T> partial)
        {
            _queue = queue;
            _success = success;
            _failure = failure;
            _noResults = noResults;
            _partial = partial;
        }


        protected abstract TState Create(HashSet<T> queue,
                                         HashSet<T> success,
                                         HashSet<T> failure,
                                         HashSet<T> noResults,
                                         HashSet<T> @partial);

        protected abstract T[] ToSortedArray(HashSet<T> items);

        public LoaderInfo LastLoaderInfo { get; set; }

        public T[] Queue
        {
            get { return ToSortedArray(_queue); }
            set { _queue = new HashSet<T>(value ?? new T[0]); }
        }

        public T[] Success
        {
            get { return ToSortedArray(_success); }
            set { _success = new HashSet<T>(value ?? new T[0]); }
        }

        public T[] Failure
        {
            get { return ToSortedArray(_failure); }
            set { _failure = new HashSet<T>(value ?? new T[0]); }
        }

        public T[] NoResults
        {
            get { return ToSortedArray(_noResults); }
            set { _noResults = new HashSet<T>(value ?? new T[0]); }
        }

        public T[] Partial
        {
            get { return ToSortedArray(_partial); }
            set { _partial = new HashSet<T>(value ?? new T[0]); }
        }

        public TState Enqueue(IEnumerable<T> items)
        {
            var queue = new HashSet<T>(Queue);
            foreach (var item in items)
                queue.Add(item);
            foreach (var item in Success)
                queue.Remove(item);
            foreach (var item in Failure)
                queue.Remove(item);
            foreach (var item in Partial)
                queue.Remove(item);
            foreach (var item in NoResults)
                queue.Remove(item);
            return Create(queue, _success, _failure, _noResults, _partial);
        }

        public int GetQueueCount()
        {
            return _queue.Count;
        }

        public TState Merge(IEnumerable<ExternalLoaderResult<T>> loaderResult)
        {
            var queue = new HashSet<T>(Queue);
            var success = new HashSet<T>(Success);
            var failure = new HashSet<T>(Failure);
            var partial = new HashSet<T>(Partial);
            var noResults = new HashSet<T>(NoResults);
            foreach (var resultItem in loaderResult)
            {
                queue.Remove(resultItem.ExternalItem);
                switch (resultItem.State)
                {
                    case TransformerResultState.Completed:
                        success.Add(resultItem.ExternalItem);
                        break;
                    case TransformerResultState.Failed:
                        failure.Add(resultItem.ExternalItem);
                        break;
                    case TransformerResultState.FailedEmpty:
                        noResults.Add(resultItem.ExternalItem);
                        break;
                    case TransformerResultState.FailedPartial:
                        partial.Add(resultItem.ExternalItem);
                        break;
                }
            }
            return Create(queue, success, failure, noResults, partial);
        }
    }