//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.     All rights    reserved.
//------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Globalization;
using System.Workflow.ComponentModel;
using System.Runtime.Serialization;
 
namespace System.Workflow.Runtime
{
    [Serializable]
    internal sealed class EventQueueState
    {
        Queue deliveredMessages;
        List<ActivityExecutorDelegateInfo<QueueEventArgs>> synchronousListeners;
        List<ActivityExecutorDelegateInfo<QueueEventArgs>> asynchronousListeners;
        bool enabled = true;
        bool transactional = true;
 
        [NonSerialized]
        internal IComparable queueName;
 
        [NonSerialized]
        bool dirty = false; // dirty flag set to true until a transaction completes
 
        internal EventQueueState()
        {
            this.deliveredMessages = new Queue();
            this.synchronousListeners = new List<ActivityExecutorDelegateInfo<QueueEventArgs>>();
            this.asynchronousListeners = new List<ActivityExecutorDelegateInfo<QueueEventArgs>>();
        }
 
        internal Queue Messages
        {
            get { return this.deliveredMessages; }
        }
        internal List<ActivityExecutorDelegateInfo<QueueEventArgs>> AsynchronousListeners
        {
            get { return this.asynchronousListeners; }
        }
        internal List<ActivityExecutorDelegateInfo<QueueEventArgs>> SynchronousListeners
        {
            get { return this.synchronousListeners; }
        }
        internal bool Enabled
        {
            get { return this.enabled; }
            set { this.enabled = value; }
        }
        internal bool Transactional
        {
            get { return this.transactional; }
            set { this.transactional = value; }
        }
 
        internal bool Dirty
        {
            get { return this.dirty; }
            set { this.dirty = value; }
        }
 
        internal void CopyFrom(EventQueueState copyFromState)
        {
            this.deliveredMessages = new Queue(copyFromState.Messages);
 
            // don't copy Subscribers since this gets fixed 
            // up at access time based on these tracking context ints
            this.asynchronousListeners.AddRange(copyFromState.AsynchronousListeners.ToArray());
            this.synchronousListeners.AddRange(copyFromState.SynchronousListeners.ToArray());
 
            this.enabled = copyFromState.Enabled;
            this.transactional = copyFromState.Transactional;
            this.dirty = false;
        }
    }
 
}