src/OpenFOAM/db/dictionary/dictionary.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "dictionary.H"
  28 #include "primitiveEntry.H"
  29 #include "dictionaryEntry.H"
  30
  31 /* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
  32
  33 defineTypeNameAndDebug(Foam::dictionary, 0);
  34
  35 const Foam::dictionary Foam::dictionary::null;
  36
  37 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  38
  39 Foam::dictionary::dictionary()
  40 :
  41     parent_(dictionary::null)
  42 {}
  43
  44
  45 Foam::dictionary::dictionary
  46 (
  47     const dictionary& parentDict,
  48     const dictionary& dict
  49 )
  50 :
  51     IDLList<entry>(dict, *this),
  52     name_(dict.name()),
  53     parent_(parentDict)
  54 {
  55     for
  56     (
  57         IDLList<entry>::iterator iter = begin();
  58         iter != end();
  59         ++iter
  60     )
  61     {
  62         hashedEntries_.insert(iter().keyword(), &iter());
  63     }
  64 }
  65
  66
  67 Foam::dictionary::dictionary
  68 (
  69     const dictionary& dict
  70 )
  71 :
  72     IDLList<entry>(dict, *this),
  73     name_(dict.name()),
  74     parent_(dictionary::null)
  75 {
  76     for
  77     (
  78         IDLList<entry>::iterator iter = begin();
  79         iter != end();
  80         ++iter
  81     )
  82     {
  83         hashedEntries_.insert(iter().keyword(), &iter());
  84     }
  85 }
  86
  87
  88 Foam::autoPtr<Foam::dictionary> Foam::dictionary::clone() const
  89 {
  90     return autoPtr<dictionary>(new dictionary(*this));
  91 }
  92
  93
  94 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  95
  96 Foam::dictionary::~dictionary()
  97 {
  98     // cerr<< "~dictionary() " << name() << " " << long(this) << std::endl;
  99 }
 100
 101
 102 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 103
 104 Foam::label Foam::dictionary::startLineNumber() const
 105 {
 106     if (size())
 107     {
 108         return first()->startLineNumber();
 109     }
 110     else
 111     {
 112         return -1;
 113     }
 114 }
 115
 116
 117 Foam::label Foam::dictionary::endLineNumber() const
 118 {
 119     if (size())
 120     {
 121         return last()->endLineNumber();
 122     }
 123     else
 124     {
 125         return -1;
 126     }
 127 }
 128
 129
 130 bool Foam::dictionary::found(const word& keyword, bool recursive) const
 131 {
 132     if (hashedEntries_.found(keyword))
 133     {
 134         return true;
 135     }
 136     else if (recursive && &parent_ != &dictionary::null)
 137     {
 138         return parent_.found(keyword, recursive);
 139     }
 140     else
 141     {
 142         return false;
 143     }
 144 }
 145
 146
 147 const Foam::entry* Foam::dictionary::lookupEntryPtr
 148 (
 149     const word& keyword,
 150     bool recursive
 151 ) const
 152 {
 153     HashTable<entry*>::const_iterator iter = hashedEntries_.find(keyword);
 154
 155     if (iter == hashedEntries_.end())
 156     {
 157         if (recursive && &parent_ != &dictionary::null)
 158         {
 159             return parent_.lookupEntryPtr(keyword, recursive);
 160         }
 161         else
 162         {
 163             return NULL;
 164         }
 165     }
 166
 167     return iter();
 168 }
 169
 170
 171 Foam::entry* Foam::dictionary::lookupEntryPtr
 172 (
 173     const word& keyword,
 174     bool recursive
 175 )
 176 {
 177     HashTable<entry*>::iterator iter = hashedEntries_.find(keyword);
 178
 179     if (iter == hashedEntries_.end())
 180     {
 181         if (recursive && &parent_ != &dictionary::null)
 182         {
 183             return const_cast<dictionary&>(parent_).lookupEntryPtr
 184             (
 185                 keyword,
 186                 recursive
 187             );
 188         }
 189         else
 190         {
 191             return NULL;
 192         }
 193     }
 194
 195     return iter();
 196 }
 197
 198
 199 const Foam::entry& Foam::dictionary::lookupEntry
 200 (
 201     const word& keyword,
 202     bool recursive
 203 ) const
 204 {
 205     const entry* entryPtr = lookupEntryPtr(keyword, recursive);
 206
 207     if (entryPtr == NULL)
 208     {
 209         FatalIOErrorIn
 210         (
 211             "dictionary::lookupEntry(const word& keyword) const",
 212             *this
 213         )   << "keyword " << keyword << " is undefined in dictionary "
 214             << name()
 215             << exit(FatalIOError);
 216     }
 217
 218     return *entryPtr;
 219 }
 220
 221
 222 Foam::ITstream& Foam::dictionary::lookup
 223 (
 224     const word& keyword,
 225     bool recursive
 226 ) const
 227 {
 228     return lookupEntry(keyword, recursive).stream();
 229 }
 230
 231
 232 bool Foam::dictionary::isDict(const word& keyword) const
 233 {
 234     const entry* entryPtr = lookupEntryPtr(keyword);
 235
 236     if (entryPtr)
 237     {
 238         return entryPtr->isDict();
 239     }
 240     else
 241     {
 242         return false;
 243     }
 244 }
 245
 246
 247 const Foam::dictionary* Foam::dictionary::subDictPtr(const word& keyword) const
 248 {
 249     const entry* entryPtr = lookupEntryPtr(keyword);
 250
 251     if (entryPtr)
 252     {
 253         return &entryPtr->dict();
 254     }
 255     else
 256     {
 257         return NULL;
 258     }
 259 }
 260
 261
 262 const Foam::dictionary& Foam::dictionary::subDict(const word& keyword) const
 263 {
 264     const entry* entryPtr = lookupEntryPtr(keyword);
 265     if (entryPtr == NULL)
 266     {
 267         FatalIOErrorIn
 268         (
 269             "dictionary::subDict(const word& keyword) const",
 270             *this
 271         )   << "keyword " << keyword << " is undefined in dictionary "
 272             << name()
 273             << exit(FatalIOError);
 274     }
 275     return entryPtr->dict();
 276 }
 277
 278
 279 Foam::dictionary& Foam::dictionary::subDict(const word& keyword)
 280 {
 281     entry* entryPtr = lookupEntryPtr(keyword);
 282     if (entryPtr == NULL)
 283     {
 284         FatalIOErrorIn
 285         (
 286             "dictionary::subDict(const word& keyword)",
 287             *this
 288         )   << "keyword " << keyword << " is undefined in dictionary "
 289             << name()
 290             << exit(FatalIOError);
 291     }
 292     return entryPtr->dict();
 293 }
 294
 295
 296 Foam::wordList Foam::dictionary::toc() const
 297 {
 298     wordList keys(size());
 299
 300     label i = 0;
 301     for
 302     (
 303         IDLList<entry>::const_iterator iter = begin();
 304         iter != end();
 305         ++iter
 306     )
 307     {
 308         keys[i++] = iter().keyword();
 309     }
 310
 311     return keys;
 312 }
 313
 314
 315 bool Foam::dictionary::add(entry* entryPtr, bool mergeEntry)
 316 {
 317     HashTable<entry*>::iterator iter = hashedEntries_.find(entryPtr->keyword());
 318
 319     if (mergeEntry && iter != hashedEntries_.end())
 320     {
 321         // merge dictionary with dictionary
 322         if (iter()->isDict() && entryPtr->isDict())
 323         {
 324             iter()->dict().merge(entryPtr->dict());
 325             delete entryPtr;
 326
 327             return true;
 328         }
 329         else
 330         {
 331             // replace existing dictionary with entry or vice versa
 332             IDLList<entry>::replace(iter(), entryPtr);
 333             delete iter();
 334             hashedEntries_.erase(iter);
 335
 336             if (hashedEntries_.insert(entryPtr->keyword(), entryPtr))
 337             {
 338                 entryPtr->name() = name_ + "::" + entryPtr->keyword();
 339                 return true;
 340             }
 341             else
 342             {
 343                 IOWarningIn("dictionary::add(entry*)", (*this))
 344                     << "problem replacing entry "<< entryPtr->keyword()
 345                     << " in dictionary " << name() << endl;
 346
 347                 IDLList<entry>::remove(entryPtr);
 348                 delete entryPtr;
 349                 return false;
 350             }
 351         }
 352     }
 353
 354     if (hashedEntries_.insert(entryPtr->keyword(), entryPtr))
 355     {
 356         entryPtr->name() = name_ + "::" + entryPtr->keyword();
 357         IDLList<entry>::append(entryPtr);
 358
 359         return true;
 360     }
 361     else
 362     {
 363         IOWarningIn("dictionary::add(entry* entryPtr)", (*this))
 364             << "attempt to add entry "<< entryPtr->keyword()
 365             << " which already exists in dictionary " << name()
 366             << endl;
 367
 368         delete entryPtr;
 369         return false;
 370     }
 371 }
 372
 373
 374 void Foam::dictionary::add(const entry& e, bool mergeEntry)
 375 {
 376     add(e.clone(*this).ptr(), mergeEntry);
 377 }
 378
 379 void Foam::dictionary::add(const word& k, const word& w, bool overwrite)
 380 {
 381     add(new primitiveEntry(k, token(w)), overwrite);
 382 }
 383
 384 void Foam::dictionary::add(const word& k, const Foam::string& s, bool overwrite)
 385 {
 386     add(new primitiveEntry(k, token(s)), overwrite);
 387 }
 388
 389 void Foam::dictionary::add(const word& k, const label l, bool overwrite)
 390 {
 391     add(new primitiveEntry(k, token(l)), overwrite);
 392 }
 393
 394 void Foam::dictionary::add(const word& k, const scalar s, bool overwrite)
 395 {
 396     add(new primitiveEntry(k, token(s)), overwrite);
 397 }
 398
 399 void Foam::dictionary::add(const word& k, const dictionary& d, bool mergeEntry)
 400 {
 401     add(new dictionaryEntry(k, *this, d), mergeEntry);
 402 }
 403
 404
 405 void Foam::dictionary::set(entry* entryPtr)
 406 {
 407     entry* existingPtr = lookupEntryPtr(entryPtr->keyword());
 408
 409     // clear dictionary so merge acts like overwrite
 410     if (existingPtr && existingPtr->isDict())
 411     {
 412         existingPtr->dict().clear();
 413     }
 414     add(entryPtr, true);
 415 }
 416
 417
 418 void Foam::dictionary::set(const entry& e)
 419 {
 420     set(e.clone(*this).ptr());
 421 }
 422
 423 void Foam::dictionary::set(const word& k, const dictionary& d)
 424 {
 425     set(new dictionaryEntry(k, *this, d));
 426 }
 427
 428
 429 bool Foam::dictionary::remove(const word& Keyword)
 430 {
 431     HashTable<entry*>::iterator iter = hashedEntries_.find(Keyword);
 432
 433     if (iter != hashedEntries_.end())
 434     {
 435         IDLList<entry>::remove(iter());
 436         delete iter();
 437         hashedEntries_.erase(iter);
 438
 439         return true;
 440     }
 441     else
 442     {
 443         return false;
 444     }
 445 }
 446
 447
 448 bool Foam::dictionary::changeKeyword
 449 (
 450     const word& oldKeyword,
 451     const word& newKeyword,
 452     bool forceOverwrite
 453 )
 454 {
 455     // no change
 456     if (oldKeyword == newKeyword)
 457     {
 458         return false;
 459     }
 460
 461     HashTable<entry*>::iterator iter = hashedEntries_.find(oldKeyword);
 462
 463     // oldKeyword not found - do nothing
 464     if (iter == hashedEntries_.end())
 465     {
 466         return false;
 467     }
 468
 469     HashTable<entry*>::iterator iter2 = hashedEntries_.find(newKeyword);
 470
 471     // newKeyword already exists
 472     if (iter2 != hashedEntries_.end())
 473     {
 474         if (forceOverwrite)
 475         {
 476             IDLList<entry>::replace(iter2(), iter());
 477             delete iter2();
 478             hashedEntries_.erase(iter2);
 479         }
 480         else
 481         {
 482             WarningIn("dictionary::changeKeyword(const word&, const word&)")
 483                 << "cannot rename keyword "<< oldKeyword
 484                 << " to existing keyword " << newKeyword
 485                 << " in dictionary " << name() << endl;
 486             return false;
 487         }
 488     }
 489
 490     // change name and HashTable, but leave DL-List untouched
 491     iter()->keyword() = newKeyword;
 492     iter()->name() = name_ + "::" + newKeyword;
 493     hashedEntries_.erase(oldKeyword);
 494     hashedEntries_.insert(newKeyword, iter());
 495
 496     return true;
 497 }
 498
 499
 500 bool Foam::dictionary::merge(const dictionary& dict)
 501 {
 502     // Check for assignment to self
 503     if (this == &dict)
 504     {
 505         FatalErrorIn("dictionary::merge(const dictionary&)")
 506             << "attempted merge to self for dictionary " << name()
 507             << abort(FatalError);
 508     }
 509
 510     bool changed = false;
 511
 512     for
 513     (
 514         IDLList<entry>::const_iterator iter = dict.begin();
 515         iter != dict.end();
 516         ++iter
 517     )
 518     {
 519         const word& keyword = iter().keyword();
 520
 521         HashTable<entry*>::iterator iter2 = hashedEntries_.find(keyword);
 522
 523         if (iter2 != hashedEntries_.end())
 524         {
 525             // Recursively merge sub-dictionaries
 526             // TODO: merge without copying
 527             if (iter2()->isDict() && iter().isDict())
 528             {
 529                 if (iter2()->dict().merge(iter().dict()))
 530                 {
 531                     changed = true;
 532                 }
 533             }
 534             else
 535             {
 536                 add(iter().clone(*this).ptr(), true);
 537                 changed = true;
 538             }
 539         }
 540         else
 541         {
 542             // not found - just add
 543             add(iter().clone(*this).ptr());
 544             changed = true;
 545         }
 546     }
 547
 548     return changed;
 549 }
 550
 551
 552 void Foam::dictionary::clear()
 553 {
 554     IDLList<entry>::clear();
 555     hashedEntries_.clear();
 556 }
 557
 558
 559 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 560
 561 Foam::ITstream& Foam::dictionary::operator[](const word& keyword) const
 562 {
 563     return lookup(keyword);
 564 }
 565
 566
 567 void Foam::dictionary::operator=(const dictionary& dict)
 568 {
 569     // Check for assignment to self
 570     if (this == &dict)
 571     {
 572         FatalErrorIn("dictionary::operator=(const dictionary&)")
 573             << "attempted assignment to self for dictionary " << name()
 574             << abort(FatalError);
 575     }
 576
 577     name_ = dict.name();
 578     clear();
 579
 580     // Create clones of the entries in the given dictionary
 581     // resetting the parentDict to this dictionary
 582     for
 583     (
 584         IDLList<entry>::const_iterator iter = dict.begin();
 585         iter != dict.end();
 586         ++iter
 587     )
 588     {
 589         IDLList<entry>::append(iter().clone(*this).ptr());
 590     }
 591
 592     for
 593     (
 594         IDLList<entry>::iterator iter = begin();
 595         iter != end();
 596         ++iter
 597     )
 598     {
 599         hashedEntries_.insert(iter().keyword(), &iter());
 600     }
 601 }
 602
 603
 604 void Foam::dictionary::operator+=(const dictionary& dict)
 605 {
 606     // Check for assignment to self
 607     if (this == &dict)
 608     {
 609         FatalErrorIn("dictionary::operator+=(const dictionary&)")
 610             << "attempted addition assignment to self for dictionary " << name()
 611             << abort(FatalError);
 612     }
 613
 614     for
 615     (
 616         IDLList<entry>::const_iterator iter = dict.begin();
 617         iter != dict.end();
 618         ++iter
 619     )
 620     {
 621         add(iter().clone(*this).ptr());
 622     }
 623 }
 624
 625
 626 void Foam::dictionary::operator|=(const dictionary& dict)
 627 {
 628     // Check for assignment to self
 629     if (this == &dict)
 630     {
 631         FatalErrorIn("dictionary::operator|=(const dictionary&)")
 632             << "attempted assignment to self for dictionary " << name()
 633             << abort(FatalError);
 634     }
 635
 636     for
 637     (
 638         IDLList<entry>::const_iterator iter = dict.begin();
 639         iter != dict.end();
 640         ++iter
 641     )
 642     {
 643         if (!found(iter().keyword()))
 644         {
 645             add(iter().clone(*this).ptr());
 646         }
 647     }
 648 }
 649
 650
 651 void Foam::dictionary::operator<<=(const dictionary& dict)
 652 {
 653     // Check for assignment to self
 654     if (this == &dict)
 655     {
 656         FatalErrorIn("dictionary::operator<<=(const dictionary&)")
 657             << "attempted assignment to self for dictionary " << name()
 658             << abort(FatalError);
 659     }
 660
 661     for
 662     (
 663         IDLList<entry>::const_iterator iter = dict.begin();
 664         iter != dict.end();
 665         ++iter
 666     )
 667     {
 668         set(iter().clone(*this).ptr());
 669     }
 670 }
 671
 672
 673 /* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
 674
 675 Foam::dictionary Foam::operator+
 676 (
 677     const dictionary& dict1,
 678     const dictionary& dict2
 679 )
 680 {
 681     dictionary sum(dict1);
 682     sum += dict2;
 683     return sum;
 684 }
 685
 686
 687 Foam::dictionary Foam::operator|
 688 (
 689     const dictionary& dict1,
 690     const dictionary& dict2
 691 )
 692 {
 693     dictionary sum(dict1);
 694     sum |= dict2;
 695     return sum;
 696 }
 697
 698
 699 // ************************************************************************* //