| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @author Intel, Mikhail Y. Fursov |
| * |
| */ |
| |
| #ifndef _HASHSET_H_ |
| #define _HASHSET_H_ |
| |
| #include <assert.h> |
| #include "open/types.h" |
| #include "MemoryManager.h" |
| #include "Stl.h" |
| |
| namespace Jitrino { |
| |
| // |
| // Hash set that is based on an STL Hash map. Set elements of type ELEM |
| // are indexed by key of type KEY. |
| // |
| template<class KEY, class ELEM> class HashSet { |
| public: |
| typedef StlHashMap<KEY,ELEM>::iterator iterator; |
| typedef StlHashMap<KEY,ELEM>::const_iterator const_iterator; |
| // |
| // Constructor |
| // |
| HashSet(MemoryManager& memManager) : map(memManager) { |
| } |
| // |
| // Copy constructor |
| // |
| HashSet(MemoryManager& memManager, const HashSet<KEY,ELEM> &set) |
| : map(memManager) { |
| const_iterator iter = set.map.begin(), |
| end = set.map.end(); |
| for (; iter != end; iter++) |
| map.insert(*iter); |
| } |
| // |
| // Returns number of elements in the set |
| // |
| U_32 getSize() const {return (U_32)map.size();} |
| // |
| // Returns true if set contains the element, false otherwise |
| // |
| bool contains(KEY key) const { |
| return map.find(key) != map.end(); |
| } |
| // |
| // Inserts element into the set |
| // |
| void insert(KEY key, ELEM elem) {map[key] = elem;} |
| // |
| // Removes element from the set |
| // |
| void remove(KEY key) {map.erase(key);} |
| // |
| // Removes all element from the set |
| // |
| void clear() {map.clear();} |
| // |
| // Checks if set is empty |
| // |
| bool isEmpty() {return map.empty();} |
| // |
| // Copies another set |
| // |
| void copyFrom(const HashSet<KEY,ELEM>& set) { |
| if (this != &set) { |
| map.clear(); |
| const_iterator iter = set.map.begin(), |
| end = set.map.end(); |
| for (; iter != end; iter++) |
| map.insert(*iter); |
| } |
| } |
| // |
| // Unions with another set |
| // |
| void unionWith(const HashSet<KEY,ELEM>& set) { |
| const_iterator iter = set.map.begin(), |
| end = set.map.end(); |
| for (; iter != end; iter++) { |
| iterator iter2 = map.find(iter->first); |
| assert((iter2 == map.end()) || (iter2->second == iter->second)); |
| map.insert(*iter); |
| } |
| } |
| // |
| // Intersects with another set |
| // |
| void intersectWith(const HashSet<KEY,ELEM>& set) { |
| // |
| // Find elements that are in this set but are not in 'set' and |
| // write them into 'removeList'. |
| // |
| MemoryManager memManager("HashSet::intersect.memManager"); |
| KEY * removeList = (KEY *)memManager.alloc(sizeof(KEY) * map.size()); |
| U_32 removeListSize = 0; |
| const_iterator iter = map.begin(), |
| end = map.end(); |
| for (; iter != end; iter++) { |
| if (set.map.find(iter->first) == set.map.end()) |
| removeList[removeListSize++] = iter->first; |
| } |
| // |
| // Remove elements that are in removeList |
| // |
| for (U_32 i = 0; i < removeListSize; i++) |
| map.erase(removeList[i]); |
| } |
| // |
| // Subtracts another set |
| // |
| void subtract(const HashSet<KEY,ELEM>& set) { |
| const_iterator iter = set.map.begin(), |
| end = set.map.end(); |
| for (; iter != end; iter++) |
| map.erase(iter->first); |
| } |
| // |
| // Checks if set is subset of another set |
| // |
| bool isSubset(const HashSet<KEY,ELEM>& set) const { |
| const_iterator iter = map.begin(), |
| end = map.end(); |
| for (; iter != end; iter++) { |
| if (set.map.find(iter->first) == set.map.end()) |
| return false; |
| } |
| return true; |
| } |
| // |
| // Checks if set is disjoint to another set |
| // |
| bool isDisjoint(const HashSet<KEY,ELEM>& set) const { |
| const_iterator iter = map.begin(), |
| end = map.end(); |
| for (; iter != end; iter++) { |
| if (set.map.find(iter->first) != set.map.end()) |
| return false; |
| } |
| return true; |
| } |
| // |
| // Checks if set is equal to another set |
| // |
| bool isEqual(const HashSet<KEY,ELEM>& set) { |
| return isSubset(set) && set.isSubset(*this); |
| } |
| // |
| // Returns an iterator to the first element in the set |
| // |
| iterator begin() {return map.begin();} |
| // |
| // Returns an iterator that points just beyond last element of the set |
| // |
| iterator end() {return map.end();} |
| private: |
| StlHashMap<U_32,ELEM> map; |
| }; |
| |
| } //namespace Jitrino |
| |
| #endif // _HASHSET_H_ |