FreeFOAM The Cross-Platform CFD Toolkit
scalarRange.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  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 #include "scalarRange.H"
27 #include <OpenFOAM/token.H>
28 
29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
30 
31 int Foam::scalarRange::debug(::Foam::debug::debugSwitch("scalarRange", 0));
32 
33 
34 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
35 
37 :
38  type_(EMPTY),
39  value_(0),
40  value2_(0)
41 {}
42 
43 
44 Foam::scalarRange::scalarRange(const scalar& lower, const scalar& upper)
45 :
46  type_(RANGE),
47  value_(lower),
48  value2_(upper)
49 {
50  // mark invalid range as empty
51  if (lower > upper)
52  {
53  type_ = EMPTY;
54  value_ = value2_ = 0;
55  }
56 }
57 
58 
60 :
61  type_(EXACT),
62  value_(0),
63  value2_(0)
64 {
65  is >> *this;
66 
68  {
69  Info<<"constructed scalarRange: " << *this << endl;
70  }
71 }
72 
73 
74 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
75 
77 {
78  return type_ != EMPTY;
79 }
80 
81 
83 {
84  return type_ == EXACT;
85 }
86 
87 
88 Foam::scalar Foam::scalarRange::value() const
89 {
90  return value_;
91 }
92 
93 
94 Foam::scalar Foam::scalarRange::lower() const
95 {
96  if (type_ == UPPER)
97  {
98  return -Foam::GREAT;
99  }
100  else
101  {
102  return value_;
103  }
104 }
105 
106 Foam::scalar Foam::scalarRange::upper() const
107 {
108  switch (type_)
109  {
110  case LOWER:
111  return Foam::GREAT;
112  break;
113 
114  case RANGE:
115  return value2_;
116  break;
117 
118  default:
119  return value_;
120  break;
121  }
122 }
123 
124 
125 bool Foam::scalarRange::selected(const scalar& value) const
126 {
127  switch (type_)
128  {
129  case LOWER:
130  return value >= value_;
131 
132  case UPPER:
133  return value <= value_;
134 
135  case RANGE:
136  return value >= value_ && value <= value2_;
137 
138  case EXACT:
139  return value == value_;
140 
141  default:
142  return false;
143  }
144 }
145 
146 
147 
148 // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
149 
151 {
152  if
153  (
154  type_ == range.type_
155  && value_ == range.value_
156  && value2_ == range.value2_
157  )
158  {
159  return true;
160  }
161 
162  return false;
163 }
164 
165 
167 {
168  return operator==(range) ? false : true;
169 }
170 
171 
172 // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
173 
175 {
176  range.type_ = scalarRange::EXACT;
177  range.value_ = 0;
178  range.value2_ = 0;
179 
180  List<token> toks(4);
181  label nTok = 0;
182 
183  // skip leading ','
184  do
185  {
186  is.read(toks[nTok]);
187  is.check("scalarRange token read");
188  }
189  while
190  (
191  toks[nTok].isPunctuation()
192  && toks[nTok].pToken() == token::COMMA
193  );
194 
195  ++nTok;
196 
197  // looks like ':VALUE'
198  if
199  (
200  toks[nTok-1].isPunctuation()
201  && toks[nTok-1].pToken() == token::COLON
202  )
203  {
204  range.type_ = scalarRange::UPPER;
205  is.read(toks[nTok++]);
206  is.check("scalarRange token read");
207  }
208 
209  // a number is now required
210  if (!toks[nTok-1].isNumber())
211  {
212  is.setBad();
213  range.type_ = scalarRange::EMPTY;
214  range.value_ = range.value2_ = 0;
215  Info<< "rejected ill-formed or empty range:";
216  for (label i=0; i<nTok; ++i)
217  {
218  Info<< " " << toks[i];
219  }
220  Info<< endl;
221  return is;
222  }
223 
224  range.value_ = toks[nTok-1].number();
225  is.read(toks[nTok++]);
226  is.check("scalarRange token read");
227 
228  if (scalarRange::debug)
229  {
230  Info<<"tokens:";
231  for (label i=0; i<nTok; ++i)
232  {
233  Info<< " " << toks[i];
234  }
235  Info<< endl;
236  }
237 
238  // could be 'VALUE:' or 'VALUE:VALUE'
239  if
240  (
241  toks[nTok-1].isPunctuation()
242  && toks[nTok-1].pToken() == token::COLON
243  )
244  {
245  if (range.type_ == scalarRange::UPPER)
246  {
247  is.setBad();
248  range.type_ = scalarRange::EMPTY;
249  range.value_ = range.value2_ = 0;
250  Info<< "rejected ill-formed range:";
251  for (label i=0; i<nTok; ++i)
252  {
253  Info<< " " << toks[i];
254  }
255  Info<< endl;
256  return is;
257  }
258 
259  is.read(toks[nTok++]);
260  is.check("scalarRange token read");
261 
262  if (scalarRange::debug)
263  {
264  Info<<"tokens:";
265  for (label i=0; i<nTok; ++i)
266  {
267  Info<< " " << toks[i];
268  }
269  Info<< endl;
270  }
271 
272 
273  // if there is a number, we have 'VALUE:VALUE' and not simply 'VALUE:'
274  if (toks[nTok-1].isNumber())
275  {
276  range.type_ = scalarRange::RANGE;
277  range.value2_ = toks[nTok-1].number();
278  is.read(toks[nTok++]);
279  is.check("scalarRange token read");
280  }
281  else
282  {
283  range.type_ = scalarRange::LOWER;
284  }
285  }
286 
287  if (scalarRange::debug)
288  {
289  Info<<"tokens:";
290  for (label i=0; i<nTok; ++i)
291  {
292  Info<< " " << toks[i];
293  }
294  Info<< endl;
295  }
296 
297 
298  // some remaining tokens, but they are not the next comma
299  // - this is a problem!
300  if
301  (
302  toks[nTok-1].good()
303  &&
304  (
305  !toks[nTok-1].isPunctuation()
306  || toks[nTok-1].pToken() != token::COMMA
307  )
308  )
309  {
310  is.setBad();
311  range.type_ = scalarRange::EMPTY;
312  range.value_ = range.value2_ = 0;
313 
314  Info<< "rejected ill-formed range:";
315  for (label i=0; i<nTok; ++i)
316  {
317  Info << " " << toks[i];
318  }
319  Info<< endl;
320  }
321 
322  return is;
323 }
324 
325 
327 {
328  switch (range.type_)
329  {
330  case scalarRange::LOWER:
331  os << range.value_ << " <=> Inf";
332  break;
333 
334  case scalarRange::UPPER:
335  os << "-Inf <=> " << range.value_;
336  break;
337 
338  case scalarRange::RANGE:
339  os << range.value_ << " <=> " << range.value2_;
340  break;
341 
342  case scalarRange::EXACT:
343  os << range.value_;
344  break;
345 
346  default:
347  os << "empty";
348  break;
349  }
350 
351  return os;
352 }
353 
354 
355 // ************************ vim: set sw=4 sts=4 et: ************************ //