← Back to branch summary

~ubuntu-branches/ubuntu/quantal/opendrim-lmp-simpleidentitymanagement/quantal

« back to all changes in this revision

Viewing changes to OpenDRIM_AccountOnSystem/OpenDRIM_AccountOnSystemAccess.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Guillaume BOTTEX
  • Date: 2010-06-21 15:54:00 UTC
  • Revision ID: james.westby@ubuntu.com-20100621155400-myesv5hd2f3s8x9y
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
OpenDRIM_AccountOnSystem/OpenDRIM_AccountOnSystemAccess.cpp
 
1
/*################################################################################
 
2
# Linux Management Providers (LMP), Simple Identity Management provider package
 
3
# Copyright (C) 2007 Frederic Desmons, ETRI <desmons@etri.re.kr, desmons_frederic@yahoo.fr>
 
4
# 
 
5
# This program is being developed under the "OpenDRIM" project.
 
6
# The "OpenDRIM" project web page: http://opendrim.sourceforge.net
 
7
# The "OpenDRIM" project mailing list: opendrim@googlegroups.com
 
8
# 
 
9
# This program is free software; you can redistribute it and/or
 
10
# modify it under the terms of the GNU General Public License
 
11
# as published by the Free Software Foundation; version 2
 
12
# of the License.
 
13
# 
 
14
# This program is distributed in the hope that it will be useful,
 
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
# GNU General Public License for more details.
 
18
# 
 
19
# You should have received a copy of the GNU General Public License
 
20
# along with this program; if not, write to the Free Software
 
21
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
22
#################################################################################
 
23
 
 
24
#################################################################################
 
25
# To contributors, please leave your contact information in this section
 
26
# AND comment your changes in the source code.
 
27
# 
 
28
# Modified by 2009 Khahramon NURIDDINOV, TUIT <qahramon0786@gmail.com>
 
29
# Modified by 2009 Guillaume BOTTEX, ETRI <guillaumebottex@etri.re.kr>
 
30
################################################################################*/
 
31
 
 
32
#include "OpenDRIM_AccountOnSystemAccess.h"
 
33
 
 
34
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_load(const CMPIBroker* broker, string& errorMessage) {
 
35
        _E_;
 
36
        /*
 
37
         * for Direct Invocation
 
38
         */
 
39
        /*
 
40
        CF_assert(Simple_Identity_Management_CIM_Account_load(broker, errorMessage));
 
41
        CF_assert(Simple_Identity_Management_CIM_System_load(broker, errorMessage));
 
42
        */
 
43
        // TODO
 
44
        _L_;
 
45
        return OK;
 
46
}
 
47
 
 
48
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_unload(string& errorMessage) {
 
49
        _E_;
 
50
        /*
 
51
         * for Direct Invocation
 
52
         */
 
53
        /*
 
54
        CF_assert(Simple_Identity_Management_CIM_Account_unload(errorMessage));
 
55
        CF_assert(Simple_Identity_Management_CIM_System_unload(errorMessage));
 
56
        */
 
57
        // TODO
 
58
        _L_;
 
59
        return OK;
 
60
}
 
61
 
 
62
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_isAssociated(const Instance& PartComponent, const Instance& GroupComponent, bool& isAssociated, string& errorMessage) {
 
63
        _E_;
 
64
        // TODO Determine if the association can be established or not
 
65
        isAssociated=true;
 
66
        _L_;
 
67
        return OK;
 
68
}
 
69
 
 
70
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_retrieve(const CMPIBroker* broker, const CMPIContext* ctx, vector<OpenDRIM_AccountOnSystem>& result, const char** properties, string& errorMessage, const string& discriminant) {
 
71
        _E_;
 
72
        /*
 
73
         * The following code has been generated for your convenience.
 
74
         * Feel free to modify/delete.
 
75
         */
 
76
        vector<Instance> subjects;
 
77
        // Only get the instance names
 
78
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumeratePartComponents(broker, ctx, subjects, NULL, true, errorMessage));
 
79
        // OR get the full instances IF we need the content of the instance to evaluate the association condition OR to set the reference properties
 
80
        // CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumeratePartComponents(broker, ctx, subjects, NULL, false, errorMessage));
 
81
        vector<Instance>::iterator c = subjects.begin();
 
82
        vector<Instance>::iterator end = subjects.end();
 
83
        for (; c != end; ++c) {
 
84
                bool leftToRight = true;
 
85
                vector<Instance> associatedInstances;
 
86
                Simple_Identity_Management_OpenDRIM_AccountOnSystem_associator(broker, ctx,
 
87
                        (*c).getObjectpath().getHdl(), (*c),
 
88
                        PartComponent_classnames[0], GroupComponent_classnames[0],
 
89
                        PartComponent_role.c_str(), GroupComponent_role.c_str(), NULL,
 
90
                        associatedInstances, leftToRight, errorMessage, "an");
 
91
 
 
92
                string ref_discriminant = discriminant == "ein" ? "rn" : "r";
 
93
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_referencePartComponentToGroupComponent(broker, ctx, (*c), associatedInstances, result, NULL, errorMessage, ref_discriminant));
 
94
        }
 
95
        _L_;
 
96
        return OK;
 
97
}
 
98
 
 
99
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_getInstance(const CMPIBroker* broker, const CMPIContext* ctx, OpenDRIM_AccountOnSystem& instance, const char** properties, string& errorMessage) {
 
100
        _E_;
 
101
        /*
 
102
         * The following code has been generated for your convenience.
 
103
         * Feel free to modify/delete.
 
104
         */
 
105
        Objectpath PartComponent_objectpath;
 
106
        instance.getPartComponent(PartComponent_objectpath);
 
107
        Instance PartComponent_instance;
 
108
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_getPartComponent(broker, ctx, PartComponent_objectpath, PartComponent_instance, NULL, errorMessage));
 
109
        
 
110
        Objectpath GroupComponent_objectpath;
 
111
        instance.getGroupComponent(GroupComponent_objectpath);
 
112
        Instance GroupComponent_instance;
 
113
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_getGroupComponent(broker, ctx, GroupComponent_objectpath, GroupComponent_instance, NULL, errorMessage));
 
114
 
 
115
        bool isAssociated = false;
 
116
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_isAssociated(PartComponent_instance, GroupComponent_instance, isAssociated, errorMessage));
 
117
        if (!isAssociated)
 
118
        {
 
119
                if(errorMessage.empty())
 
120
                        errorMessage = "No instance";
 
121
                
 
122
                return NOT_FOUND;
 
123
        }
 
124
        _L_;
 
125
        return OK;
 
126
}
 
127
 
 
128
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_setInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountOnSystem& newInstance, const OpenDRIM_AccountOnSystem& oldInstance, const char** properties, string& errorMessage) {
 
129
        _E_;
 
130
        // TODO
 
131
        _L_;
 
132
        return NOT_SUPPORTED;
 
133
}
 
134
 
 
135
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_createInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountOnSystem& instance, string& errorMessage) {
 
136
        _E_;
 
137
        // TODO
 
138
        _L_;
 
139
        return NOT_SUPPORTED;
 
140
}
 
141
 
 
142
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_deleteInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountOnSystem& instance, string& errorMessage) {
 
143
        _E_;
 
144
        // TODO
 
145
        _L_;
 
146
        return NOT_SUPPORTED;
 
147
}
 
148
 
 
149
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_associatorPartComponentToGroupComponent(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& PartComponent_instance, const char** properties, vector<Instance>& GroupComponent_associatedInstances, string& errorMessage, const string& discriminant) {
 
150
        _E_;
 
151
        /*
 
152
         * The following code has been generated for your convenience.
 
153
         * Feel free to modify/delete.
 
154
         */
 
155
        vector<Instance> GroupComponent_instances;
 
156
        if (discriminant=="a")
 
157
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumerateGroupComponents(broker, ctx, GroupComponent_instances, properties, false, errorMessage));
 
158
        if (discriminant=="an") {
 
159
                // Only get the instance names
 
160
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumerateGroupComponents(broker, ctx, GroupComponent_instances, properties, true, errorMessage));
 
161
                // OR get the full instances IF we need the content of the instance to evaluate the association condition OR to set the reference properties
 
162
                // CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumerateGroupComponents(broker, ctx, GroupComponent_instances, properties, false, errorMessage));
 
163
        }
 
164
 
 
165
        for (size_t i=0; i<GroupComponent_instances.size(); i++) {
 
166
                bool isAssociated = false;
 
167
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_isAssociated(PartComponent_instance, GroupComponent_instances[i], isAssociated, errorMessage));
 
168
                if (isAssociated)
 
169
                        GroupComponent_associatedInstances.push_back(GroupComponent_instances[i]);
 
170
        }
 
171
        _L_;
 
172
        return OK;
 
173
}
 
174
 
 
175
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_associatorGroupComponentToPartComponent(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& GroupComponent_instance, const char** properties, vector<Instance>& PartComponent_associatedInstances, string& errorMessage, const string& discriminant) {
 
176
        _E_;
 
177
        /*
 
178
         * The following code has been generated for your convenience.
 
179
         * Feel free to modify/delete.
 
180
         */
 
181
        vector<Instance> PartComponent_instances;
 
182
        if (discriminant=="a")
 
183
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumeratePartComponents(broker, ctx, PartComponent_instances, properties, false, errorMessage));
 
184
        if (discriminant=="an") {
 
185
                // Only get the instance names
 
186
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumeratePartComponents(broker, ctx, PartComponent_instances, properties, true, errorMessage));
 
187
                // OR get the full instances IF we need the content of the instance to evaluate the association condition OR to set the reference properties
 
188
                // CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_enumeratePartComponents(broker, ctx, PartComponent_instances, properties, false, errorMessage));
 
189
        }
 
190
 
 
191
        for (size_t i=0; i<PartComponent_instances.size(); i++) {
 
192
                bool isAssociated = false;
 
193
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountOnSystem_isAssociated(PartComponent_instances[i], GroupComponent_instance, isAssociated, errorMessage));
 
194
                if (isAssociated)
 
195
                        PartComponent_associatedInstances.push_back(PartComponent_instances[i]);
 
196
        }
 
197
        _L_;
 
198
        return OK;
 
199
}
 
200
 
 
201
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_referencePartComponentToGroupComponent(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& PartComponent_instance, const vector<Instance>& GroupComponent_instances, vector<OpenDRIM_AccountOnSystem>& OpenDRIM_AccountOnSystem_instances, const char** properties, string& errorMessage, const string& discriminant) {
 
202
        _E_;
 
203
        /*
 
204
         * The following code has been generated for your convenience.
 
205
         * Feel free to modify/delete.
 
206
         */
 
207
        for (size_t i=0; i < GroupComponent_instances.size(); i++) {
 
208
                OpenDRIM_AccountOnSystem instance;
 
209
                instance.setPartComponent(((Instance) PartComponent_instance).getObjectpath());
 
210
                instance.setGroupComponent(((Instance) GroupComponent_instances[i]).getObjectpath());
 
211
                
 
212
                OpenDRIM_AccountOnSystem_instances.push_back(instance);
 
213
        }
 
214
        _L_;
 
215
        return OK;
 
216
}
 
217
 
 
218
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_referenceGroupComponentToPartComponent(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& GroupComponent_instance, const vector<Instance>& PartComponent_instances, vector<OpenDRIM_AccountOnSystem>& OpenDRIM_AccountOnSystem_instances, const char** properties, string& errorMessage, const string& discriminant) {
 
219
        _E_;
 
220
        /*
 
221
         * The following code has been generated for your convenience.
 
222
         * Feel free to modify/delete.
 
223
         */
 
224
        for (size_t i=0; i < PartComponent_instances.size(); i++) {
 
225
                OpenDRIM_AccountOnSystem instance;
 
226
                instance.setPartComponent(((Instance) PartComponent_instances[i]).getObjectpath());
 
227
                instance.setGroupComponent(((Instance) GroupComponent_instance).getObjectpath());
 
228
                
 
229
                OpenDRIM_AccountOnSystem_instances.push_back(instance);
 
230
        }
 
231
        _L_;
 
232
        return OK;
 
233
}
 
234
 
 
235
int Simple_Identity_Management_OpenDRIM_AccountOnSystem_populate(OpenDRIM_AccountOnSystem& instance, string& errorMessage) {
 
236
        _E_;
 
237
        // TODO
 
238
        _L_;
 
239
        return OK;
 
240
}
 
241