RTSS_time_reader/PipeReaderStateEnum.cs at master · scumware/RTSS_time_reader · GitHub

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
using System;
using System.CodeDom;
using System.Runtime.CompilerServices;

namespace RTSS_time_reader
{
    [Flags]
    public enum PipeReaderStateEnum
    {
        None = 0
        ,
        Starting            = 1 << 0
        ,
        Started             = 1 << 1
        ,
        FileOpening         = 1 << 2
        ,
        FileOpened          = 1 << 3
        ,
        PipeCreated         = 1 << 4
        ,
        ConnectionAccepted  = 1 << 5
        ,
        Error               = 1 << 6
        ,
        PipeIO              = 1 << 7
        ,
        EnabledWritingFile  = 1 << 8
    }

    public struct PipeReaderState
    {
        private volatile PipeReaderStateEnum m_stateValue;

        public PipeReaderState(PipeReaderStateEnum p_stateValue)
        {
            m_stateValue = p_stateValue;
        }

        public static PipeReaderState None
        {
            get { return new PipeReaderState(PipeReaderStateEnum.None); }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public PipeReaderStateEnum GetDifference(PipeReaderState another)
        {
            return m_stateValue ^ another.m_stateValue;
        }

        public PipeReaderStateEnum GetClearedFlags(PipeReaderState p_oldState)
        {
            return p_oldState.m_stateValue & ~m_stateValue;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool ReadFlag(PipeReaderStateEnum p_flag)
        {
            return (m_stateValue & p_flag) != 0;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetFlag(PipeReaderStateEnum p_flag, bool p_value)
        {
            if (p_value)
                m_stateValue = m_stateValue | p_flag;
            else
                m_stateValue = m_stateValue & ~p_flag;
        }


        public bool IsStarted
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get
            {
                return ReadFlag(PipeReaderStateEnum.Starting) || ReadFlag(PipeReaderStateEnum.Started);
            }
        }

        public bool EnabledWritingFile
        {
            get { return ReadFlag(PipeReaderStateEnum.EnabledWritingFile); }
        }

        public bool IsPipeCreated
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return ReadFlag(PipeReaderStateEnum.PipeCreated); }
        }

        public bool IsFileOpened
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return ReadFlag(PipeReaderStateEnum.FileOpened); }
        }

        public bool IsFileOpening
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return ReadFlag(PipeReaderStateEnum.FileOpening); }
        }

        public bool IsConnectionAccepted
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return ReadFlag(PipeReaderStateEnum.ConnectionAccepted); }
        }

        public bool IsError
        {
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get { return ReadFlag(PipeReaderStateEnum.Error); }
        }

        public static bool operator ==(PipeReaderState p_a, PipeReaderState p_b) => p_a.m_stateValue == p_b.m_stateValue;

        public static bool operator !=(PipeReaderState p_a, PipeReaderState p_b) => !(p_a == p_b);
    }
}