applications/test/Dictionary/DictionaryTest.C

   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 Application
  25
  26 Description
  27
  28 \*---------------------------------------------------------------------------*/
  29
  30 #include "OSspecific.H"
  31
  32 #include "scalar.H"
  33
  34 #include "IOstreams.H"
  35 #include "Dictionary.H"
  36 #include "PtrDictionary.H"
  37
  38 using namespace Foam;
  39
  40 class ent
  41 :
  42     public Dictionary<ent>::link
  43 {
  44     word keyword_;
  45     int i_;
  46
  47 public:
  48
  49     ent(const word& keyword, int i)
  50     :
  51         keyword_(keyword),
  52         i_(i)
  53     {}
  54
  55     const word& keyword() const
  56     {
  57         return keyword_;
  58     }
  59
  60     friend Ostream& operator<<(Ostream& os, const ent& e)
  61     {
  62         os << e.keyword_ << ' ' << e.i_ << endl;
  63         return os;
  64     }
  65 };
  66
  67
  68 class Scalar
  69 {
  70     scalar data_;
  71
  72 public:
  73
  74     Scalar()
  75     :
  76         data_(0)
  77     {}
  78
  79     Scalar(scalar val)
  80     :
  81         data_(val)
  82     {}
  83
  84     ~Scalar()
  85     {
  86         Info <<"delete Scalar: " << data_ << endl;
  87     }
  88
  89     friend Ostream& operator<<(Ostream& os, const Scalar& val)
  90     {
  91         os << val.data_;
  92         return os;
  93     }
  94 };
  95
  96
  97
  98 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  99 //  Main program:
 100
 101 int main(int argc, char *argv[])
 102 {
 103     Dictionary<ent>* dictPtr = new Dictionary<ent>;
 104     Dictionary<ent>& dict = *dictPtr;
 105
 106     for (int i = 0; i<10; i++)
 107     {
 108         ent* ePtr = new ent(word("ent") + name(i), i);
 109         dict.append(ePtr->keyword(), ePtr);
 110         dict.swapUp(ePtr);
 111     }
 112
 113     Info<< dict << endl;
 114
 115     dict.swapDown(dict.first());
 116
 117     for
 118     (
 119         Dictionary<ent>::const_iterator iter = dict.begin();
 120         iter != dict.end();
 121         ++iter
 122     )
 123     {
 124         Info<< "element : " << *iter;
 125     }
 126
 127     Info<< "keys: " << dict.toc() << endl;
 128
 129     delete dictPtr;
 130
 131     Dictionary<ent> dict2;
 132
 133     for (int i = 0; i<10; i++)
 134     {
 135         ent* ePtr = new ent(word("ent") + name(i), i);
 136         dict2.append(ePtr->keyword(), ePtr);
 137         dict2.swapUp(ePtr);
 138     }
 139
 140     Info<< "dict:\n" << dict2 << endl;
 141
 142     Info<< nl << "Testing transfer: " << nl << endl;
 143     Info<< "original: " << dict2 << endl;
 144
 145     Dictionary<ent> newDict;
 146     newDict.transfer(dict2);
 147
 148     Info<< nl << "source: " << dict2 << nl
 149         << "keys: " << dict2.toc() << nl
 150         << "target: " << newDict << nl
 151         << "keys: " << newDict.toc() << endl;
 152
 153
 154     PtrDictionary<Scalar> scalarDict;
 155     for (int i = 0; i<10; i++)
 156     {
 157         word key("ent" + name(i));
 158         scalarDict.insert(key, new Scalar(1.3*i));
 159     }
 160
 161     Info<< nl << "scalarDict1: " << endl;
 162     for
 163     (
 164         PtrDictionary<Scalar>::const_iterator iter = scalarDict.begin();
 165         iter != scalarDict.end();
 166         ++iter
 167     )
 168     {
 169         Info<< " = " << iter() << endl;
 170     }
 171
 172     PtrDictionary<Scalar> scalarDict2;
 173     for (int i = 8; i<15; i++)
 174     {
 175         word key("ent" + name(i));
 176         scalarDict2.insert(key, new Scalar(1.3*i));
 177     }
 178     Info<< nl << "scalarDict2: " << endl;
 179     for
 180     (
 181         PtrDictionary<Scalar>::const_iterator iter = scalarDict2.begin();
 182         iter != scalarDict2.end();
 183         ++iter
 184     )
 185     {
 186         Info<< "elem = " << *iter << endl;
 187     }
 188
 189     scalarDict.transfer(scalarDict2);
 190
 191
 192     Scalar* p = scalarDict.lookupPtr("ent8");
 193
 194     // This does not (yet) work
 195     // Scalar* q = scalarDict.remove("ent10");
 196
 197     if (p)
 198     {
 199         Info << "found: " << *p << endl;
 200     }
 201     else
 202     {
 203         Info << "no p: " << endl;
 204     }
 205
 206     scalarDict.clear();
 207
 208     // Info<< " = " << *iter << endl;
 209
 210
 211
 212     Info<< nl << "Done." << endl;
 213     return 0;
 214 }
 215
 216
 217 // ************************************************************************* //