aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Framework/Communications/RestClient/GenericAsyncResult.cs
blob: 55456ae195628dfc5e26e9097c80990c5a23c8c3 (plain)
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace OpenSim.Framework.RestClient
{
    internal class SimpleAsyncResult : IAsyncResult
    {

        private readonly AsyncCallback m_callback;

        /// <summary>
        /// Is process completed?
        /// </summary>
        /// <remarks>Should really be boolean, but VolatileRead has no boolean method</remarks>
        private byte m_completed;

        /// <summary>
        /// Did process complete synchroneously?
        /// </summary>
        /// <remarks>I have a hard time imagining a scenario where this is the case, again, same issue about
        /// booleans and VolatileRead as m_completed
        /// </remarks>
        private byte m_completedSynchronously;

        private readonly object m_asyncState;
        private ManualResetEvent m_waitHandle;
        private Exception m_exception;

        internal SimpleAsyncResult(AsyncCallback cb, object state)
        {
            m_callback = cb;
            m_asyncState = state;
            m_completed = 0;
            m_completedSynchronously = 1;
        }


        #region IAsyncResult Members

        public object AsyncState
        {
            get { return m_asyncState; }
        }



        public WaitHandle AsyncWaitHandle
        {
            get
            {
                if (m_waitHandle == null)
                {
                    bool done = IsCompleted;
                    ManualResetEvent mre = new ManualResetEvent(done);
                    if (Interlocked.CompareExchange(ref m_waitHandle, mre, null) != null)
                    {
                        mre.Close();
                    }
                    else
                    {
                        if (!done && IsCompleted)
                        {
                            m_waitHandle.Set();
                        }
                    }
                }
                return m_waitHandle;
            }
        }


        public bool CompletedSynchronously
        {
            get { return Thread.VolatileRead(ref m_completedSynchronously) == 1; }
        }


        public bool IsCompleted
        {
            get { return Thread.VolatileRead(ref m_completed) == 1; }
        }


        #endregion


        #region class Methods
        internal void SetAsCompleted(bool completedSynchronously)
        {
            m_completed = 1;
            if(completedSynchronously)
                m_completedSynchronously = 1;
            else
                m_completedSynchronously = 0;
            
            SignalCompletion();
        }

        internal void HandleException(Exception e, bool completedSynchronously)
        {
            m_completed = 1;
            if (completedSynchronously)
                m_completedSynchronously = 1;
            else
                m_completedSynchronously = 0;
            m_exception = e;

            SignalCompletion();
        }

        private void SignalCompletion()
        {
            if(m_waitHandle != null) m_waitHandle.Set();

            if(m_callback != null) m_callback(this);
        }

        public void EndInvoke()
        {
            // This method assumes that only 1 thread calls EndInvoke 
            if (!IsCompleted)
            {
                // If the operation isn't done, wait for it
                AsyncWaitHandle.WaitOne();
                AsyncWaitHandle.Close();
                m_waitHandle = null;  // Allow early GC
            }

            // Operation is done: if an exception occured, throw it
            if (m_exception != null) throw m_exception;
        }       

        #endregion 
    }

    internal class AsyncResult<T> : SimpleAsyncResult
    {
        private T m_result = default(T);

        public AsyncResult(AsyncCallback asyncCallback, Object state) :
            base(asyncCallback, state) { }


        public void SetAsCompleted(T result,  bool completedSynchronously)
        {
            // Save the asynchronous operation's result
            m_result = result;

            // Tell the base class that the operation completed 
            // sucessfully (no exception)
            base.SetAsCompleted(completedSynchronously);
        }

        new public T EndInvoke()
        {
            base.EndInvoke(); 
            return m_result;  
        }

    }
}