src/OpenFOAM/db/dictionary/dictionary.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 #include "regExp.H"
  31 #include "OSHA1stream.H"
  32
  33 /* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
  34
  35 defineTypeNameAndDebug(Foam::dictionary, 0);
  36
  37 const Foam::dictionary Foam::dictionary::null;
  38
  39
  40 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  41
  42 bool Foam::dictionary::findInPatterns
  43 (
  44     const bool patternMatch,
  45     const word& Keyword,
  46     DLList<entry*>::const_iterator& wcLink,
  47     DLList<autoPtr<regExp> >::const_iterator& reLink
  48 ) const
  49 {
  50     if (patternEntries_.size())
  51     {
  52         while (wcLink != patternEntries_.end())
  53         {
  54             if
  55             (
  56                 patternMatch
  57               ? reLink()->match(Keyword)
  58               : wcLink()->keyword() == Keyword
  59             )
  60             {
  61                 return true;
  62             }
  63
  64             ++reLink;
  65             ++wcLink;
  66         }
  67     }
  68
  69     return false;
  70 }
  71
  72
  73 bool Foam::dictionary::findInPatterns
  74 (
  75     const bool patternMatch,
  76     const word& Keyword,
  77     DLList<entry*>::iterator& wcLink,
  78     DLList<autoPtr<regExp> >::iterator& reLink
  79 )
  80 {
  81     if (patternEntries_.size())
  82     {
  83         while (wcLink != patternEntries_.end())
  84         {
  85             if
  86             (
  87                 patternMatch
  88               ? reLink()->match(Keyword)
  89               : wcLink()->keyword() == Keyword
  90             )
  91             {
  92                 return true;
  93             }
  94
  95             ++reLink;
  96             ++wcLink;
  97         }
  98     }
  99
 100     return false;
 101 }
 102
 103
 104 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 105
 106 Foam::dictionary::dictionary()
 107 :
 108     parent_(dictionary::null)
 109 {}
 110
 111
 112 Foam::dictionary::dictionary(const fileName& name)
 113 :
 114     dictionaryName(name),
 115     parent_(dictionary::null)
 116 {}
 117
 118
 119 Foam::dictionary::dictionary
 120 (
 121     const dictionary& parentDict,
 122     const dictionary& dict
 123 )
 124 :
 125     dictionaryName(dict.name()),
 126     IDLList<entry>(dict, *this),
 127     parent_(parentDict)
 128 {
 129     forAllIter(IDLList<entry>, *this, iter)
 130     {
 131         hashedEntries_.insert(iter().keyword(), &iter());
 132
 133         if (iter().keyword().isPattern())
 134         {
 135             patternEntries_.insert(&iter());
 136             patternRegexps_.insert
 137             (
 138                 autoPtr<regExp>(new regExp(iter().keyword()))
 139             );
 140         }
 141     }
 142 }
 143
 144
 145 Foam::dictionary::dictionary
 146 (
 147     const dictionary& dict
 148 )
 149 :
 150     dictionaryName(dict.name()),
 151     IDLList<entry>(dict, *this),
 152     parent_(dictionary::null)
 153 {
 154     forAllIter(IDLList<entry>, *this, iter)
 155     {
 156         hashedEntries_.insert(iter().keyword(), &iter());
 157
 158         if (iter().keyword().isPattern())
 159         {
 160             patternEntries_.insert(&iter());
 161             patternRegexps_.insert
 162             (
 163                 autoPtr<regExp>(new regExp(iter().keyword()))
 164             );
 165         }
 166     }
 167 }
 168
 169
 170 Foam::dictionary::dictionary
 171 (
 172     const dictionary* dictPtr
 173 )
 174 :
 175     parent_(dictionary::null)
 176 {
 177     if (dictPtr)
 178     {
 179         operator=(*dictPtr);
 180     }
 181 }
 182
 183
 184 Foam::dictionary::dictionary
 185 (
 186     const dictionary& parentDict,
 187     const Xfer<dictionary>& dict
 188 )
 189 :
 190     parent_(parentDict)
 191 {
 192     transfer(dict());
 193     name() = parentDict.name() + "::" + name();
 194 }
 195
 196
 197 Foam::dictionary::dictionary
 198 (
 199     const Xfer<dictionary>& dict
 200 )
 201 :
 202     parent_(dictionary::null)
 203 {
 204     transfer(dict());
 205 }
 206
 207
 208 Foam::autoPtr<Foam::dictionary> Foam::dictionary::clone() const
 209 {
 210     return autoPtr<dictionary>(new dictionary(*this));
 211 }
 212
 213
 214 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 215
 216 Foam::dictionary::~dictionary()
 217 {
 218     // cerr<< "~dictionary() " << name() << " " << long(this) << std::endl;
 219 }
 220
 221
 222 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 223
 224 Foam::label Foam::dictionary::startLineNumber() const
 225 {
 226     if (size())
 227     {
 228         return first()->startLineNumber();
 229     }
 230     else
 231     {
 232         return -1;
 233     }
 234 }
 235
 236
 237 Foam::label Foam::dictionary::endLineNumber() const
 238 {
 239     if (size())
 240     {
 241         return last()->endLineNumber();
 242     }
 243     else
 244     {
 245         return -1;
 246     }
 247 }
 248
 249
 250 Foam::SHA1Digest Foam::dictionary::digest() const
 251 {
 252     OSHA1stream os;
 253
 254     // process entries
 255     forAllConstIter(IDLList<entry>, *this, iter)
 256     {
 257         os << *iter;
 258     }
 259
 260     return os.digest();
 261 }
 262
 263
 264 bool Foam::dictionary::found(const word& keyword, bool recursive) const
 265 {
 266     if (hashedEntries_.found(keyword))
 267     {
 268         return true;
 269     }
 270     else
 271     {
 272         if (patternEntries_.size())
 273         {
 274             DLList<entry*>::const_iterator wcLink =
 275                 patternEntries_.begin();
 276             DLList<autoPtr<regExp> >::const_iterator reLink =
 277                 patternRegexps_.begin();
 278
 279             // Find in patterns using regular expressions only
 280             if (findInPatterns(true, keyword, wcLink, reLink))
 281             {
 282                 return true;
 283             }
 284         }
 285
 286         if (recursive && &parent_ != &dictionary::null)
 287         {
 288             return parent_.found(keyword, recursive);
 289         }
 290         else
 291         {
 292             return false;
 293         }
 294     }
 295 }
 296
 297
 298 const Foam::entry* Foam::dictionary::lookupEntryPtr
 299 (
 300     const word& keyword,
 301     bool recursive,
 302     bool patternMatch
 303 ) const
 304 {
 305     HashTable<entry*>::const_iterator iter = hashedEntries_.find(keyword);
 306
 307     if (iter == hashedEntries_.end())
 308     {
 309         if (patternMatch && patternEntries_.size())
 310         {
 311             DLList<entry*>::const_iterator wcLink =
 312                 patternEntries_.begin();
 313             DLList<autoPtr<regExp> >::const_iterator reLink =
 314                 patternRegexps_.begin();
 315
 316             // Find in patterns using regular expressions only
 317             if (findInPatterns(patternMatch, keyword, wcLink, reLink))
 318             {
 319                 return wcLink();
 320             }
 321         }
 322
 323         if (recursive && &parent_ != &dictionary::null)
 324         {
 325             return parent_.lookupEntryPtr(keyword, recursive, patternMatch);
 326         }
 327         else
 328         {
 329             return NULL;
 330         }
 331     }
 332
 333     return iter();
 334 }
 335
 336
 337 Foam::entry* Foam::dictionary::lookupEntryPtr
 338 (
 339     const word& keyword,
 340     bool recursive,
 341     bool patternMatch
 342 )
 343 {
 344     HashTable<entry*>::iterator iter = hashedEntries_.find(keyword);
 345
 346     if (iter == hashedEntries_.end())
 347     {
 348         if (patternMatch && patternEntries_.size())
 349         {
 350             DLList<entry*>::iterator wcLink =
 351                 patternEntries_.begin();
 352             DLList<autoPtr<regExp> >::iterator reLink =
 353                 patternRegexps_.begin();
 354
 355             // Find in patterns using regular expressions only
 356             if (findInPatterns(patternMatch, keyword, wcLink, reLink))
 357             {
 358                 return wcLink();
 359             }
 360         }
 361
 362         if (recursive && &parent_ != &dictionary::null)
 363         {
 364             return const_cast<dictionary&>(parent_).lookupEntryPtr
 365             (
 366                 keyword,
 367                 recursive,
 368                 patternMatch
 369             );
 370         }
 371         else
 372         {
 373             return NULL;
 374         }
 375     }
 376
 377     return iter();
 378 }
 379
 380
 381 const Foam::entry& Foam::dictionary::lookupEntry
 382 (
 383     const word& keyword,
 384     bool recursive,
 385     bool patternMatch
 386 ) const
 387 {
 388     const entry* entryPtr = lookupEntryPtr(keyword, recursive, patternMatch);
 389
 390     if (entryPtr == NULL)
 391     {
 392         FatalIOErrorIn
 393         (
 394             "dictionary::lookupEntry(const word&, bool, bool) const",
 395             *this
 396         )   << "keyword " << keyword << " is undefined in dictionary "
 397             << name()
 398             << exit(FatalIOError);
 399     }
 400
 401     return *entryPtr;
 402 }
 403
 404
 405 Foam::ITstream& Foam::dictionary::lookup
 406 (
 407     const word& keyword,
 408     bool recursive,
 409     bool patternMatch
 410 ) const
 411 {
 412     return lookupEntry(keyword, recursive, patternMatch).stream();
 413 }
 414
 415
 416 bool Foam::dictionary::isDict(const word& keyword) const
 417 {
 418     // Find non-recursive with patterns
 419     const entry* entryPtr = lookupEntryPtr(keyword, false, true);
 420
 421     if (entryPtr)
 422     {
 423         return entryPtr->isDict();
 424     }
 425     else
 426     {
 427         return false;
 428     }
 429 }
 430
 431
 432 const Foam::dictionary* Foam::dictionary::subDictPtr(const word& keyword) const
 433 {
 434     const entry* entryPtr = lookupEntryPtr(keyword, false, true);
 435
 436     if (entryPtr)
 437     {
 438         return &entryPtr->dict();
 439     }
 440     else
 441     {
 442         return NULL;
 443     }
 444 }
 445
 446
 447 const Foam::dictionary& Foam::dictionary::subDict(const word& keyword) const
 448 {
 449     const entry* entryPtr = lookupEntryPtr(keyword, false, true);
 450
 451     if (entryPtr == NULL)
 452     {
 453         FatalIOErrorIn
 454         (
 455             "dictionary::subDict(const word& keyword) const",
 456             *this
 457         )   << "keyword " << keyword << " is undefined in dictionary "
 458             << name()
 459             << exit(FatalIOError);
 460     }
 461     return entryPtr->dict();
 462 }
 463
 464
 465 Foam::dictionary& Foam::dictionary::subDict(const word& keyword)
 466 {
 467     entry* entryPtr = lookupEntryPtr(keyword, false, true);
 468
 469     if (entryPtr == NULL)
 470     {
 471         FatalIOErrorIn
 472         (
 473             "dictionary::subDict(const word& keyword)",
 474             *this
 475         )   << "keyword " << keyword << " is undefined in dictionary "
 476             << name()
 477             << exit(FatalIOError);
 478     }
 479     return entryPtr->dict();
 480 }
 481
 482
 483 Foam::dictionary Foam::dictionary::subOrEmptyDict
 484 (
 485     const word& keyword
 486 ) const
 487 {
 488     const entry* entryPtr = lookupEntryPtr(keyword, false, true);
 489
 490     if (entryPtr == NULL)
 491     {
 492         return dictionary(*this, dictionary(name() + "::" + keyword));
 493     }
 494     else
 495     {
 496         return entryPtr->dict();
 497     }
 498 }
 499
 500
 501 Foam::wordList Foam::dictionary::toc() const
 502 {
 503     wordList keys(size());
 504
 505     label nKeys = 0;
 506     forAllConstIter(IDLList<entry>, *this, iter)
 507     {
 508         keys[nKeys++] = iter().keyword();
 509     }
 510
 511     return keys;
 512 }
 513
 514
 515 Foam::List<Foam::keyType> Foam::dictionary::keys(bool patterns) const
 516 {
 517     List<keyType> keys(size());
 518
 519     label nKeys = 0;
 520     forAllConstIter(IDLList<entry>, *this, iter)
 521     {
 522         if (iter().keyword().isPattern() ? patterns : !patterns)
 523         {
 524             keys[nKeys++] = iter().keyword();
 525         }
 526     }
 527     keys.setSize(nKeys);
 528
 529     return keys;
 530 }
 531
 532
 533 bool Foam::dictionary::add(entry* entryPtr, bool mergeEntry)
 534 {
 535     HashTable<entry*>::iterator iter = hashedEntries_.find
 536     (
 537         entryPtr->keyword()
 538     );
 539
 540     if (mergeEntry && iter != hashedEntries_.end())
 541     {
 542         // merge dictionary with dictionary
 543         if (iter()->isDict() && entryPtr->isDict())
 544         {
 545             iter()->dict().merge(entryPtr->dict());
 546             delete entryPtr;
 547
 548             return true;
 549         }
 550         else
 551         {
 552             // replace existing dictionary with entry or vice versa
 553             IDLList<entry>::replace(iter(), entryPtr);
 554             delete iter();
 555             hashedEntries_.erase(iter);
 556
 557             if (hashedEntries_.insert(entryPtr->keyword(), entryPtr))
 558             {
 559                 entryPtr->name() = name() + "::" + entryPtr->keyword();
 560
 561                 if (entryPtr->keyword().isPattern())
 562                 {
 563                     patternEntries_.insert(entryPtr);
 564                     patternRegexps_.insert
 565                     (
 566                         autoPtr<regExp>(new regExp(entryPtr->keyword()))
 567                     );
 568                 }
 569
 570                 return true;
 571             }
 572             else
 573             {
 574                 IOWarningIn("dictionary::add(entry*, bool)", (*this))
 575                     << "problem replacing entry "<< entryPtr->keyword()
 576                     << " in dictionary " << name() << endl;
 577
 578                 IDLList<entry>::remove(entryPtr);
 579                 delete entryPtr;
 580                 return false;
 581             }
 582         }
 583     }
 584
 585     if (hashedEntries_.insert(entryPtr->keyword(), entryPtr))
 586     {
 587         entryPtr->name() = name() + "::" + entryPtr->keyword();
 588         IDLList<entry>::append(entryPtr);
 589
 590         if (entryPtr->keyword().isPattern())
 591         {
 592             patternEntries_.insert(entryPtr);
 593             patternRegexps_.insert
 594             (
 595                 autoPtr<regExp>(new regExp(entryPtr->keyword()))
 596             );
 597         }
 598
 599         return true;
 600     }
 601     else
 602     {
 603         IOWarningIn("dictionary::add(entry*, bool)", (*this))
 604             << "attempt to add entry "<< entryPtr->keyword()
 605             << " which already exists in dictionary " << name()
 606             << endl;
 607
 608         delete entryPtr;
 609         return false;
 610     }
 611 }
 612
 613
 614 void Foam::dictionary::add(const entry& e, bool mergeEntry)
 615 {
 616     add(e.clone(*this).ptr(), mergeEntry);
 617 }
 618
 619
 620 void Foam::dictionary::add(const keyType& k, const word& w, bool overwrite)
 621 {
 622     add(new primitiveEntry(k, token(w)), overwrite);
 623 }
 624
 625
 626 void Foam::dictionary::add
 627 (
 628     const keyType& k,
 629     const Foam::string& s,
 630     bool overwrite
 631 )
 632 {
 633     add(new primitiveEntry(k, token(s)), overwrite);
 634 }
 635
 636
 637 void Foam::dictionary::add(const keyType& k, const label l, bool overwrite)
 638 {
 639     add(new primitiveEntry(k, token(l)), overwrite);
 640 }
 641
 642
 643 void Foam::dictionary::add(const keyType& k, const scalar s, bool overwrite)
 644 {
 645     add(new primitiveEntry(k, token(s)), overwrite);
 646 }
 647
 648
 649 void Foam::dictionary::add
 650 (
 651     const keyType& k,
 652     const dictionary& d,
 653     bool mergeEntry
 654 )
 655 {
 656     add(new dictionaryEntry(k, *this, d), mergeEntry);
 657 }
 658
 659
 660 void Foam::dictionary::set(entry* entryPtr)
 661 {
 662     entry* existingPtr = lookupEntryPtr(entryPtr->keyword(), false, true);
 663
 664     // clear dictionary so merge acts like overwrite
 665     if (existingPtr && existingPtr->isDict())
 666     {
 667         existingPtr->dict().clear();
 668     }
 669     add(entryPtr, true);
 670 }
 671
 672
 673 void Foam::dictionary::set(const entry& e)
 674 {
 675     set(e.clone(*this).ptr());
 676 }
 677
 678
 679 void Foam::dictionary::set(const keyType& k, const dictionary& d)
 680 {
 681     set(new dictionaryEntry(k, *this, d));
 682 }
 683
 684
 685 bool Foam::dictionary::remove(const word& Keyword)
 686 {
 687     HashTable<entry*>::iterator iter = hashedEntries_.find(Keyword);
 688
 689     if (iter != hashedEntries_.end())
 690     {
 691         // Delete from patterns first
 692         DLList<entry*>::iterator wcLink =
 693             patternEntries_.begin();
 694         DLList<autoPtr<regExp> >::iterator reLink =
 695             patternRegexps_.begin();
 696
 697         // Find in pattern using exact match only
 698         if (findInPatterns(false, Keyword, wcLink, reLink))
 699         {
 700             patternEntries_.remove(wcLink);
 701             patternRegexps_.remove(reLink);
 702         }
 703
 704         IDLList<entry>::remove(iter());
 705         delete iter();
 706         hashedEntries_.erase(iter);
 707
 708         return true;
 709     }
 710     else
 711     {
 712         return false;
 713     }
 714 }
 715
 716
 717 bool Foam::dictionary::changeKeyword
 718 (
 719     const keyType& oldKeyword,
 720     const keyType& newKeyword,
 721     bool forceOverwrite
 722 )
 723 {
 724     // no change
 725     if (oldKeyword == newKeyword)
 726     {
 727         return false;
 728     }
 729
 730     HashTable<entry*>::iterator iter = hashedEntries_.find(oldKeyword);
 731
 732     // oldKeyword not found - do nothing
 733     if (iter == hashedEntries_.end())
 734     {
 735         return false;
 736     }
 737
 738     if (iter()->keyword().isPattern())
 739     {
 740         FatalErrorIn
 741         (
 742             "dictionary::changeKeyword(const word&, const word&, bool)"
 743         )   << "Old keyword "<< oldKeyword
 744             << " is a pattern."
 745             << "Pattern replacement not yet implemented."
 746             << exit(FatalError);
 747     }
 748
 749
 750     HashTable<entry*>::iterator iter2 = hashedEntries_.find(newKeyword);
 751
 752     // newKeyword already exists
 753     if (iter2 != hashedEntries_.end())
 754     {
 755         if (forceOverwrite)
 756         {
 757             if (iter2()->keyword().isPattern())
 758             {
 759                 // Delete from patterns first
 760                 DLList<entry*>::iterator wcLink =
 761                     patternEntries_.begin();
 762                 DLList<autoPtr<regExp> >::iterator reLink =
 763                     patternRegexps_.begin();
 764
 765                 // Find in patterns using exact match only
 766                 if (findInPatterns(false, iter2()->keyword(), wcLink, reLink))
 767                 {
 768                     patternEntries_.remove(wcLink);
 769                     patternRegexps_.remove(reLink);
 770                 }
 771             }
 772
 773             IDLList<entry>::replace(iter2(), iter());
 774             delete iter2();
 775             hashedEntries_.erase(iter2);
 776
 777         }
 778         else
 779         {
 780             WarningIn
 781             (
 782                 "dictionary::changeKeyword(const word&, const word&, bool)"
 783             )   << "cannot rename keyword "<< oldKeyword
 784                 << " to existing keyword " << newKeyword
 785                 << " in dictionary " << name() << endl;
 786             return false;
 787         }
 788     }
 789
 790     // change name and HashTable, but leave DL-List untouched
 791     iter()->keyword() = newKeyword;
 792     iter()->name() = name() + "::" + newKeyword;
 793     hashedEntries_.erase(oldKeyword);
 794     hashedEntries_.insert(newKeyword, iter());
 795
 796     if (newKeyword.isPattern())
 797     {
 798         patternEntries_.insert(iter());
 799         patternRegexps_.insert
 800         (
 801             autoPtr<regExp>(new regExp(newKeyword))
 802         );
 803     }
 804
 805     return true;
 806 }
 807
 808
 809 bool Foam::dictionary::merge(const dictionary& dict)
 810 {
 811     // Check for assignment to self
 812     if (this == &dict)
 813     {
 814         FatalErrorIn("dictionary::merge(const dictionary&)")
 815             << "attempted merge to self for dictionary " << name()
 816             << abort(FatalError);
 817     }
 818
 819     bool changed = false;
 820
 821     forAllConstIter(IDLList<entry>, dict, iter)
 822     {
 823         HashTable<entry*>::iterator fnd = hashedEntries_.find(iter().keyword());
 824
 825         if (fnd != hashedEntries_.end())
 826         {
 827             // Recursively merge sub-dictionaries
 828             // TODO: merge without copying
 829             if (fnd()->isDict() && iter().isDict())
 830             {
 831                 if (fnd()->dict().merge(iter().dict()))
 832                 {
 833                     changed = true;
 834                 }
 835             }
 836             else
 837             {
 838                 add(iter().clone(*this).ptr(), true);
 839                 changed = true;
 840             }
 841         }
 842         else
 843         {
 844             // not found - just add
 845             add(iter().clone(*this).ptr());
 846             changed = true;
 847         }
 848     }
 849
 850     return changed;
 851 }
 852
 853
 854 void Foam::dictionary::clear()
 855 {
 856     IDLList<entry>::clear();
 857     hashedEntries_.clear();
 858     patternEntries_.clear();
 859     patternRegexps_.clear();
 860 }
 861
 862
 863 void Foam::dictionary::transfer(dictionary& dict)
 864 {
 865     // changing parents probably doesn't make much sense,
 866     // but what about the names?
 867     name() = dict.name();
 868
 869     IDLList<entry>::transfer(dict);
 870     hashedEntries_.transfer(dict.hashedEntries_);
 871     patternEntries_.transfer(dict.patternEntries_);
 872     patternRegexps_.transfer(dict.patternRegexps_);
 873 }
 874
 875
 876 Foam::Xfer<Foam::dictionary> Foam::dictionary::xfer()
 877 {
 878     return xferMove(*this);
 879 }
 880
 881
 882 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 883
 884 Foam::ITstream& Foam::dictionary::operator[](const word& keyword) const
 885 {
 886     return lookup(keyword);
 887 }
 888
 889
 890 void Foam::dictionary::operator=(const dictionary& rhs)
 891 {
 892     // Check for assignment to self
 893     if (this == &rhs)
 894     {
 895         FatalErrorIn("dictionary::operator=(const dictionary&)")
 896             << "attempted assignment to self for dictionary " << name()
 897             << abort(FatalError);
 898     }
 899
 900     name() = rhs.name();
 901     clear();
 902
 903     // Create clones of the entries in the given dictionary
 904     // resetting the parentDict to this dictionary
 905
 906     forAllConstIter(IDLList<entry>, rhs, iter)
 907     {
 908         add(iter().clone(*this).ptr());
 909     }
 910 }
 911
 912
 913 void Foam::dictionary::operator+=(const dictionary& rhs)
 914 {
 915     // Check for assignment to self
 916     if (this == &rhs)
 917     {
 918         FatalErrorIn("dictionary::operator+=(const dictionary&)")
 919             << "attempted addition assignment to self for dictionary " << name()
 920             << abort(FatalError);
 921     }
 922
 923     forAllConstIter(IDLList<entry>, rhs, iter)
 924     {
 925         add(iter().clone(*this).ptr());
 926     }
 927 }
 928
 929
 930 void Foam::dictionary::operator|=(const dictionary& rhs)
 931 {
 932     // Check for assignment to self
 933     if (this == &rhs)
 934     {
 935         FatalErrorIn("dictionary::operator|=(const dictionary&)")
 936             << "attempted assignment to self for dictionary " << name()
 937             << abort(FatalError);
 938     }
 939
 940     forAllConstIter(IDLList<entry>, rhs, iter)
 941     {
 942         if (!found(iter().keyword()))
 943         {
 944             add(iter().clone(*this).ptr());
 945         }
 946     }
 947 }
 948
 949
 950 void Foam::dictionary::operator<<=(const dictionary& rhs)
 951 {
 952     // Check for assignment to self
 953     if (this == &rhs)
 954     {
 955         FatalErrorIn("dictionary::operator<<=(const dictionary&)")
 956             << "attempted assignment to self for dictionary " << name()
 957             << abort(FatalError);
 958     }
 959
 960     forAllConstIter(IDLList<entry>, rhs, iter)
 961     {
 962         set(iter().clone(*this).ptr());
 963     }
 964 }
 965
 966
 967 /* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
 968
 969 Foam::dictionary Foam::operator+
 970 (
 971     const dictionary& dict1,
 972     const dictionary& dict2
 973 )
 974 {
 975     dictionary sum(dict1);
 976     sum += dict2;
 977     return sum;
 978 }
 979
 980
 981 Foam::dictionary Foam::operator|
 982 (
 983     const dictionary& dict1,
 984     const dictionary& dict2
 985 )
 986 {
 987     dictionary sum(dict1);
 988     sum |= dict2;
 989     return sum;
 990 }
 991
 992
 993 // ************************************************************************* //