Set.h

Go to the documentation of this file.

#ifndef G3D_Set_h
#define G3D_Set_h

#include "G3D/platform.h"
#include "G3D/Table.h"
#include "G3D/MemoryManager.h"
#include <assert.h>
#include <string>

namespace G3D {

// There is not copy constructor or assignment operator defined because
// the default ones are correct for Set.
template<class T, class HashFunc = HashTrait<T>, class EqualsFunc = EqualsTrait<T> > 
class Set {

 Table<T, bool, HashFunc, EqualsFunc> memberTable;

public:

 void clearAndSetMemoryManager(const MemoryManager::Ref& m) {
 memberTable.clearAndSetMemoryManager(m);
 }

 virtual ~Set() {}

 int size() const {
 return (int)memberTable.size();
 }

 bool contains(const T& member) const {
 return memberTable.containsKey(member);
 }

 bool insert(const T& member) {
 bool isNew = false;
 memberTable.getCreate(member, isNew) = true;
 return isNew;
 }

 bool remove(const T& member) {
 return memberTable.remove(member); 
 }

 bool getRemove(const T& member, T& removed) {
 bool ignore;
 return memberTable.getRemove(member, removed, ignore);
 }

 const T* getPointer(const T& member) const {
 return memberTable.getKeyPointer(member);
 }

 Array<T> getMembers() const {
 return memberTable.getKeys();
 }

 void getMembers(Array<T>& keyArray) const {
 memberTable.getKeys(keyArray);
 }

 void clear() {
 memberTable.clear();
 }

 void deleteAll() {
 getMembers().deleteAll();
 clear();
 }

 class Iterator {
 private:
 friend class Set<T>;

 // Note: this is a Table iterator, we are currently defining
 // Set iterator
 typename Table<T, bool>::Iterator it;

 Iterator(const typename Table<T, bool>::Iterator& it) : it(it) {}

 public:
 inline bool operator!=(const Iterator& other) const {
 return !(*this == other);
 }

 bool isValid() const {
 return it.isValid();
 }

 bool hasMore() const {
 return it.isValid();
 }
 
 bool operator==(const Iterator& other) const {
 return it == other.it;
 }

 Iterator& operator++() {
 ++it;
 return *this;
 }

 Iterator operator++(int) {
 Iterator old = *this;
 ++(*this);
 return old;
 }

 const T& operator*() const {
 return it->key;
 }

 T* operator->() const {
 return &(it->key);
 }

 operator T*() const {
 return &(it->key);
 }
 };


 Iterator begin() const {
 return Iterator(memberTable.begin());
 }


 const Iterator end() const {
 return Iterator(memberTable.end());
 }
};

}

#endif