← Back to branch summary

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

« back to all changes in this revision

Viewing changes to OpenDRIM_AccountManagementService/OpenDRIM_AccountManagementService.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_AccountManagementService/OpenDRIM_AccountManagementService.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_ACCOUNTMANAGEMENTSERVICE_H_
 
33
#define OPENDRIM_ACCOUNTMANAGEMENTSERVICE_H_
 
34
 
 
35
#include <Instance.h>
 
36
 
 
37
const static char* OpenDRIM_AccountManagementService_classnames[] = {"OpenDRIM_AccountManagementService"};
 
38
static string OpenDRIM_AccountManagementService_NAMESPACE = _NAMESPACE;
 
39
 
 
40
class OpenDRIM_AccountManagementService {
 
41
 
 
42
public:
 
43
        
 
44
        string Caption;
 
45
        bool Caption_isNULL;
 
46
        
 
47
        string Description;
 
48
        bool Description_isNULL;
 
49
        
 
50
        string ElementName;
 
51
        bool ElementName_isNULL;
 
52
        
 
53
        string InstallDate;
 
54
        bool InstallDate_isNULL;
 
55
        
 
56
        vector<unsigned short> OperationalStatus;
 
57
        bool OperationalStatus_isNULL;
 
58
        
 
59
        vector<string> StatusDescriptions;
 
60
        bool StatusDescriptions_isNULL;
 
61
        
 
62
        string Status;
 
63
        bool Status_isNULL;
 
64
        
 
65
        unsigned short HealthState;
 
66
        bool HealthState_isNULL;
 
67
        
 
68
        unsigned short PrimaryStatus;
 
69
        bool PrimaryStatus_isNULL;
 
70
        
 
71
        unsigned short DetailedStatus;
 
72
        bool DetailedStatus_isNULL;
 
73
        
 
74
        unsigned short OperatingStatus;
 
75
        bool OperatingStatus_isNULL;
 
76
        
 
77
        unsigned short CommunicationStatus;
 
78
        bool CommunicationStatus_isNULL;
 
79
        
 
80
        unsigned short EnabledState;
 
81
        bool EnabledState_isNULL;
 
82
        
 
83
        string OtherEnabledState;
 
84
        bool OtherEnabledState_isNULL;
 
85
        
 
86
        unsigned short RequestedState;
 
87
        bool RequestedState_isNULL;
 
88
        
 
89
        unsigned short EnabledDefault;
 
90
        bool EnabledDefault_isNULL;
 
91
        
 
92
        string TimeOfLastStateChange;
 
93
        bool TimeOfLastStateChange_isNULL;
 
94
        
 
95
        vector<unsigned short> AvailableRequestedStates;
 
96
        bool AvailableRequestedStates_isNULL;
 
97
        
 
98
        unsigned short TransitioningToState;
 
99
        bool TransitioningToState_isNULL;
 
100
        
 
101
        string SystemCreationClassName;
 
102
        bool SystemCreationClassName_isNULL;
 
103
        
 
104
        string SystemName;
 
105
        bool SystemName_isNULL;
 
106
        
 
107
        string CreationClassName;
 
108
        bool CreationClassName_isNULL;
 
109
        
 
110
        string Name;
 
111
        bool Name_isNULL;
 
112
        
 
113
        string PrimaryOwnerName;
 
114
        bool PrimaryOwnerName_isNULL;
 
115
        
 
116
        string PrimaryOwnerContact;
 
117
        bool PrimaryOwnerContact_isNULL;
 
118
        
 
119
        string StartMode;
 
120
        bool StartMode_isNULL;
 
121
        
 
122
        bool Started;
 
123
        bool Started_isNULL;
 
124
        
 
125
        OpenDRIM_AccountManagementService() {
 
126
                Caption_isNULL = true;
 
127
                Description_isNULL = true;
 
128
                ElementName_isNULL = true;
 
129
                InstallDate_isNULL = true;
 
130
                OperationalStatus_isNULL = true;
 
131
                StatusDescriptions_isNULL = true;
 
132
                Status_isNULL = true;
 
133
                HealthState_isNULL = true;
 
134
                PrimaryStatus_isNULL = true;
 
135
                DetailedStatus_isNULL = true;
 
136
                OperatingStatus_isNULL = true;
 
137
                CommunicationStatus_isNULL = true;
 
138
                EnabledState_isNULL = true;
 
139
                OtherEnabledState_isNULL = true;
 
140
                RequestedState_isNULL = true;
 
141
                EnabledDefault_isNULL = true;
 
142
                TimeOfLastStateChange_isNULL = true;
 
143
                AvailableRequestedStates_isNULL = true;
 
144
                TransitioningToState_isNULL = true;
 
145
                SystemCreationClassName_isNULL = true;
 
146
                SystemName_isNULL = true;
 
147
                CreationClassName_isNULL = true;
 
148
                Name_isNULL = true;
 
149
                PrimaryOwnerName_isNULL = true;
 
150
                PrimaryOwnerContact_isNULL = true;
 
151
                StartMode_isNULL = true;
 
152
                Started_isNULL = true;
 
153
        }
 
154
        
 
155
        ~OpenDRIM_AccountManagementService() {}
 
156
        
 
157
        string getKeys() const {
 
158
                return CF_toLowCase(".SystemCreationClassName=\"" + CF_quoteString(SystemCreationClassName) + "\""".SystemName=\"" + CF_quoteString(SystemName) + "\""".CreationClassName=\"" + CF_quoteString(CreationClassName) + "\""".Name=\"" + CF_quoteString(Name) + "\"");
 
159
        }
 
160
 
 
161
        int getCaption(string& value) const {
 
162
                if (Caption_isNULL==true)
 
163
                        return NOT_FOUND;
 
164
                value = Caption;
 
165
                return OK;
 
166
        }
 
167
        
 
168
        int setCaption(const string& newValue) {
 
169
                Caption = newValue;
 
170
                Caption_isNULL = false;
 
171
                return OK;
 
172
        }
 
173
 
 
174
        int getDescription(string& value) const {
 
175
                if (Description_isNULL==true)
 
176
                        return NOT_FOUND;
 
177
                value = Description;
 
178
                return OK;
 
179
        }
 
180
        
 
181
        int setDescription(const string& newValue) {
 
182
                Description = newValue;
 
183
                Description_isNULL = false;
 
184
                return OK;
 
185
        }
 
186
 
 
187
        int getElementName(string& value) const {
 
188
                if (ElementName_isNULL==true)
 
189
                        return NOT_FOUND;
 
190
                value = ElementName;
 
191
                return OK;
 
192
        }
 
193
        
 
194
        int setElementName(const string& newValue) {
 
195
                ElementName = newValue;
 
196
                ElementName_isNULL = false;
 
197
                return OK;
 
198
        }
 
199
 
 
200
        int getInstallDate(string& value) const {
 
201
                if (InstallDate_isNULL==true)
 
202
                        return NOT_FOUND;
 
203
                value = InstallDate;
 
204
                return OK;
 
205
        }
 
206
        
 
207
        int setInstallDate(const string& newValue) {
 
208
                InstallDate = newValue;
 
209
                InstallDate_isNULL = false;
 
210
                return OK;
 
211
        }
 
212
 
 
213
        int getOperationalStatus(vector<unsigned short>& value) const {
 
214
                if (OperationalStatus_isNULL==true)
 
215
                        return NOT_FOUND;
 
216
                value = OperationalStatus;
 
217
                return OK;
 
218
        }
 
219
        
 
220
        int setOperationalStatus(const vector<unsigned short>& newValue) {
 
221
                OperationalStatus = newValue;
 
222
                OperationalStatus_isNULL = false;
 
223
                return OK;
 
224
        }
 
225
 
 
226
        int getStatusDescriptions(vector<string>& value) const {
 
227
                if (StatusDescriptions_isNULL==true)
 
228
                        return NOT_FOUND;
 
229
                value = StatusDescriptions;
 
230
                return OK;
 
231
        }
 
232
        
 
233
        int setStatusDescriptions(const vector<string>& newValue) {
 
234
                StatusDescriptions = newValue;
 
235
                StatusDescriptions_isNULL = false;
 
236
                return OK;
 
237
        }
 
238
 
 
239
        int getStatus(string& value) const {
 
240
                if (Status_isNULL==true)
 
241
                        return NOT_FOUND;
 
242
                value = Status;
 
243
                return OK;
 
244
        }
 
245
        
 
246
        int setStatus(const string& newValue) {
 
247
                Status = newValue;
 
248
                Status_isNULL = false;
 
249
                return OK;
 
250
        }
 
251
 
 
252
        int getHealthState(unsigned short& value) const {
 
253
                if (HealthState_isNULL==true)
 
254
                        return NOT_FOUND;
 
255
                value = HealthState;
 
256
                return OK;
 
257
        }
 
258
        
 
259
        int setHealthState(const unsigned short& newValue) {
 
260
                HealthState = newValue;
 
261
                HealthState_isNULL = false;
 
262
                return OK;
 
263
        }
 
264
 
 
265
        int getPrimaryStatus(unsigned short& value) const {
 
266
                if (PrimaryStatus_isNULL==true)
 
267
                        return NOT_FOUND;
 
268
                value = PrimaryStatus;
 
269
                return OK;
 
270
        }
 
271
        
 
272
        int setPrimaryStatus(const unsigned short& newValue) {
 
273
                PrimaryStatus = newValue;
 
274
                PrimaryStatus_isNULL = false;
 
275
                return OK;
 
276
        }
 
277
 
 
278
        int getDetailedStatus(unsigned short& value) const {
 
279
                if (DetailedStatus_isNULL==true)
 
280
                        return NOT_FOUND;
 
281
                value = DetailedStatus;
 
282
                return OK;
 
283
        }
 
284
        
 
285
        int setDetailedStatus(const unsigned short& newValue) {
 
286
                DetailedStatus = newValue;
 
287
                DetailedStatus_isNULL = false;
 
288
                return OK;
 
289
        }
 
290
 
 
291
        int getOperatingStatus(unsigned short& value) const {
 
292
                if (OperatingStatus_isNULL==true)
 
293
                        return NOT_FOUND;
 
294
                value = OperatingStatus;
 
295
                return OK;
 
296
        }
 
297
        
 
298
        int setOperatingStatus(const unsigned short& newValue) {
 
299
                OperatingStatus = newValue;
 
300
                OperatingStatus_isNULL = false;
 
301
                return OK;
 
302
        }
 
303
 
 
304
        int getCommunicationStatus(unsigned short& value) const {
 
305
                if (CommunicationStatus_isNULL==true)
 
306
                        return NOT_FOUND;
 
307
                value = CommunicationStatus;
 
308
                return OK;
 
309
        }
 
310
        
 
311
        int setCommunicationStatus(const unsigned short& newValue) {
 
312
                CommunicationStatus = newValue;
 
313
                CommunicationStatus_isNULL = false;
 
314
                return OK;
 
315
        }
 
316
 
 
317
        int getEnabledState(unsigned short& value) const {
 
318
                if (EnabledState_isNULL==true)
 
319
                        return NOT_FOUND;
 
320
                value = EnabledState;
 
321
                return OK;
 
322
        }
 
323
        
 
324
        int setEnabledState(const unsigned short& newValue) {
 
325
                EnabledState = newValue;
 
326
                EnabledState_isNULL = false;
 
327
                return OK;
 
328
        }
 
329
 
 
330
        int getOtherEnabledState(string& value) const {
 
331
                if (OtherEnabledState_isNULL==true)
 
332
                        return NOT_FOUND;
 
333
                value = OtherEnabledState;
 
334
                return OK;
 
335
        }
 
336
        
 
337
        int setOtherEnabledState(const string& newValue) {
 
338
                OtherEnabledState = newValue;
 
339
                OtherEnabledState_isNULL = false;
 
340
                return OK;
 
341
        }
 
342
 
 
343
        int getRequestedState(unsigned short& value) const {
 
344
                if (RequestedState_isNULL==true)
 
345
                        return NOT_FOUND;
 
346
                value = RequestedState;
 
347
                return OK;
 
348
        }
 
349
        
 
350
        int setRequestedState(const unsigned short& newValue) {
 
351
                RequestedState = newValue;
 
352
                RequestedState_isNULL = false;
 
353
                return OK;
 
354
        }
 
355
 
 
356
        int getEnabledDefault(unsigned short& value) const {
 
357
                if (EnabledDefault_isNULL==true)
 
358
                        return NOT_FOUND;
 
359
                value = EnabledDefault;
 
360
                return OK;
 
361
        }
 
362
        
 
363
        int setEnabledDefault(const unsigned short& newValue) {
 
364
                EnabledDefault = newValue;
 
365
                EnabledDefault_isNULL = false;
 
366
                return OK;
 
367
        }
 
368
 
 
369
        int getTimeOfLastStateChange(string& value) const {
 
370
                if (TimeOfLastStateChange_isNULL==true)
 
371
                        return NOT_FOUND;
 
372
                value = TimeOfLastStateChange;
 
373
                return OK;
 
374
        }
 
375
        
 
376
        int setTimeOfLastStateChange(const string& newValue) {
 
377
                TimeOfLastStateChange = newValue;
 
378
                TimeOfLastStateChange_isNULL = false;
 
379
                return OK;
 
380
        }
 
381
 
 
382
        int getAvailableRequestedStates(vector<unsigned short>& value) const {
 
383
                if (AvailableRequestedStates_isNULL==true)
 
384
                        return NOT_FOUND;
 
385
                value = AvailableRequestedStates;
 
386
                return OK;
 
387
        }
 
388
        
 
389
        int setAvailableRequestedStates(const vector<unsigned short>& newValue) {
 
390
                AvailableRequestedStates = newValue;
 
391
                AvailableRequestedStates_isNULL = false;
 
392
                return OK;
 
393
        }
 
394
 
 
395
        int getTransitioningToState(unsigned short& value) const {
 
396
                if (TransitioningToState_isNULL==true)
 
397
                        return NOT_FOUND;
 
398
                value = TransitioningToState;
 
399
                return OK;
 
400
        }
 
401
        
 
402
        int setTransitioningToState(const unsigned short& newValue) {
 
403
                TransitioningToState = newValue;
 
404
                TransitioningToState_isNULL = false;
 
405
                return OK;
 
406
        }
 
407
 
 
408
        int getSystemCreationClassName(string& value) const {
 
409
                if (SystemCreationClassName_isNULL==true)
 
410
                        return NOT_FOUND;
 
411
                value = SystemCreationClassName;
 
412
                return OK;
 
413
        }
 
414
        
 
415
        int setSystemCreationClassName(const string& newValue) {
 
416
                SystemCreationClassName = newValue;
 
417
                SystemCreationClassName_isNULL = false;
 
418
                return OK;
 
419
        }
 
420
 
 
421
        int getSystemName(string& value) const {
 
422
                if (SystemName_isNULL==true)
 
423
                        return NOT_FOUND;
 
424
                value = SystemName;
 
425
                return OK;
 
426
        }
 
427
        
 
428
        int setSystemName(const string& newValue) {
 
429
                SystemName = newValue;
 
430
                SystemName_isNULL = false;
 
431
                return OK;
 
432
        }
 
433
 
 
434
        int getCreationClassName(string& value) const {
 
435
                if (CreationClassName_isNULL==true)
 
436
                        return NOT_FOUND;
 
437
                value = CreationClassName;
 
438
                return OK;
 
439
        }
 
440
        
 
441
        int setCreationClassName(const string& newValue) {
 
442
                CreationClassName = newValue;
 
443
                CreationClassName_isNULL = false;
 
444
                return OK;
 
445
        }
 
446
 
 
447
        int getName(string& value) const {
 
448
                if (Name_isNULL==true)
 
449
                        return NOT_FOUND;
 
450
                value = Name;
 
451
                return OK;
 
452
        }
 
453
        
 
454
        int setName(const string& newValue) {
 
455
                Name = newValue;
 
456
                Name_isNULL = false;
 
457
                return OK;
 
458
        }
 
459
 
 
460
        int getPrimaryOwnerName(string& value) const {
 
461
                if (PrimaryOwnerName_isNULL==true)
 
462
                        return NOT_FOUND;
 
463
                value = PrimaryOwnerName;
 
464
                return OK;
 
465
        }
 
466
        
 
467
        int setPrimaryOwnerName(const string& newValue) {
 
468
                PrimaryOwnerName = newValue;
 
469
                PrimaryOwnerName_isNULL = false;
 
470
                return OK;
 
471
        }
 
472
 
 
473
        int getPrimaryOwnerContact(string& value) const {
 
474
                if (PrimaryOwnerContact_isNULL==true)
 
475
                        return NOT_FOUND;
 
476
                value = PrimaryOwnerContact;
 
477
                return OK;
 
478
        }
 
479
        
 
480
        int setPrimaryOwnerContact(const string& newValue) {
 
481
                PrimaryOwnerContact = newValue;
 
482
                PrimaryOwnerContact_isNULL = false;
 
483
                return OK;
 
484
        }
 
485
 
 
486
        int getStartMode(string& value) const {
 
487
                if (StartMode_isNULL==true)
 
488
                        return NOT_FOUND;
 
489
                value = StartMode;
 
490
                return OK;
 
491
        }
 
492
        
 
493
        int setStartMode(const string& newValue) {
 
494
                StartMode = newValue;
 
495
                StartMode_isNULL = false;
 
496
                return OK;
 
497
        }
 
498
 
 
499
        int getStarted(bool& value) const {
 
500
                if (Started_isNULL==true)
 
501
                        return NOT_FOUND;
 
502
                value = Started;
 
503
                return OK;
 
504
        }
 
505
        
 
506
        int setStarted(const bool& newValue) {
 
507
                Started = newValue;
 
508
                Started_isNULL = false;
 
509
                return OK;
 
510
        }
 
511
 
 
512
};
 
513
 
 
514
class OpenDRIM_AccountManagementService_RequestStateChange_In {
 
515
 
 
516
public:
 
517
 
 
518
        unsigned short RequestedState;
 
519
        bool RequestedState_isNULL;
 
520
 
 
521
        Objectpath Job;
 
522
        bool Job_isNULL;
 
523
 
 
524
        string TimeoutPeriod;
 
525
        bool TimeoutPeriod_isNULL;
 
526
 
 
527
        OpenDRIM_AccountManagementService_RequestStateChange_In() {
 
528
                RequestedState_isNULL = true;
 
529
                Job_isNULL = true;
 
530
                TimeoutPeriod_isNULL = true;
 
531
        }
 
532
 
 
533
        ~OpenDRIM_AccountManagementService_RequestStateChange_In() {}
 
534
 
 
535
        int getRequestedState(unsigned short& value) const {
 
536
                if (RequestedState_isNULL == true)
 
537
                        return NOT_FOUND;
 
538
                value = RequestedState;
 
539
                return OK;
 
540
        }
 
541
        int setRequestedState(const unsigned short&  newValue) {
 
542
                RequestedState = newValue;
 
543
                RequestedState_isNULL = false;
 
544
                return OK;
 
545
        }
 
546
 
 
547
        int getJob(Objectpath& value) const {
 
548
                if (Job_isNULL == true)
 
549
                        return NOT_FOUND;
 
550
                value = Job;
 
551
                return OK;
 
552
        }
 
553
        int setJob(const Objectpath&  newValue) {
 
554
                Job = newValue;
 
555
                Job_isNULL = false;
 
556
                return OK;
 
557
        }
 
558
 
 
559
        int getTimeoutPeriod(string& value) const {
 
560
                if (TimeoutPeriod_isNULL == true)
 
561
                        return NOT_FOUND;
 
562
                value = TimeoutPeriod;
 
563
                return OK;
 
564
        }
 
565
        int setTimeoutPeriod(const string&  newValue) {
 
566
                TimeoutPeriod = newValue;
 
567
                TimeoutPeriod_isNULL = false;
 
568
                return OK;
 
569
        }
 
570
 
 
571
};
 
572
 
 
573
class OpenDRIM_AccountManagementService_RequestStateChange_Out {
 
574
 
 
575
public:
 
576
 
 
577
        Objectpath Job;
 
578
        bool Job_isNULL;
 
579
 
 
580
        OpenDRIM_AccountManagementService_RequestStateChange_Out() {
 
581
                Job_isNULL = true;
 
582
        }
 
583
 
 
584
        ~OpenDRIM_AccountManagementService_RequestStateChange_Out() {}
 
585
 
 
586
        int getJob(Objectpath& value) const {
 
587
                if (Job_isNULL == true)
 
588
                        return NOT_FOUND;
 
589
                value = Job;
 
590
                return OK;
 
591
        }
 
592
        int setJob(const Objectpath&  newValue) {
 
593
                Job = newValue;
 
594
                Job_isNULL = false;
 
595
                return OK;
 
596
        }
 
597
 
 
598
};
 
599
 
 
600
class OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_In {
 
601
 
 
602
public:
 
603
 
 
604
        vector<Objectpath> ManagedElements;
 
605
        bool ManagedElements_isNULL;
 
606
 
 
607
        vector<unsigned short> AssignedSequence;
 
608
        bool AssignedSequence_isNULL;
 
609
 
 
610
        Objectpath Job;
 
611
        bool Job_isNULL;
 
612
 
 
613
        OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_In() {
 
614
                ManagedElements_isNULL = true;
 
615
                AssignedSequence_isNULL = true;
 
616
                Job_isNULL = true;
 
617
        }
 
618
 
 
619
        ~OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_In() {}
 
620
 
 
621
        int getManagedElements(vector<Objectpath>& value) const {
 
622
                if (ManagedElements_isNULL == true)
 
623
                        return NOT_FOUND;
 
624
                value = ManagedElements;
 
625
                return OK;
 
626
        }
 
627
        int setManagedElements(const vector<Objectpath>&  newValue) {
 
628
                ManagedElements = newValue;
 
629
                ManagedElements_isNULL = false;
 
630
                return OK;
 
631
        }
 
632
 
 
633
        int getAssignedSequence(vector<unsigned short>& value) const {
 
634
                if (AssignedSequence_isNULL == true)
 
635
                        return NOT_FOUND;
 
636
                value = AssignedSequence;
 
637
                return OK;
 
638
        }
 
639
        int setAssignedSequence(const vector<unsigned short>&  newValue) {
 
640
                AssignedSequence = newValue;
 
641
                AssignedSequence_isNULL = false;
 
642
                return OK;
 
643
        }
 
644
 
 
645
        int getJob(Objectpath& value) const {
 
646
                if (Job_isNULL == true)
 
647
                        return NOT_FOUND;
 
648
                value = Job;
 
649
                return OK;
 
650
        }
 
651
        int setJob(const Objectpath&  newValue) {
 
652
                Job = newValue;
 
653
                Job_isNULL = false;
 
654
                return OK;
 
655
        }
 
656
 
 
657
};
 
658
 
 
659
class OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_Out {
 
660
 
 
661
public:
 
662
 
 
663
        Objectpath Job;
 
664
        bool Job_isNULL;
 
665
 
 
666
        OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_Out() {
 
667
                Job_isNULL = true;
 
668
        }
 
669
 
 
670
        ~OpenDRIM_AccountManagementService_ChangeAffectedElementsAssignedSequence_Out() {}
 
671
 
 
672
        int getJob(Objectpath& value) const {
 
673
                if (Job_isNULL == true)
 
674
                        return NOT_FOUND;
 
675
                value = Job;
 
676
                return OK;
 
677
        }
 
678
        int setJob(const Objectpath&  newValue) {
 
679
                Job = newValue;
 
680
                Job_isNULL = false;
 
681
                return OK;
 
682
        }
 
683
 
 
684
};
 
685
 
 
686
class OpenDRIM_AccountManagementService_CreateAccount_In {
 
687
 
 
688
public:
 
689
 
 
690
        Objectpath System;
 
691
        bool System_isNULL;
 
692
 
 
693
        string AccountTemplate;
 
694
        bool AccountTemplate_isNULL;
 
695
 
 
696
        Objectpath Account;
 
697
        bool Account_isNULL;
 
698
 
 
699
        vector<Objectpath> Identities;
 
700
        bool Identities_isNULL;
 
701
 
 
702
        OpenDRIM_AccountManagementService_CreateAccount_In() {
 
703
                System_isNULL = true;
 
704
                AccountTemplate_isNULL = true;
 
705
                Account_isNULL = true;
 
706
                Identities_isNULL = true;
 
707
        }
 
708
 
 
709
        ~OpenDRIM_AccountManagementService_CreateAccount_In() {}
 
710
 
 
711
        int getSystem(Objectpath& value) const {
 
712
                if (System_isNULL == true)
 
713
                        return NOT_FOUND;
 
714
                value = System;
 
715
                return OK;
 
716
        }
 
717
        int setSystem(const Objectpath&  newValue) {
 
718
                System = newValue;
 
719
                System_isNULL = false;
 
720
                return OK;
 
721
        }
 
722
 
 
723
        int getAccountTemplate(string& value) const {
 
724
                if (AccountTemplate_isNULL == true)
 
725
                        return NOT_FOUND;
 
726
                value = AccountTemplate;
 
727
                return OK;
 
728
        }
 
729
        int setAccountTemplate(const string&  newValue) {
 
730
                AccountTemplate = newValue;
 
731
                AccountTemplate_isNULL = false;
 
732
                return OK;
 
733
        }
 
734
 
 
735
        int getAccount(Objectpath& value) const {
 
736
                if (Account_isNULL == true)
 
737
                        return NOT_FOUND;
 
738
                value = Account;
 
739
                return OK;
 
740
        }
 
741
        int setAccount(const Objectpath&  newValue) {
 
742
                Account = newValue;
 
743
                Account_isNULL = false;
 
744
                return OK;
 
745
        }
 
746
 
 
747
        int getIdentities(vector<Objectpath>& value) const {
 
748
                if (Identities_isNULL == true)
 
749
                        return NOT_FOUND;
 
750
                value = Identities;
 
751
                return OK;
 
752
        }
 
753
        int setIdentities(const vector<Objectpath>&  newValue) {
 
754
                Identities = newValue;
 
755
                Identities_isNULL = false;
 
756
                return OK;
 
757
        }
 
758
 
 
759
};
 
760
 
 
761
class OpenDRIM_AccountManagementService_CreateAccount_Out {
 
762
 
 
763
public:
 
764
 
 
765
        Objectpath Account;
 
766
        bool Account_isNULL;
 
767
 
 
768
        vector<Objectpath> Identities;
 
769
        bool Identities_isNULL;
 
770
 
 
771
        OpenDRIM_AccountManagementService_CreateAccount_Out() {
 
772
                Account_isNULL = true;
 
773
                Identities_isNULL = true;
 
774
        }
 
775
 
 
776
        ~OpenDRIM_AccountManagementService_CreateAccount_Out() {}
 
777
 
 
778
        int getAccount(Objectpath& value) const {
 
779
                if (Account_isNULL == true)
 
780
                        return NOT_FOUND;
 
781
                value = Account;
 
782
                return OK;
 
783
        }
 
784
        int setAccount(const Objectpath&  newValue) {
 
785
                Account = newValue;
 
786
                Account_isNULL = false;
 
787
                return OK;
 
788
        }
 
789
 
 
790
        int getIdentities(vector<Objectpath>& value) const {
 
791
                if (Identities_isNULL == true)
 
792
                        return NOT_FOUND;
 
793
                value = Identities;
 
794
                return OK;
 
795
        }
 
796
        int setIdentities(const vector<Objectpath>&  newValue) {
 
797
                Identities = newValue;
 
798
                Identities_isNULL = false;
 
799
                return OK;
 
800
        }
 
801
 
 
802
};
 
803
 
 
804
#endif /*OPENDRIM_ACCOUNTMANAGEMENTSERVICE_H_*/