← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/opendrim-lmp-ssh/oneiric

« back to all changes in this revision

Viewing changes to OpenDRIM_SSHProtocolService/OpenDRIM_SSHProtocolService.h

  • Committer: Bazaar Package Importer
  • Author(s): Guillaume BOTTEX
  • Date: 2010-07-07 11:04:10 UTC
  • Revision ID: james.westby@ubuntu.com-20100707110410-2bojrtqjp582wiy8
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

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