← Back to branch summary

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

« back to all changes in this revision

Viewing changes to OpenDRIM_AccountCapabilities/OpenDRIM_AccountCapabilities.h

  • 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_AccountCapabilities/OpenDRIM_AccountCapabilities.h
 
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
#ifndef OPENDRIM_ACCOUNTCAPABILITIES_H_
 
33
#define OPENDRIM_ACCOUNTCAPABILITIES_H_
 
34
 
 
35
#include <Instance.h>
 
36
 
 
37
const static char* OpenDRIM_AccountCapabilities_classnames[] = {"OpenDRIM_AccountCapabilities"};
 
38
static string OpenDRIM_AccountCapabilities_NAMESPACE = _NAMESPACE;
 
39
 
 
40
class OpenDRIM_AccountCapabilities {
 
41
 
 
42
public:
 
43
        
 
44
        string Caption;
 
45
        bool Caption_isNULL;
 
46
        
 
47
        string Description;
 
48
        bool Description_isNULL;
 
49
        
 
50
        string InstanceID;
 
51
        bool InstanceID_isNULL;
 
52
        
 
53
        string ElementName;
 
54
        bool ElementName_isNULL;
 
55
        
 
56
        unsigned short MaxElementNameLen;
 
57
        bool MaxElementNameLen_isNULL;
 
58
        
 
59
        vector<unsigned short> RequestedStatesSupported;
 
60
        bool RequestedStatesSupported_isNULL;
 
61
        
 
62
        string ElementNameMask;
 
63
        bool ElementNameMask_isNULL;
 
64
        
 
65
        vector<unsigned short> StateAwareness;
 
66
        bool StateAwareness_isNULL;
 
67
        
 
68
        unsigned short PasswordHistory;
 
69
        bool PasswordHistory_isNULL;
 
70
        
 
71
        string MaximumPasswordAge;
 
72
        bool MaximumPasswordAge_isNULL;
 
73
        
 
74
        vector<unsigned short> ComplexPasswordRulesSupported;
 
75
        bool ComplexPasswordRulesSupported_isNULL;
 
76
        
 
77
        bool DisableOnInactivity;
 
78
        bool DisableOnInactivity_isNULL;
 
79
        
 
80
        vector<unsigned short> RequestedStateSupported;
 
81
        bool RequestedStateSupported_isNULL;
 
82
        
 
83
        bool ElementNameEditSupported;
 
84
        bool ElementNameEditSupported_isNULL;
 
85
        
 
86
        string DisableTimeoutAfterPasswordExpiration;
 
87
        bool DisableTimeoutAfterPasswordExpiration_isNULL;
 
88
        
 
89
        OpenDRIM_AccountCapabilities() {
 
90
                Caption_isNULL = true;
 
91
                Description_isNULL = true;
 
92
                InstanceID_isNULL = true;
 
93
                ElementName_isNULL = true;
 
94
                MaxElementNameLen_isNULL = true;
 
95
                RequestedStatesSupported_isNULL = true;
 
96
                ElementNameMask_isNULL = true;
 
97
                StateAwareness_isNULL = true;
 
98
                PasswordHistory_isNULL = true;
 
99
                MaximumPasswordAge_isNULL = true;
 
100
                ComplexPasswordRulesSupported_isNULL = true;
 
101
                DisableOnInactivity_isNULL = true;
 
102
                RequestedStateSupported_isNULL = true;
 
103
                ElementNameEditSupported_isNULL = true;
 
104
                DisableTimeoutAfterPasswordExpiration_isNULL = true;
 
105
        }
 
106
        
 
107
        ~OpenDRIM_AccountCapabilities() {}
 
108
        
 
109
        string getKeys() const {
 
110
                return CF_toLowCase(".InstanceID=\"" + CF_quoteString(InstanceID) + "\"");
 
111
        }
 
112
 
 
113
        int getCaption(string& value) const {
 
114
                if (Caption_isNULL==true)
 
115
                        return NOT_FOUND;
 
116
                value = Caption;
 
117
                return OK;
 
118
        }
 
119
        
 
120
        int setCaption(const string& newValue) {
 
121
                Caption = newValue;
 
122
                Caption_isNULL = false;
 
123
                return OK;
 
124
        }
 
125
 
 
126
        int getDescription(string& value) const {
 
127
                if (Description_isNULL==true)
 
128
                        return NOT_FOUND;
 
129
                value = Description;
 
130
                return OK;
 
131
        }
 
132
        
 
133
        int setDescription(const string& newValue) {
 
134
                Description = newValue;
 
135
                Description_isNULL = false;
 
136
                return OK;
 
137
        }
 
138
 
 
139
        int getInstanceID(string& value) const {
 
140
                if (InstanceID_isNULL==true)
 
141
                        return NOT_FOUND;
 
142
                value = InstanceID;
 
143
                return OK;
 
144
        }
 
145
        
 
146
        int setInstanceID(const string& newValue) {
 
147
                InstanceID = newValue;
 
148
                InstanceID_isNULL = false;
 
149
                return OK;
 
150
        }
 
151
 
 
152
        int getElementName(string& value) const {
 
153
                if (ElementName_isNULL==true)
 
154
                        return NOT_FOUND;
 
155
                value = ElementName;
 
156
                return OK;
 
157
        }
 
158
        
 
159
        int setElementName(const string& newValue) {
 
160
                ElementName = newValue;
 
161
                ElementName_isNULL = false;
 
162
                return OK;
 
163
        }
 
164
 
 
165
        int getMaxElementNameLen(unsigned short& value) const {
 
166
                if (MaxElementNameLen_isNULL==true)
 
167
                        return NOT_FOUND;
 
168
                value = MaxElementNameLen;
 
169
                return OK;
 
170
        }
 
171
        
 
172
        int setMaxElementNameLen(const unsigned short& newValue) {
 
173
                MaxElementNameLen = newValue;
 
174
                MaxElementNameLen_isNULL = false;
 
175
                return OK;
 
176
        }
 
177
 
 
178
        int getRequestedStatesSupported(vector<unsigned short>& value) const {
 
179
                if (RequestedStatesSupported_isNULL==true)
 
180
                        return NOT_FOUND;
 
181
                value = RequestedStatesSupported;
 
182
                return OK;
 
183
        }
 
184
        
 
185
        int setRequestedStatesSupported(const vector<unsigned short>& newValue) {
 
186
                RequestedStatesSupported = newValue;
 
187
                RequestedStatesSupported_isNULL = false;
 
188
                return OK;
 
189
        }
 
190
 
 
191
        int getElementNameMask(string& value) const {
 
192
                if (ElementNameMask_isNULL==true)
 
193
                        return NOT_FOUND;
 
194
                value = ElementNameMask;
 
195
                return OK;
 
196
        }
 
197
        
 
198
        int setElementNameMask(const string& newValue) {
 
199
                ElementNameMask = newValue;
 
200
                ElementNameMask_isNULL = false;
 
201
                return OK;
 
202
        }
 
203
 
 
204
        int getStateAwareness(vector<unsigned short>& value) const {
 
205
                if (StateAwareness_isNULL==true)
 
206
                        return NOT_FOUND;
 
207
                value = StateAwareness;
 
208
                return OK;
 
209
        }
 
210
        
 
211
        int setStateAwareness(const vector<unsigned short>& newValue) {
 
212
                StateAwareness = newValue;
 
213
                StateAwareness_isNULL = false;
 
214
                return OK;
 
215
        }
 
216
 
 
217
        int getPasswordHistory(unsigned short& value) const {
 
218
                if (PasswordHistory_isNULL==true)
 
219
                        return NOT_FOUND;
 
220
                value = PasswordHistory;
 
221
                return OK;
 
222
        }
 
223
        
 
224
        int setPasswordHistory(const unsigned short& newValue) {
 
225
                PasswordHistory = newValue;
 
226
                PasswordHistory_isNULL = false;
 
227
                return OK;
 
228
        }
 
229
 
 
230
        int getMaximumPasswordAge(string& value) const {
 
231
                if (MaximumPasswordAge_isNULL==true)
 
232
                        return NOT_FOUND;
 
233
                value = MaximumPasswordAge;
 
234
                return OK;
 
235
        }
 
236
        
 
237
        int setMaximumPasswordAge(const string& newValue) {
 
238
                MaximumPasswordAge = newValue;
 
239
                MaximumPasswordAge_isNULL = false;
 
240
                return OK;
 
241
        }
 
242
 
 
243
        int getComplexPasswordRulesSupported(vector<unsigned short>& value) const {
 
244
                if (ComplexPasswordRulesSupported_isNULL==true)
 
245
                        return NOT_FOUND;
 
246
                value = ComplexPasswordRulesSupported;
 
247
                return OK;
 
248
        }
 
249
        
 
250
        int setComplexPasswordRulesSupported(const vector<unsigned short>& newValue) {
 
251
                ComplexPasswordRulesSupported = newValue;
 
252
                ComplexPasswordRulesSupported_isNULL = false;
 
253
                return OK;
 
254
        }
 
255
 
 
256
        int getDisableOnInactivity(bool& value) const {
 
257
                if (DisableOnInactivity_isNULL==true)
 
258
                        return NOT_FOUND;
 
259
                value = DisableOnInactivity;
 
260
                return OK;
 
261
        }
 
262
        
 
263
        int setDisableOnInactivity(const bool& newValue) {
 
264
                DisableOnInactivity = newValue;
 
265
                DisableOnInactivity_isNULL = false;
 
266
                return OK;
 
267
        }
 
268
 
 
269
        int getRequestedStateSupported(vector<unsigned short>& value) const {
 
270
                if (RequestedStateSupported_isNULL==true)
 
271
                        return NOT_FOUND;
 
272
                value = RequestedStateSupported;
 
273
                return OK;
 
274
        }
 
275
        
 
276
        int setRequestedStateSupported(const vector<unsigned short>& newValue) {
 
277
                RequestedStateSupported = newValue;
 
278
                RequestedStateSupported_isNULL = false;
 
279
                return OK;
 
280
        }
 
281
 
 
282
        int getElementNameEditSupported(bool& value) const {
 
283
                if (ElementNameEditSupported_isNULL==true)
 
284
                        return NOT_FOUND;
 
285
                value = ElementNameEditSupported;
 
286
                return OK;
 
287
        }
 
288
        
 
289
        int setElementNameEditSupported(const bool& newValue) {
 
290
                ElementNameEditSupported = newValue;
 
291
                ElementNameEditSupported_isNULL = false;
 
292
                return OK;
 
293
        }
 
294
 
 
295
        int getDisableTimeoutAfterPasswordExpiration(string& value) const {
 
296
                if (DisableTimeoutAfterPasswordExpiration_isNULL==true)
 
297
                        return NOT_FOUND;
 
298
                value = DisableTimeoutAfterPasswordExpiration;
 
299
                return OK;
 
300
        }
 
301
        
 
302
        int setDisableTimeoutAfterPasswordExpiration(const string& newValue) {
 
303
                DisableTimeoutAfterPasswordExpiration = newValue;
 
304
                DisableTimeoutAfterPasswordExpiration_isNULL = false;
 
305
                return OK;
 
306
        }
 
307
 
 
308
};
 
309
 
 
310
class OpenDRIM_AccountCapabilities_CreateGoalSettings_In {
 
311
 
 
312
public:
 
313
 
 
314
        vector<string> TemplateGoalSettings;
 
315
        bool TemplateGoalSettings_isNULL;
 
316
 
 
317
        vector<string> SupportedGoalSettings;
 
318
        bool SupportedGoalSettings_isNULL;
 
319
 
 
320
        OpenDRIM_AccountCapabilities_CreateGoalSettings_In() {
 
321
                TemplateGoalSettings_isNULL = true;
 
322
                SupportedGoalSettings_isNULL = true;
 
323
        }
 
324
 
 
325
        ~OpenDRIM_AccountCapabilities_CreateGoalSettings_In() {}
 
326
 
 
327
        int getTemplateGoalSettings(vector<string>& value) const {
 
328
                if (TemplateGoalSettings_isNULL == true)
 
329
                        return NOT_FOUND;
 
330
                value = TemplateGoalSettings;
 
331
                return OK;
 
332
        }
 
333
        int setTemplateGoalSettings(const vector<string>&  newValue) {
 
334
                TemplateGoalSettings = newValue;
 
335
                TemplateGoalSettings_isNULL = false;
 
336
                return OK;
 
337
        }
 
338
 
 
339
        int getSupportedGoalSettings(vector<string>& value) const {
 
340
                if (SupportedGoalSettings_isNULL == true)
 
341
                        return NOT_FOUND;
 
342
                value = SupportedGoalSettings;
 
343
                return OK;
 
344
        }
 
345
        int setSupportedGoalSettings(const vector<string>&  newValue) {
 
346
                SupportedGoalSettings = newValue;
 
347
                SupportedGoalSettings_isNULL = false;
 
348
                return OK;
 
349
        }
 
350
 
 
351
};
 
352
 
 
353
class OpenDRIM_AccountCapabilities_CreateGoalSettings_Out {
 
354
 
 
355
public:
 
356
 
 
357
        vector<string> SupportedGoalSettings;
 
358
        bool SupportedGoalSettings_isNULL;
 
359
 
 
360
        OpenDRIM_AccountCapabilities_CreateGoalSettings_Out() {
 
361
                SupportedGoalSettings_isNULL = true;
 
362
        }
 
363
 
 
364
        ~OpenDRIM_AccountCapabilities_CreateGoalSettings_Out() {}
 
365
 
 
366
        int getSupportedGoalSettings(vector<string>& value) const {
 
367
                if (SupportedGoalSettings_isNULL == true)
 
368
                        return NOT_FOUND;
 
369
                value = SupportedGoalSettings;
 
370
                return OK;
 
371
        }
 
372
        int setSupportedGoalSettings(const vector<string>&  newValue) {
 
373
                SupportedGoalSettings = newValue;
 
374
                SupportedGoalSettings_isNULL = false;
 
375
                return OK;
 
376
        }
 
377
 
 
378
};
 
379
 
 
380
#endif /*OPENDRIM_ACCOUNTCAPABILITIES_H_*/