1 karl 1.26 //%2004////////////////////////////////////////////////////////////////////////
|
2 mike 1.2 //
|
3 karl 1.26 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.22 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.26 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 mike 1.2 //
10 // Permission is hereby granted, free of charge, to any person obtaining a copy
11 // of this software and associated documentation files (the "Software"), to
12 // deal in the Software without restriction, including without limitation the
13 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
14 // sell copies of the Software, and to permit persons to whom the Software is
15 // furnished to do so, subject to the following conditions:
|
16 kumpf 1.8 //
|
17 mike 1.2 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
18 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
19 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
20 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
21 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 //
26 //==============================================================================
27 //
28 // Author: Chip Vincent (cvincent@us.ibm.com)
29 //
|
30 kumpf 1.11 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
31 kumpf 1.15 // Carol Ann Krug Graves, Hewlett-Packard Company
32 // (carolann_graves@hp.com)
|
33 kumpf 1.20 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
|
34 kumpf 1.24 // Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)
|
35 mike 1.2 //
36 //%/////////////////////////////////////////////////////////////////////////////
37
38 #include "OperationContext.h"
|
39 kumpf 1.10 #include "ArrayInternal.h"
|
40 humberto 1.19 #include <Pegasus/Common/MessageLoader.h> //l10n
|
41 mike 1.2
42 PEGASUS_NAMESPACE_BEGIN
43
|
44 chip 1.5 //
45 // OperationContext
46 //
|
47 kumpf 1.11
|
48 kumpf 1.7 class OperationContextRep
49 {
50 public:
51 Array<OperationContext::Container *> containers;
52 };
53
|
54 chip 1.3 OperationContext::OperationContext(void)
|
55 mike 1.2 {
|
56 kumpf 1.7 _rep = new OperationContextRep;
|
57 mike 1.2 }
58
|
59 chip 1.4 OperationContext::OperationContext(const OperationContext & context)
60 {
|
61 kumpf 1.7 _rep = new OperationContextRep;
|
62 chip 1.6 *this = context;
|
63 chip 1.4 }
64
|
65 chip 1.3 OperationContext::~OperationContext(void)
66 {
|
67 chip 1.5 clear();
|
68 kumpf 1.7 delete _rep;
|
69 chip 1.5 }
70
71 OperationContext & OperationContext::operator=(const OperationContext & context)
72 {
73 if(this == &context)
74 {
75 return(*this);
76 }
77
78 clear();
79
|
80 kumpf 1.7 for(Uint32 i = 0, n = context._rep->containers.size(); i < n; i++)
|
81 chip 1.5 {
|
82 kumpf 1.7 _rep->containers.append(context._rep->containers[i]->clone());
|
83 chip 1.5 }
84
85 return(*this);
|
86 chip 1.3 }
87
88 void OperationContext::clear(void)
89 {
|
90 kumpf 1.7 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
|
91 chip 1.5 {
|
92 kumpf 1.11 _rep->containers[i]->destroy();
|
93 chip 1.5 }
94
|
95 kumpf 1.7 _rep->containers.clear();
|
96 chip 1.3 }
97
|
98 kumpf 1.11 const OperationContext::Container & OperationContext::get(
99 const String& containerName) const
100 {
101 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
102 {
103 if(containerName == _rep->containers[i]->getName())
104 {
105 Container * p = _rep->containers[i];
106
107 return(*p);
108 }
109 }
110
|
111 humberto 1.19 //l10n
112 MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
113 "object not found");
114 throw Exception(parms);
115 //throw Exception("object not found");
|
116 kumpf 1.11 }
117
|
118 chip 1.3 void OperationContext::set(const OperationContext::Container & container)
119 {
|
120 kumpf 1.7 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
|
121 chip 1.3 {
|
122 kumpf 1.11 if(container.getName() == _rep->containers[i]->getName())
|
123 chip 1.3 {
124 // delete previous container
|
125 kumpf 1.11 _rep->containers[i]->destroy();
|
126 kumpf 1.7 _rep->containers.remove(i);
|
127 chip 1.3
128 // append current container
|
129 kumpf 1.7 _rep->containers.append(container.clone());
|
130 chip 1.3
131 return;
132 }
133 }
134
|
135 humberto 1.19 //l10n
136 MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
137 "object not found");
138 throw Exception(parms);
139 //throw Exception("object not found");
|
140 chip 1.3 }
141
142 void OperationContext::insert(const OperationContext::Container & container)
143 {
|
144 kumpf 1.7 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
|
145 chip 1.3 {
|
146 kumpf 1.11 if(container.getName() == _rep->containers[i]->getName())
|
147 chip 1.3 {
|
148 humberto 1.19 //l10n
149 MessageLoaderParms parms("Common.OperationContext.OBJECT_ALREADY_EXISTS",
150 "object already exists.");
151 throw Exception(parms);
152 //throw Exception("object already exists.");
|
153 chip 1.3 }
154 }
155
|
156 kumpf 1.7 _rep->containers.append(container.clone());
|
157 chip 1.3 }
158
|
159 kumpf 1.11 void OperationContext::remove(const String& containerName)
160 {
161 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
162 {
163 if(containerName == _rep->containers[i]->getName())
164 {
165 _rep->containers[i]->destroy();
166 _rep->containers.remove(i);
167
168 return;
169 }
170 }
171
|
172 humberto 1.19 //l10n
173 MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
174 "object not found");
175 throw Exception(parms);
176 //throw Exception("object not found");
|
177 kumpf 1.11 }
|
178 humberto 1.19
|
179 chip 1.3
|
180 chip 1.5 //
181 // OperationContext::Container
182 //
|
183 kumpf 1.11
|
184 chip 1.3 OperationContext::Container::~Container(void)
185 {
186 }
187
|
188 chip 1.5
189 //
|
190 kumpf 1.7 // IdentityContainer
|
191 chip 1.5 //
192
|
193 kumpf 1.11 class IdentityContainerRep
|
194 chip 1.3 {
|
195 kumpf 1.11 public:
196 String userName;
197 };
|
198 chip 1.3
|
199 kumpf 1.11 const String IdentityContainer::NAME = "IdentityContainer";
|
200 chip 1.5
|
201 kumpf 1.11 IdentityContainer::IdentityContainer(const OperationContext::Container & container)
|
202 chip 1.5 {
|
203 kumpf 1.11 const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);
|
204 chip 1.5
205 if(p == 0)
206 {
|
207 kumpf 1.9 throw DynamicCastFailedException();
|
208 chip 1.5 }
209
|
210 kumpf 1.11 _rep = new IdentityContainerRep();
211 _rep->userName = p->_rep->userName;
|
212 mike 1.2 }
213
|
214 kumpf 1.16 IdentityContainer::IdentityContainer(const IdentityContainer & container)
215 {
216 _rep = new IdentityContainerRep();
217 _rep->userName = container._rep->userName;
218 }
219
|
220 kumpf 1.11 IdentityContainer::IdentityContainer(const String & userName)
|
221 chip 1.3 {
|
222 kumpf 1.11 _rep = new IdentityContainerRep();
223 _rep->userName = userName;
|
224 chip 1.3 }
225
|
226 kumpf 1.11 IdentityContainer::~IdentityContainer(void)
|
227 chip 1.5 {
|
228 kumpf 1.11 delete _rep;
|
229 kumpf 1.16 }
230
231 IdentityContainer & IdentityContainer::operator=(
232 const IdentityContainer & container)
233 {
234 if (this == &container)
235 {
236 return (*this);
237 }
238
239 _rep->userName = container._rep->userName;
240
241 return (*this);
|
242 chip 1.5 }
243
|
244 kumpf 1.11 String IdentityContainer::getName(void) const
|
245 chip 1.5 {
|
246 kumpf 1.11 return(NAME);
|
247 chip 1.5 }
248
|
249 kumpf 1.11 OperationContext::Container * IdentityContainer::clone(void) const
|
250 chip 1.5 {
|
251 kumpf 1.11 return(new IdentityContainer(_rep->userName));
|
252 chip 1.5 }
253
|
254 kumpf 1.11 void IdentityContainer::destroy(void)
|
255 chip 1.5 {
|
256 kumpf 1.11 delete this;
|
257 chip 1.5 }
258
|
259 kumpf 1.11 String IdentityContainer::getUserName(void) const
|
260 chip 1.3 {
|
261 kumpf 1.11 return(_rep->userName);
|
262 kumpf 1.15 }
263
|
264 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
265 IdentityContainer::IdentityContainer()
266 {
267 }
268
|
269 kumpf 1.15 //
270 // SubscriptionInstanceContainer
271 //
272
273 class SubscriptionInstanceContainerRep
274 {
275 public:
276 CIMInstance subscriptionInstance;
277 };
278
279 const String SubscriptionInstanceContainer::NAME =
280 "SubscriptionInstanceContainer";
281
282 SubscriptionInstanceContainer::SubscriptionInstanceContainer
283 (const OperationContext::Container & container)
284 {
285 const SubscriptionInstanceContainer * p =
286 dynamic_cast<const SubscriptionInstanceContainer *>(&container);
287
288 if(p == 0)
289 {
290 kumpf 1.15 throw DynamicCastFailedException();
291 }
292
293 _rep = new SubscriptionInstanceContainerRep();
294 _rep->subscriptionInstance = p->_rep->subscriptionInstance;
295 }
296
297 SubscriptionInstanceContainer::SubscriptionInstanceContainer
298 (const SubscriptionInstanceContainer & container)
299 {
300 _rep = new SubscriptionInstanceContainerRep();
301 _rep->subscriptionInstance = container._rep->subscriptionInstance;
302 }
303
304 SubscriptionInstanceContainer::SubscriptionInstanceContainer
305 (const CIMInstance & subscriptionInstance)
306 {
307 _rep = new SubscriptionInstanceContainerRep();
308 _rep->subscriptionInstance = subscriptionInstance;
309 }
310
311 kumpf 1.15 SubscriptionInstanceContainer::~SubscriptionInstanceContainer(void)
312 {
313 delete _rep;
314 }
315
316 SubscriptionInstanceContainer & SubscriptionInstanceContainer::operator=(
317 const SubscriptionInstanceContainer & container)
318 {
319 if (this == &container)
320 {
321 return (*this);
322 }
323
324 _rep->subscriptionInstance = container._rep->subscriptionInstance;
325
326 return (*this);
327 }
328
329 String SubscriptionInstanceContainer::getName(void) const
330 {
331 return(NAME);
332 kumpf 1.15 }
333
334 OperationContext::Container * SubscriptionInstanceContainer::clone(void) const
335 {
336 return(new SubscriptionInstanceContainer(_rep->subscriptionInstance));
337 }
338
339 void SubscriptionInstanceContainer::destroy(void)
340 {
341 delete this;
342 }
343
344 CIMInstance SubscriptionInstanceContainer::getInstance(void) const
345 {
346 return(_rep->subscriptionInstance);
347 }
348
|
349 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
350 SubscriptionInstanceContainer::SubscriptionInstanceContainer()
351 {
352 }
|
353 kumpf 1.15
354 //
355 // SubscriptionInstanceNamesContainer
356 //
357
358 class SubscriptionInstanceNamesContainerRep
359 {
360 public:
361 Array<CIMObjectPath> subscriptionInstanceNames;
362 };
363
364 const String SubscriptionInstanceNamesContainer::NAME =
365 "SubscriptionInstanceNamesContainer";
366
367 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
368 (const OperationContext::Container & container)
369 {
370 const SubscriptionInstanceNamesContainer * p =
371 dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);
372
373 if(p == 0)
374 kumpf 1.15 {
375 throw DynamicCastFailedException();
376 }
377
378 _rep = new SubscriptionInstanceNamesContainerRep();
379 _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
380 }
381
382 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
383 (const SubscriptionInstanceNamesContainer & container)
384 {
385 _rep = new SubscriptionInstanceNamesContainerRep();
386 _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
387 }
388
389 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
390 (const Array<CIMObjectPath> & subscriptionInstanceNames)
391 {
392 _rep = new SubscriptionInstanceNamesContainerRep();
393 _rep->subscriptionInstanceNames = subscriptionInstanceNames;
394 }
395 kumpf 1.15
396 SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer(void)
397 {
398 delete _rep;
399 }
400
401 SubscriptionInstanceNamesContainer &
402 SubscriptionInstanceNamesContainer::operator=(
403 const SubscriptionInstanceNamesContainer & container)
404 {
405 if (this == &container)
406 {
407 return (*this);
408 }
409
410 _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
411
412 return (*this);
413 }
414
415 String SubscriptionInstanceNamesContainer::getName(void) const
416 kumpf 1.15 {
417 return(NAME);
418 }
419
420 OperationContext::Container *
421 SubscriptionInstanceNamesContainer::clone(void) const
422 {
423 return(new SubscriptionInstanceNamesContainer
424 (_rep->subscriptionInstanceNames));
425 }
426
427 void SubscriptionInstanceNamesContainer::destroy(void)
428 {
429 delete this;
430 }
431
432 Array<CIMObjectPath>
433 SubscriptionInstanceNamesContainer::getInstanceNames(void) const
434 {
435 return(_rep->subscriptionInstanceNames);
436 }
437 kumpf 1.15
|
438 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
439 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer()
440 {
441 }
442
|
443 kumpf 1.15 //
444 // SubscriptionFilterConditionContainer
445 //
446
447 class SubscriptionFilterConditionContainerRep
448 {
449 public:
450 String filterCondition;
451 String queryLanguage;
452 };
453
454 const String SubscriptionFilterConditionContainer::NAME =
455 "SubscriptionFilterConditionContainer";
456
457 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
458 (const OperationContext::Container & container)
459 {
460 const SubscriptionFilterConditionContainer * p =
461 dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);
462
463 if(p == 0)
464 kumpf 1.15 {
465 throw DynamicCastFailedException();
466 }
467
468 _rep = new SubscriptionFilterConditionContainerRep();
469 _rep->filterCondition = p->_rep->filterCondition;
470 _rep->queryLanguage = p->_rep->queryLanguage;
471 }
472
473 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
474 (const SubscriptionFilterConditionContainer & container)
475 {
476 _rep = new SubscriptionFilterConditionContainerRep();
477 _rep->filterCondition = container._rep->filterCondition;
478 _rep->queryLanguage = container._rep->queryLanguage;
479 }
480
481 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
482 const String & filterCondition,
483 const String & queryLanguage)
484 {
485 kumpf 1.15 _rep = new SubscriptionFilterConditionContainerRep();
486 _rep->filterCondition = filterCondition;
487 _rep->queryLanguage = queryLanguage;
488 }
489
490 SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer
491 (void)
492 {
493 delete _rep;
494 }
495
496 SubscriptionFilterConditionContainer &
497 SubscriptionFilterConditionContainer::operator=(
498 const SubscriptionFilterConditionContainer & container)
499 {
500 if (this == &container)
501 {
502 return (*this);
503 }
504
505 _rep->filterCondition = container._rep->filterCondition;
506 kumpf 1.15 _rep->queryLanguage = container._rep->queryLanguage;
507
508 return (*this);
509 }
510
511 String SubscriptionFilterConditionContainer::getName(void) const
512 {
513 return(NAME);
514 }
515
516 OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const
517 {
518 return(new SubscriptionFilterConditionContainer(_rep->filterCondition,
519 _rep->queryLanguage));
520 }
521
522 void SubscriptionFilterConditionContainer::destroy(void)
523 {
524 delete this;
525 }
526
527 kumpf 1.15 String SubscriptionFilterConditionContainer::getFilterCondition(void) const
528 {
529 return(_rep->filterCondition);
530 }
531
532 String SubscriptionFilterConditionContainer::getQueryLanguage(void) const
533 {
534 return(_rep->queryLanguage);
|
535 chip 1.3 }
|
536 mike 1.2
|
537 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
538 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer()
539 {
540 }
541
542 //
543 // TimeoutContainer
544 //
|
545 mday 1.17
546 const String TimeoutContainer::NAME = "TimeoutContainer";
547
548 TimeoutContainer::TimeoutContainer(const OperationContext::Container & container)
549 {
550 const TimeoutContainer * p = dynamic_cast<const TimeoutContainer *>(&container);
551 if(p == 0)
552 {
553 throw DynamicCastFailedException();
554 }
555 _value = p->_value;
556 }
557
558 TimeoutContainer::TimeoutContainer(Uint32 timeout)
559 {
560 _value = timeout;
561 }
562
563 String TimeoutContainer::getName(void) const
564 {
565 return (NAME);
566 mday 1.17 }
567
568 OperationContext::Container * TimeoutContainer::clone(void) const
569 {
570 return (new TimeoutContainer(_value));
571 }
572
573 void TimeoutContainer::destroy(void)
574 {
575 delete this;
576 }
577
578 Uint32 TimeoutContainer::getTimeOut(void) const
579 {
580 return _value;
581 }
582
583
|
584 chuck 1.18 // l10n start
|
585 mday 1.17
|
586 chuck 1.18 //
587 // AcceptLanguageListContainer
588 //
|
589 mday 1.17
|
590 chuck 1.18 class AcceptLanguageListContainerRep
591 {
592 public:
593 AcceptLanguages languages;
594 };
595
596 const String AcceptLanguageListContainer::NAME =
597 "AcceptLanguageListContainer";
598
599 AcceptLanguageListContainer::AcceptLanguageListContainer
600 (const OperationContext::Container & container)
601 {
602 const AcceptLanguageListContainer * p =
603 dynamic_cast<const AcceptLanguageListContainer *>(&container);
604
605 if(p == 0)
606 {
607 throw DynamicCastFailedException();
608 }
609
610 _rep = new AcceptLanguageListContainerRep();
611 chuck 1.18 _rep->languages = p->_rep->languages;
612 }
613
614 AcceptLanguageListContainer::AcceptLanguageListContainer
615 (const AcceptLanguageListContainer & container)
616 {
617 _rep = new AcceptLanguageListContainerRep();
618 _rep->languages = container._rep->languages;
619 }
620
621 AcceptLanguageListContainer::AcceptLanguageListContainer
622 (const AcceptLanguages & languages)
623 {
624 _rep = new AcceptLanguageListContainerRep();
625 _rep->languages = languages;
626 }
627
628 AcceptLanguageListContainer::~AcceptLanguageListContainer(void)
629 {
630 delete _rep;
631 }
632 chuck 1.18
633 AcceptLanguageListContainer & AcceptLanguageListContainer::operator=(
634 const AcceptLanguageListContainer & container)
635 {
636 if (this == &container)
637 {
638 return (*this);
639 }
640
641 _rep->languages = container._rep->languages;
642
643 return (*this);
644 }
645
646 String AcceptLanguageListContainer::getName(void) const
647 {
648 return(NAME);
649 }
650
651 OperationContext::Container * AcceptLanguageListContainer::clone(void) const
652 {
653 chuck 1.18 return(new AcceptLanguageListContainer(_rep->languages));
654 }
655
656 void AcceptLanguageListContainer::destroy(void)
657 {
658 delete this;
659 }
660
661 AcceptLanguages AcceptLanguageListContainer::getLanguages(void) const
662 {
663 return(_rep->languages);
664 }
665
|
666 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
667 AcceptLanguageListContainer::AcceptLanguageListContainer()
668 {
669 }
670
|
671 chuck 1.18 //
672 // SubscriptionLanguageListContainer
673 //
674
|
675 chuck 1.21 class SubscriptionLanguageListContainerRep
676 {
677 public:
678 AcceptLanguages languages;
679 };
680
|
681 chuck 1.18 const String SubscriptionLanguageListContainer::NAME =
682 "SubscriptionLanguageListContainer";
683
|
684 chuck 1.21 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer
685 (const OperationContext::Container & container)
686 {
687 const SubscriptionLanguageListContainer * p =
688 dynamic_cast<const SubscriptionLanguageListContainer *>(&container);
689
690 if(p == 0)
691 {
692 throw DynamicCastFailedException();
693 }
694
695 _rep = new SubscriptionLanguageListContainerRep();
696 _rep->languages = p->_rep->languages;
697 }
698
699 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer
700 (const SubscriptionLanguageListContainer & container)
701 {
702 _rep = new SubscriptionLanguageListContainerRep();
703 _rep->languages = container._rep->languages;
704 }
705 chuck 1.21
706 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer
707 (const AcceptLanguages & languages)
708 {
709 _rep = new SubscriptionLanguageListContainerRep();
710 _rep->languages = languages;
711 }
712
713 SubscriptionLanguageListContainer::~SubscriptionLanguageListContainer(void)
714 {
715 delete _rep;
716 }
717
718 SubscriptionLanguageListContainer & SubscriptionLanguageListContainer::operator=(
719 const SubscriptionLanguageListContainer & container)
720 {
721 if (this == &container)
722 {
723 return (*this);
724 }
725
726 chuck 1.21 _rep->languages = container._rep->languages;
727
728 return (*this);
729 }
730
|
731 chuck 1.18 String SubscriptionLanguageListContainer::getName(void) const
732 {
733 return(NAME);
|
734 chuck 1.21 }
735
736 OperationContext::Container * SubscriptionLanguageListContainer::clone(void) const
737 {
738 return(new SubscriptionLanguageListContainer(_rep->languages));
739 }
740
741 void SubscriptionLanguageListContainer::destroy(void)
742 {
743 delete this;
744 }
745
746 AcceptLanguages SubscriptionLanguageListContainer::getLanguages(void) const
747 {
748 return(_rep->languages);
|
749 chuck 1.18 }
750
|
751 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
752 SubscriptionLanguageListContainer::SubscriptionLanguageListContainer()
753 {
754 }
755
|
756 chuck 1.18 //
757 // ContentLanguageListContainer
758 //
759
760 class ContentLanguageListContainerRep
761 {
762 public:
763 ContentLanguages languages;
764 };
765
766 const String ContentLanguageListContainer::NAME =
767 "ContentLanguageListContainer";
768
769 ContentLanguageListContainer::ContentLanguageListContainer
770 (const OperationContext::Container & container)
771 {
772 const ContentLanguageListContainer * p =
773 dynamic_cast<const ContentLanguageListContainer *>(&container);
774
775 if(p == 0)
776 {
777 chuck 1.18 throw DynamicCastFailedException();
778 }
779
780 _rep = new ContentLanguageListContainerRep();
781 _rep->languages = p->_rep->languages;
782 }
783
784 ContentLanguageListContainer::ContentLanguageListContainer
785 (const ContentLanguageListContainer & container)
786 {
787 _rep = new ContentLanguageListContainerRep();
788 _rep->languages = container._rep->languages;
789 }
790
791 ContentLanguageListContainer::ContentLanguageListContainer
792 (const ContentLanguages & languages)
793 {
794 _rep = new ContentLanguageListContainerRep();
795 _rep->languages = languages;
796 }
797
798 chuck 1.18 ContentLanguageListContainer::~ContentLanguageListContainer(void)
799 {
800 delete _rep;
801 }
802
803 ContentLanguageListContainer & ContentLanguageListContainer::operator=(
804 const ContentLanguageListContainer & container)
805 {
806 if (this == &container)
807 {
808 return (*this);
809 }
810
811 _rep->languages = container._rep->languages;
812
813 return (*this);
814 }
815
816 String ContentLanguageListContainer::getName(void) const
817 {
818 return(NAME);
819 chuck 1.18 }
820
821 OperationContext::Container * ContentLanguageListContainer::clone(void) const
822 {
823 return(new ContentLanguageListContainer(_rep->languages));
824 }
825
826 void ContentLanguageListContainer::destroy(void)
827 {
828 delete this;
829 }
830
831 ContentLanguages ContentLanguageListContainer::getLanguages(void) const
832 {
833 return(_rep->languages);
834 }
835
|
836 kumpf 1.24 // Unimplemented, hidden constructor not intended for actual use
837 ContentLanguageListContainer::ContentLanguageListContainer()
838 {
839 }
|
840 chuck 1.18
841 // l10n end
|
842 mday 1.17
|
843 kumpf 1.20 //
844 // SnmpTrapOidContainer
845 //
846
847 class SnmpTrapOidContainerRep
848 {
849 public:
850 String snmpTrapOid;
851 };
852
853 const String SnmpTrapOidContainer::NAME =
854 "SnmpTrapOidContainer";
855
856 SnmpTrapOidContainer::SnmpTrapOidContainer
857 (const OperationContext::Container & container)
858 {
859 const SnmpTrapOidContainer * p =
860 dynamic_cast<const SnmpTrapOidContainer *>(&container);
861
862 if(p == 0)
863 {
864 kumpf 1.20 throw DynamicCastFailedException();
865 }
866
867 _rep = new SnmpTrapOidContainerRep();
868 _rep->snmpTrapOid = p->_rep->snmpTrapOid;
869 }
870
871 SnmpTrapOidContainer::SnmpTrapOidContainer
872 (const SnmpTrapOidContainer & container)
873 {
874 _rep = new SnmpTrapOidContainerRep();
875 _rep->snmpTrapOid = container._rep->snmpTrapOid;
876 }
877
878 SnmpTrapOidContainer::SnmpTrapOidContainer
879 (const String & snmpTrapOid)
880 {
881 _rep = new SnmpTrapOidContainerRep();
882 _rep->snmpTrapOid = snmpTrapOid;
883 }
884
885 kumpf 1.20 SnmpTrapOidContainer::~SnmpTrapOidContainer(void)
886 {
887 delete _rep;
888 }
889
890 SnmpTrapOidContainer & SnmpTrapOidContainer::operator=(
891 const SnmpTrapOidContainer & container)
892 {
893 if (this == &container)
894 {
895 return (*this);
896 }
897
898 _rep->snmpTrapOid = container._rep->snmpTrapOid;
899
900 return (*this);
901 }
902
903 String SnmpTrapOidContainer::getName(void) const
904 {
905 return(NAME);
906 kumpf 1.20 }
907
908 OperationContext::Container * SnmpTrapOidContainer::clone(void) const
909 {
910 return(new SnmpTrapOidContainer(_rep->snmpTrapOid));
911 }
912
913 void SnmpTrapOidContainer::destroy(void)
914 {
915 delete this;
916 }
917
918 String SnmpTrapOidContainer::getSnmpTrapOid(void) const
919 {
920 return(_rep->snmpTrapOid);
921 }
|
922 kumpf 1.24
923 // Unimplemented, hidden constructor not intended for actual use
924 SnmpTrapOidContainer::SnmpTrapOidContainer()
925 {
926 }
927
|
928 mike 1.2 PEGASUS_NAMESPACE_END
|
Return to
OperationContext.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common