src/OpenFOAM/containers/HashTables/HashSet/HashSet.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 \*---------------------------------------------------------------------------*/
  26
  27 #ifndef HashSet_C
  28 #define HashSet_C
  29
  30 #include "HashSet.H"
  31
  32 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  33
  34 template<class Key, class Hash>
  35 template<class AnyType>
  36 Foam::HashSet<Key, Hash>::HashSet(const HashTable<AnyType, Key, Hash>& h)
  37 :
  38     HashTable<nil, Key, Hash>(h.size())
  39 {
  40     for
  41     (
  42         typename HashTable<AnyType, Key, Hash>::const_iterator cit = h.cbegin();
  43         cit != h.cend();
  44         ++cit
  45     )
  46     {
  47         insert(cit.key());
  48     }
  49 }
  50
  51
  52 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
  53
  54 template<class Key, class Hash>
  55 inline bool Foam::HashSet<Key, Hash>::operator[](const Key& key) const
  56 {
  57     return found(key);
  58 }
  59
  60
  61 template<class Key, class Hash>
  62 bool Foam::HashSet<Key, Hash>::operator==(const HashSet<Key, Hash>& rhs) const
  63 {
  64     // Are all lhs elements in rhs?
  65     for (const_iterator iter = this->cbegin(); iter != this->cend(); ++iter)
  66     {
  67         if (!rhs.found(iter.key()))
  68         {
  69             return false;
  70         }
  71     }
  72
  73     // Are all rhs elements in lhs?
  74     for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
  75     {
  76         if (!found(iter.key()))
  77         {
  78             return false;
  79         }
  80     }
  81
  82     return true;
  83 }
  84
  85
  86 template<class Key, class Hash>
  87 bool Foam::HashSet<Key, Hash>::operator!=(const HashSet<Key, Hash>& rhs) const
  88 {
  89     return !(operator==(rhs));
  90 }
  91
  92
  93 template<class Key, class Hash>
  94 void Foam::HashSet<Key, Hash>::operator|=(const HashSet<Key, Hash>& rhs)
  95 {
  96     // Add rhs elements into lhs
  97     for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
  98     {
  99         insert(iter.key());
 100     }
 101 }
 102
 103
 104 template<class Key, class Hash>
 105 void Foam::HashSet<Key, Hash>::operator&=(const HashSet<Key, Hash>& rhs)
 106 {
 107     // Remove elements not also found in rhs
 108     for (iterator iter = this->cbegin(); iter != this->cend(); ++iter)
 109     {
 110         if (!rhs.found(iter.key()))
 111         {
 112             erase(iter);
 113         }
 114     }
 115 }
 116
 117
 118 template<class Key, class Hash>
 119 void Foam::HashSet<Key, Hash>::operator^=(const HashSet<Key, Hash>& rhs)
 120 {
 121     // Add missed rhs elements, remove duplicate elements
 122     for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
 123     {
 124         if (found(iter.key()))
 125         {
 126             erase(iter.key());
 127         }
 128         else
 129         {
 130             insert(iter.key());
 131         }
 132     }
 133 }
 134
 135
 136 // same as HashTable::erase()
 137 template<class Key, class Hash>
 138 void Foam::HashSet<Key, Hash>::operator-=(const HashSet<Key, Hash>& rhs)
 139 {
 140     // Remove rhs elements from lhs
 141     for (const_iterator iter = rhs.cbegin(); iter != rhs.cend(); ++iter)
 142     {
 143         erase(iter.key());
 144     }
 145 }
 146
 147
 148 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 149
 150 /* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
 151
 152 template<class Key, class Hash>
 153 Foam::HashSet<Key, Hash>
 154 Foam::operator|
 155 (
 156     const HashSet<Key, Hash>& hash1,
 157     const HashSet<Key, Hash>& hash2
 158 )
 159 {
 160     HashSet<Key, Hash> out(hash1);
 161     out |= hash2;
 162     return out;
 163 }
 164
 165
 166 template<class Key, class Hash>
 167 Foam::HashSet<Key, Hash>
 168 Foam::operator&
 169 (
 170     const HashSet<Key, Hash>& hash1,
 171     const HashSet<Key, Hash>& hash2
 172 )
 173 {
 174     HashSet<Key, Hash> out(hash1);
 175     out &= hash2;
 176     return out;
 177 }
 178
 179
 180 template<class Key, class Hash>
 181 Foam::HashSet<Key, Hash>
 182 Foam::operator^
 183 (
 184     const HashSet<Key, Hash>& hash1,
 185     const HashSet<Key, Hash>& hash2
 186 )
 187 {
 188     HashSet<Key, Hash> out(hash1);
 189     out ^= hash2;
 190     return out;
 191 }
 192
 193 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 194
 195 #endif
 196
 197 // ************************************************************************* //