Switch.H 6.06 KB
Newer Older
1
2
3
4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
5
    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
6
     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
7
8
9
10
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

11
12
13
14
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
15
16
17
18
19
20
21

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
22
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
23
24
25
26
27

Class
    Foam::Switch

Description
28
    A simple wrapper around bool so that it can be read as a word:
29
    true/false, on/off, yes/no, y/n, t/f, or none.
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

SourceFiles
    Switch.C
    SwitchIO.C

\*---------------------------------------------------------------------------*/

#ifndef Switch_H
#define Switch_H

#include "bool.H"
#include "word.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward declaration of friend functions and operators

class Switch;
51
class dictionary;
52

Mark Olesen's avatar
Mark Olesen committed
53
54
Istream& operator>>(Istream& is, Switch& s);
Ostream& operator<<(Ostream& is, const Switch& s);
55
56
57
58
59
60
61
62


/*---------------------------------------------------------------------------*\
                           Class Switch Declaration
\*---------------------------------------------------------------------------*/

class Switch
{
Mark Olesen's avatar
Mark Olesen committed
63
64
65
66
67
    // Private data

        //- The logic and enumerated text representation stored as a single byte
        unsigned char switch_;

68
69
public:

Mark Olesen's avatar
Mark Olesen committed
70
71
    // Public data types

72
        // Avoid issues with possible pre-processor defines
73
74
75
76
        #undef FALSE
        #undef TRUE
        #undef NO
        #undef YES
77
78
        #undef OFF
        #undef ON
79
80
81
82
        #undef NONE
        #undef PLACEHOLDER
        #undef INVALID

Mark Olesen's avatar
Mark Olesen committed
83
84
85
86
        //- The various text representations for a switch value.
        //  These also correspond to the entries in names.
        enum switchType
        {
87
            FALSE   = 0,  TRUE   = 1,
88
89
90
            NO      = 2,  YES    = 3,
            OFF     = 4,  ON     = 5,
            NONE    = 6,  PLACEHOLDER = 7,
Mark Olesen's avatar
Mark Olesen committed
91
92
            INVALID
        };
93
94
95
96
97
98
99

    // Static data members

        //- The set of names corresponding to the switchType enumeration
        //  Includes an extra entry for "invalid".
        static const char* names[INVALID+1];

100

101
private:
102

103
    // Static Member Functions
104

Mark Olesen's avatar
Mark Olesen committed
105
106
107
108
109
110
        //- Return a switchType representation of an input string
        static switchType asEnum
        (
            const std::string& str,
            const bool allowInvalid
        );
111

112

113
public:
114

115
116
    // Constructors

Mark Olesen's avatar
Mark Olesen committed
117
118
119
        //- Construct null as false
        Switch()
        :
120
            switch_(switchType::FALSE)
Mark Olesen's avatar
Mark Olesen committed
121
122
        {}

123
        //- Construct from enumerated value
124
        Switch(const switchType sw)
125
        :
126
            switch_(sw)
127
128
        {}

129
        //- Construct from bool
130
        Switch(const bool b)
131
        :
132
            switch_(b ? switchType::TRUE : switchType::FALSE)
Mark Olesen's avatar
Mark Olesen committed
133
134
135
        {}

        //- Construct from integer values (treats integer as bool value)
136
        Switch(const int i)
Mark Olesen's avatar
Mark Olesen committed
137
        :
138
139
140
141
142
143
144
145
146
147
148
149
150
            switch_(i ? switchType::TRUE : switchType::FALSE)
        {}

        //- Construct from string - catches bad input.
        explicit Switch(const std::string& str)
        :
            switch_(asEnum(str, false))
        {}

        //- Construct from character array - catches bad input.
        explicit Switch(const char* str)
        :
            switch_(asEnum(std::string(str), false))
Mark Olesen's avatar
Mark Olesen committed
151
152
        {}

153
        //- Construct from string.
154
        //  Optionally allow bad words, and catch the error elsewhere
155
        Switch(const std::string& str, const bool allowInvalid)
Mark Olesen's avatar
Mark Olesen committed
156
        :
157
            switch_(asEnum(str, allowInvalid))
158
159
        {}

160
        //- Construct from character array.
161
        //  Optionally allow bad words, and catch the error elsewhere
162
        Switch(const char* str, const bool allowInvalid)
163
        :
164
            switch_(asEnum(std::string(str), allowInvalid))
165
166
167
168
169
        {}

        //- Construct from Istream
        Switch(Istream& is);

170
171
172
173
        //- Construct from dictionary, supplying default value so that if the
        //  value is not found, it is added into the dictionary.
        static Switch lookupOrAddToDict
        (
Mark Olesen's avatar
Mark Olesen committed
174
175
            const word& name,
            dictionary& dict,
176
            const Switch& defaultValue = switchType::FALSE
177
178
        );

179

180
181
182
    // Member Functions

        //- Return true if the Switch has a valid value
183
184
185
186
187
188
        bool valid() const;

        //- Return a text representation of the Switch
        const char* asText() const;

        //- Update the value of the Switch if it is found in the dictionary
Mark Olesen's avatar
Mark Olesen committed
189
        bool readIfPresent(const word& name, const dictionary& dict);
190
191


192
193
    // Member Operators

Mark Olesen's avatar
Mark Olesen committed
194
195
        //- Conversion to bool
        operator bool() const
196
        {
Mark Olesen's avatar
Mark Olesen committed
197
            return (switch_ & 0x1);
198
199
        }

200
        //- Assignment to enumerated value
201
        void operator=(const switchType sw)
202
203
204
205
        {
            switch_ = sw;
        }

206
        //- Assignment to bool
207
        void operator=(const bool b)
208
        {
Mark Olesen's avatar
Mark Olesen committed
209
            switch_ = (b ? Switch::TRUE : Switch::FALSE);
210
211
212
213
214
        }


    // IOstream Operators

Mark Olesen's avatar
Mark Olesen committed
215
216
        friend Istream& operator>>(Istream& is, Switch& s);
        friend Ostream& operator<<(Ostream& os, const Switch& s);
217
218
219
220
221
222
223
224
225
226
227
228
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //