summaryrefslogtreecommitdiff
path: root/libresourceqt/src/resource-set.cpp
blob: 6ff8d9a2c666f6b16d4c8e77c0f13b44e7095958 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <policy/resource-set.h>
using namespace ResourcePolicy;


ResourceSet::ResourceSet(const QString &applicationClass, QObject * parent)
    : QObject(parent), resourceClass(applicationClass)
{
    identifier = (quint32)this;
    memset(resourceSet, 0, sizeof(QPointer<Resource>)*NumberOfTypes);
}

ResourceSet::~ResourceSet()
{
    for(int i=0;i<NumberOfTypes;i++) {
        delete resourceSet[i];
    }
}

void ResourceSet::addResource(const Resource *resource)
{
    resourceSet[resource->type()] = resource->clone();
}

void ResourceSet::addResources(const QList<Resource *>resources)
{
    for(int i=0; i < resources.size(); i++) {
        addResource(resources.at(i));
    }
}

void ResourceSet::delResource(ResourceType type)
{
    if(contains(type)) {
        delete resourceSet[type];
        resourceSet[type] = NULL;
    }
}

bool ResourceSet::contains(ResourceType type) const
{
    if((type < NumberOfTypes) && (resourceSet[type] != NULL))
        return true;
    else
        return false;
}

bool ResourceSet::contains(const QList<ResourceType> &types) const
{
    bool containsAll=true;
    int i=0;
    do {
        containsAll = contains(types.at(i));
        i++;
    } while((i < NumberOfTypes) && containsAll);
    return containsAll;
}

quint32 ResourceSet::id() const
{
    return identifier;
}

QList<Resource *> ResourceSet::resources() const
{
    QList<Resource *> listOfResources;
    for(int i=0; i < NumberOfTypes; i++) {
        if(resourceSet[i] != NULL) {
            Resource *clone = resourceSet[i]->clone();
            listOfResources.append(clone);
        }
    }
    return listOfResources;
}

Resource * ResourceSet::resource(ResourceType type) const
{
    if(contains(type))
        return resourceSet[type]->clone();
    else
        return NULL;
}

bool ResourceSet::connectToManager(bool reconnectOnDisconnect)
{
    return false;
}

void ResourceSet::disconnectFromManager()
{
}

bool ResourceSet::isConnectedToManager()
{
    return false;
}

bool ResourceSet::acquire()
{
    return false;
}

bool ResourceSet::release()
{
    return false;
}

bool ResourceSet::update()
{
    return false;
}

QString ResourceSet::applicationClass()
{
    return this->resourceClass;
}