blob: 09b1c8b9150ed20e85a8dcf138e4a96dbaa8b509 [file] [log] [blame]
/*
* 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_