File: EventQueueState.cs

package info (click to toggle)
mono 6.14.1%2Bds2-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 1,282,732 kB
  • sloc: cs: 11,182,461; xml: 2,850,281; ansic: 699,123; cpp: 122,919; perl: 58,604; javascript: 30,841; asm: 21,845; makefile: 19,602; sh: 10,973; python: 4,772; pascal: 925; sql: 859; sed: 16; php: 1
file content (81 lines) | stat: -rw-r--r-- 2,731 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
//------------------------------------------------------------
// 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;
        }
    }

}