src/OpenFOAM/db/IOobjectList/IOobjectList.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "IOobjectList.H"
  27 #include "Time.H"
  28 #include "OSspecific.H"
  29
  30
  31 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  32
  33 Foam::IOobjectList::IOobjectList(const label nIoObjects)
  34 :
  35     HashPtrTable<IOobject>(nIoObjects)
  36 {}
  37
  38
  39 Foam::IOobjectList::IOobjectList
  40 (
  41     const objectRegistry& db,
  42     const fileName& instance,
  43     const fileName& local
  44 )
  45 :
  46     HashPtrTable<IOobject>()
  47 {
  48     word newInstance = instance;
  49
  50     if (!isDir(db.path(instance)))
  51     {
  52         newInstance = db.time().findInstancePath(instant(instance));
  53
  54         if (newInstance.empty())
  55         {
  56             return;
  57         }
  58     }
  59
  60     // Create a list of file names in this directory
  61     fileNameList ObjectNames =
  62         readDir(db.path(newInstance, db.dbDir()/local), fileName::FILE);
  63
  64     forAll(ObjectNames, i)
  65     {
  66         IOobject* objectPtr = new IOobject
  67         (
  68             ObjectNames[i],
  69             newInstance,
  70             local,
  71             db,
  72             IOobject::MUST_READ,
  73             IOobject::NO_WRITE
  74         );
  75
  76         if (objectPtr->headerOk())
  77         {
  78             insert(ObjectNames[i], objectPtr);
  79         }
  80         else
  81         {
  82             delete objectPtr;
  83         }
  84     }
  85 }
  86
  87
  88 Foam::IOobjectList::IOobjectList(const IOobjectList& ioOL)
  89 :
  90     HashPtrTable<IOobject>(ioOL)
  91 {}
  92
  93
  94 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
  95
  96 Foam::IOobjectList::~IOobjectList()
  97 {}
  98
  99
 100 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 101
 102 bool Foam::IOobjectList::add(IOobject& io)
 103 {
 104     return insert(io.name(), &io);
 105 }
 106
 107
 108 bool Foam::IOobjectList::remove(IOobject& io)
 109 {
 110     HashPtrTable<IOobject>::iterator iter =
 111         HashPtrTable<IOobject>::find(io.name());
 112
 113     if (iter != end())
 114     {
 115         return erase(iter);
 116     }
 117     else
 118     {
 119         return false;
 120     }
 121 }
 122
 123
 124 Foam::IOobject* Foam::IOobjectList::lookup(const word& name) const
 125 {
 126     HashPtrTable<IOobject>::const_iterator iter = find(name);
 127
 128     if (iter != end())
 129     {
 130         if (IOobject::debug)
 131         {
 132             Info<< "IOobjectList::lookup : found "
 133                 << name << endl;
 134         }
 135
 136         return const_cast<IOobject*>(*iter);
 137     }
 138     else
 139     {
 140         if (IOobject::debug)
 141         {
 142             Info<< "IOobjectList::lookup : could not find "
 143                 << name << endl;
 144         }
 145
 146         return NULL;
 147     }
 148 }
 149
 150
 151 Foam::IOobjectList Foam::IOobjectList::lookupClass(const word& ClassName) const
 152 {
 153     IOobjectList objectsOfClass(size());
 154
 155     forAllConstIter(HashPtrTable<IOobject>, *this, iter)
 156     {
 157         if (iter()->headerClassName() == ClassName)
 158         {
 159             if (IOobject::debug)
 160             {
 161                 Info<< "IOobjectList::lookupClass : found "
 162                     << iter.key() << endl;
 163             }
 164
 165             objectsOfClass.insert(iter.key(), new IOobject(*iter()));
 166         }
 167     }
 168
 169     return objectsOfClass;
 170 }
 171
 172
 173 Foam::wordList Foam::IOobjectList::names() const
 174 {
 175     return HashPtrTable<IOobject>::toc();
 176 }
 177
 178
 179 Foam::wordList Foam::IOobjectList::sortedNames() const
 180 {
 181     return HashPtrTable<IOobject>::sortedToc();
 182 }
 183
 184
 185 Foam::wordList Foam::IOobjectList::names(const word& ClassName) const
 186 {
 187     wordList objectNames(size());
 188
 189     label count = 0;
 190     forAllConstIter(HashPtrTable<IOobject>, *this, iter)
 191     {
 192         if (iter()->headerClassName() == ClassName)
 193         {
 194             objectNames[count++] = iter.key();
 195         }
 196     }
 197
 198     objectNames.setSize(count);
 199
 200     return objectNames;
 201 }
 202
 203
 204 Foam::wordList Foam::IOobjectList::sortedNames(const word& ClassName) const
 205 {
 206     wordList sortedLst = names(ClassName);
 207     sort(sortedLst);
 208
 209     return sortedLst;
 210 }
 211
 212
 213 // ************************************************************************* //