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