Chaged Resource::type to be stored as a number instead of a string. Also

changed ResourceSet to store resources as a QVector instead of a QSet.

2 files changed, 42 insertions, 40 deletions

diff --git a/src/resource-set.cpp b/src/resource-set.cpp
index 999baec..af691b1 100644
--- a/src/resource-set.cpp
+++ b/src/resource-set.cpp
@@ -1,48 +1,71 @@
 #include "resource-set.h"
+using namespace ResourcePolicy;
 
 
-ResourcePolicy::ResourceSet::ResourceSet(const QString &applicationClass)
-    : applicationClass(applicationClass), resourceSet()
+ResourceSet::ResourceSet(const QString &applicationClass)
+    : applicationClass(applicationClass), resourceSet(ResourceGuard)
 {
     identifier = (quint32)this;
 }
 
-ResourcePolicy::ResourceSet::~ResourceSet()
+ResourceSet::~ResourceSet()
 {
 }
 
-void ResourcePolicy::ResourceSet::addResource(const ResourcePolicy::Resource &resource)
+void ResourceSet::addResource(const Resource &resource)
 {
-    resourceSet.insert(resource);
+    resourceSet.insert(resource.type(), resource);
 }
 
-void ResourcePolicy::ResourceSet::addResources(const QSet<ResourcePolicy::Resource> &resources)
+void ResourceSet::addResources(const QList<Resource> &resources)
 {
-    resourceSet.unite(resources);
+    for(int i=0; i < resources.size(); i++) {
+	addResource(resources.at(i));
+    }
 }
 
-void ResourcePolicy::ResourceSet::setResources(const QSet<ResourcePolicy::Resource> &resources)
+void ResourceSet::setResources(const QList<Resource> &resources)
 {
+    Resource invalidResource;
     resourceSet.clear();
-    resourceSet = resources;
+    resourceSet.resize(ResourceGuard);
+    for(int i=0; i < resources.size(); i++) {
+	addResource(resources.at(i));
+    }
 }
 
-bool ResourcePolicy::ResourceSet::contains(const ResourcePolicy::Resource &resource) const
+bool ResourceSet::contains(const Resource &resource) const
 {
-    return resourceSet.contains(resource);
+    if(resourceSet.at(resource.type()) == resource)
+	return true;
+    else
+	return false;
 }
 
-bool ResourcePolicy::ResourceSet::contains(const QSet<ResourcePolicy::Resource> &resources) const
+bool ResourceSet::contains(const QList<Resource> &resources) const
 {
-    return resourceSet.contains(resources);
+    bool containsAll=false;
+    for(int i=0; i<resources.size(); i++) {
+	containsAll = contains(resources.at(i));
+	if(!containsAll) {
+	    break;
+	}
+    }
+    return containsAll;
 }
 
-quint32 ResourcePolicy::ResourceSet::id() const
+quint32 ResourceSet::id() const
 {
     return identifier;
 }
 
-QSet<ResourcePolicy::Resource> ResourcePolicy::ResourceSet::resources()
+QList<Resource> ResourceSet::resources()
 {
-    return resourceSet;
+    QList<Resource> listOfResources;
+    for(int i=0; i < resourceSet.size(); i++) {
+	if(resourceSet.at(i).type() != InvalidResource) {
+	    listOfResources.append(resourceSet.at(i));
+	}
+    }
+    return listOfResources;
 }
diff --git a/src/resource.cpp b/src/resource.cpp
index a54c8cf..72ac24e 100644
--- a/src/resource.cpp
+++ b/src/resource.cpp
@@ -2,9 +2,9 @@
 
 using namespace ResourcePolicy;
 
-Resource::Resource() : resourceType(InvalidResource), optional(false), shared(false)
+Resource::Resource(enum ResourceType type)
+    : resourceType(type), optional(false), shared(false)
 {
-    identifier = (quint32)this;
 }
 
 Resource::~Resource()
@@ -13,7 +13,7 @@ Resource::~Resource()
 
 Resource::Resource(const Resource &other)
     : resourceType(other.resourceType), optional(other.optional),
-      shared(other.shared), identifier(other.identifier)
+      shared(other.shared)
 {
 }
 
@@ -22,7 +22,6 @@ Resource & Resource::operator=(const Resource &other)
     resourceType = other.resourceType;
     optional = other.optional;
     shared = other.shared;
-    identifier = other.identifier;
 
     return *this;
 }
@@ -63,30 +62,10 @@ void Resource::setShared(bool shared)
     this->shared = shared;
 }
 
-quint32 Resource::id() const
-{
-    return identifier;
-}
-
-void Resource::setId(quint32 newId)
-{
-    identifier = newId;
-}
-
 bool Resource::operator==(const Resource &other) const
 {
     if(resourceType != other.resourceType) {
 	return false;
     }
-    if((shared != other.shared) or 
-       (optional != other.optional))
-    {
-	return false;
-    }
     return true;
 }
-
-uint ResourcePolicy::qHash(const Resource & key)
-{
-    return (((key.type()<<1) + key.isShared()) << 1) + key.isOptional();
-}