src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTable.H

   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 Class
  26     Foam::HashPtrTable
  27
  28 Description
  29     A HashTable specialization for hashing pointers.
  30
  31 SourceFiles
  32     HashPtrTable.C
  33     HashPtrTableIO.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef HashPtrTable_H
  38 #define HashPtrTable_H
  39
  40 #include "HashTable.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 class Istream;
  48 class Ostream;
  49
  50 // Forward declaration of friend functions and operators
  51
  52 template<class T, class Key, class Hash> class HashPtrTable;
  53
  54 template<class T, class Key, class Hash> Istream& operator>>
  55 (
  56     Istream&,
  57     HashPtrTable<T, Key, Hash>&
  58 );
  59
  60 template<class T, class Key, class Hash> Ostream& operator<<
  61 (
  62     Ostream&,
  63     const HashPtrTable<T, Key, Hash>&
  64 );
  65
  66
  67 /*---------------------------------------------------------------------------*\
  68                            Class HashPtrTable Declaration
  69 \*---------------------------------------------------------------------------*/
  70
  71 template<class T, class Key=word, class Hash=string::hash>
  72 class HashPtrTable
  73 :
  74     public HashTable<T*, Key, Hash>
  75 {
  76     // Private member functions
  77
  78         //- Read from Istream using given Istream constructor class
  79         template<class INew>
  80         void read(Istream&, const INew& inewt);
  81
  82
  83 public:
  84
  85     typedef typename HashTable<T*, Key, Hash>::iterator iterator;
  86     typedef typename HashTable<T*, Key, Hash>::const_iterator const_iterator;
  87
  88
  89     // Constructors
  90
  91         //- Construct given initial table size
  92         HashPtrTable(label size = 100);
  93
  94         //- Construct from Istream using given Istream constructor class
  95         template<class INew>
  96         HashPtrTable(Istream&, const INew&);
  97
  98         //- Construct from Istream using default Istream constructor class
  99         HashPtrTable(Istream&);
 100
 101         //- Construct as copy
 102         HashPtrTable(const HashPtrTable<T, Key, Hash>&);
 103
 104
 105     // Destructor
 106
 107         ~HashPtrTable();
 108
 109
 110     // Member Functions
 111
 112         // Edit
 113
 114             //- Remove and return the pointer specified by given iterator
 115             T* remove(iterator&);
 116
 117             //- Erase an hashedEntry specified by given iterator
 118             bool erase(iterator&);
 119
 120             //- Clear all entries from table
 121             void clear();
 122
 123
 124     // Member Operators
 125
 126         void operator=(const HashPtrTable<T, Key, Hash>&);
 127
 128
 129     // IOstream Operators
 130
 131         friend Istream& operator>>
 132         #ifndef __CINT__
 133         <T, Key, Hash>
 134         #endif
 135         (
 136             Istream&,
 137             HashPtrTable<T, Key, Hash>&
 138         );
 139
 140         friend Ostream& operator<<
 141         #ifndef __CINT__
 142         <T, Key, Hash>
 143         #endif
 144         (
 145             Ostream&,
 146             const HashPtrTable<T, Key, Hash>&
 147         );
 148 };
 149
 150
 151 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 152
 153 } // End namespace Foam
 154
 155 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 156
 157 #ifdef NoRepository
 158 #   include "HashPtrTable.C"
 159 #endif
 160
 161 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 162
 163 #endif
 164
 165 // ************************************************************************* //