← Back to branch summary

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

« back to all changes in this revision

Viewing changes to OpenDRIM_AccountAssignedIdentity/OpenDRIM_AccountAssignedIdentityAccess.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_AccountAssignedIdentity/OpenDRIM_AccountAssignedIdentityAccess.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_AccountAssignedIdentityAccess.h"
 
33
 
 
34
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_load(const CMPIBroker* broker, string& errorMessage) {
 
35
        _E_;
 
36
        /*
 
37
         * for Direct Invocation
 
38
         */
 
39
        /*
 
40
        CF_assert(Simple_Identity_Management_CIM_Identity_load(broker, errorMessage));
 
41
        CF_assert(Simple_Identity_Management_CIM_ManagedElement_load(broker, errorMessage));
 
42
        */
 
43
        // TODO
 
44
        _L_;
 
45
        return OK;
 
46
}
 
47
 
 
48
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_unload(string& errorMessage) {
 
49
        _E_;
 
50
        /*
 
51
         * for Direct Invocation
 
52
         */
 
53
        /*
 
54
        CF_assert(Simple_Identity_Management_CIM_Identity_unload(errorMessage));
 
55
        CF_assert(Simple_Identity_Management_CIM_ManagedElement_unload(errorMessage));
 
56
        */
 
57
        // TODO
 
58
        _L_;
 
59
        return OK;
 
60
}
 
61
 
 
62
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_isAssociated(const Instance& IdentityInfo, const Instance& ManagedElement, 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_AccountAssignedIdentity_retrieve(const CMPIBroker* broker, const CMPIContext* ctx, vector<OpenDRIM_AccountAssignedIdentity>& 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_AccountAssignedIdentity_enumerateIdentityInfos(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_AccountAssignedIdentity_enumerateIdentityInfos(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_AccountAssignedIdentity_associator(broker, ctx,
 
87
                        (*c).getObjectpath().getHdl(), (*c),
 
88
                        IdentityInfo_classnames[0], ManagedElement_classnames[0],
 
89
                        IdentityInfo_role.c_str(), ManagedElement_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_AccountAssignedIdentity_referenceIdentityInfoToManagedElement(broker, ctx, (*c), associatedInstances, result, NULL, errorMessage, ref_discriminant));
 
94
        }
 
95
        _L_;
 
96
        return OK;
 
97
}
 
98
 
 
99
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_getInstance(const CMPIBroker* broker, const CMPIContext* ctx, OpenDRIM_AccountAssignedIdentity& 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 IdentityInfo_objectpath;
 
106
        instance.getIdentityInfo(IdentityInfo_objectpath);
 
107
        Instance IdentityInfo_instance;
 
108
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_getIdentityInfo(broker, ctx, IdentityInfo_objectpath, IdentityInfo_instance, NULL, errorMessage));
 
109
        
 
110
        Objectpath ManagedElement_objectpath;
 
111
        instance.getManagedElement(ManagedElement_objectpath);
 
112
        Instance ManagedElement_instance;
 
113
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_getManagedElement(broker, ctx, ManagedElement_objectpath, ManagedElement_instance, NULL, errorMessage));
 
114
 
 
115
        bool isAssociated = false;
 
116
        CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_isAssociated(IdentityInfo_instance, ManagedElement_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_AccountAssignedIdentity_setInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountAssignedIdentity& newInstance, const OpenDRIM_AccountAssignedIdentity& oldInstance, const char** properties, string& errorMessage) {
 
129
        _E_;
 
130
        // TODO
 
131
        _L_;
 
132
        return NOT_SUPPORTED;
 
133
}
 
134
 
 
135
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_createInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountAssignedIdentity& instance, string& errorMessage) {
 
136
        _E_;
 
137
        // TODO
 
138
        _L_;
 
139
        return NOT_SUPPORTED;
 
140
}
 
141
 
 
142
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_deleteInstance(const CMPIBroker* broker, const CMPIContext* ctx, const OpenDRIM_AccountAssignedIdentity& instance, string& errorMessage) {
 
143
        _E_;
 
144
        // TODO
 
145
        _L_;
 
146
        return NOT_SUPPORTED;
 
147
}
 
148
 
 
149
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_associatorIdentityInfoToManagedElement(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& IdentityInfo_instance, const char** properties, vector<Instance>& ManagedElement_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> ManagedElement_instances;
 
156
        if (discriminant=="a")
 
157
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_enumerateManagedElements(broker, ctx, ManagedElement_instances, properties, false, errorMessage));
 
158
        if (discriminant=="an") {
 
159
                // Only get the instance names
 
160
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_enumerateManagedElements(broker, ctx, ManagedElement_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_AccountAssignedIdentity_enumerateManagedElements(broker, ctx, ManagedElement_instances, properties, false, errorMessage));
 
163
        }
 
164
 
 
165
        for (size_t i=0; i<ManagedElement_instances.size(); i++) {
 
166
                bool isAssociated = false;
 
167
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_isAssociated(IdentityInfo_instance, ManagedElement_instances[i], isAssociated, errorMessage));
 
168
                if (isAssociated)
 
169
                        ManagedElement_associatedInstances.push_back(ManagedElement_instances[i]);
 
170
        }
 
171
        _L_;
 
172
        return OK;
 
173
}
 
174
 
 
175
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_associatorManagedElementToIdentityInfo(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& ManagedElement_instance, const char** properties, vector<Instance>& IdentityInfo_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> IdentityInfo_instances;
 
182
        if (discriminant=="a")
 
183
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_enumerateIdentityInfos(broker, ctx, IdentityInfo_instances, properties, false, errorMessage));
 
184
        if (discriminant=="an") {
 
185
                // Only get the instance names
 
186
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_enumerateIdentityInfos(broker, ctx, IdentityInfo_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_AccountAssignedIdentity_enumerateIdentityInfos(broker, ctx, IdentityInfo_instances, properties, false, errorMessage));
 
189
        }
 
190
 
 
191
        for (size_t i=0; i<IdentityInfo_instances.size(); i++) {
 
192
                bool isAssociated = false;
 
193
                CF_assert(Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_isAssociated(IdentityInfo_instances[i], ManagedElement_instance, isAssociated, errorMessage));
 
194
                if (isAssociated)
 
195
                        IdentityInfo_associatedInstances.push_back(IdentityInfo_instances[i]);
 
196
        }
 
197
        _L_;
 
198
        return OK;
 
199
}
 
200
 
 
201
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_referenceIdentityInfoToManagedElement(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& IdentityInfo_instance, const vector<Instance>& ManagedElement_instances, vector<OpenDRIM_AccountAssignedIdentity>& OpenDRIM_AccountAssignedIdentity_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 < ManagedElement_instances.size(); i++) {
 
208
                OpenDRIM_AccountAssignedIdentity instance;
 
209
                instance.setIdentityInfo(((Instance) IdentityInfo_instance).getObjectpath());
 
210
                instance.setManagedElement(((Instance) ManagedElement_instances[i]).getObjectpath());
 
211
                
 
212
                OpenDRIM_AccountAssignedIdentity_instances.push_back(instance);
 
213
        }
 
214
        _L_;
 
215
        return OK;
 
216
}
 
217
 
 
218
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_referenceManagedElementToIdentityInfo(const CMPIBroker* broker, const CMPIContext* ctx, const Instance& ManagedElement_instance, const vector<Instance>& IdentityInfo_instances, vector<OpenDRIM_AccountAssignedIdentity>& OpenDRIM_AccountAssignedIdentity_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 < IdentityInfo_instances.size(); i++) {
 
225
                OpenDRIM_AccountAssignedIdentity instance;
 
226
                instance.setIdentityInfo(((Instance) IdentityInfo_instances[i]).getObjectpath());
 
227
                instance.setManagedElement(((Instance) ManagedElement_instance).getObjectpath());
 
228
                
 
229
                OpenDRIM_AccountAssignedIdentity_instances.push_back(instance);
 
230
        }
 
231
        _L_;
 
232
        return OK;
 
233
}
 
234
 
 
235
int Simple_Identity_Management_OpenDRIM_AccountAssignedIdentity_populate(OpenDRIM_AccountAssignedIdentity& instance, string& errorMessage) {
 
236
        _E_;
 
237
        // TODO
 
238
        _L_;
 
239
        return OK;
 
240
}
 
241