src/foam/db/scalarRange/scalarRange.C

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