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