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 a.dunfey 1.38 Boolean OperationContext::contains(
119 const String& containerName) const
120 {
121 Uint32 size = _rep->containers.size();
122 Container** data = (Container**)_rep->containers.getData();
123
124 for (; size--; data++)
125 {
126 if (data[0]->getName() == containerName)
127 return true;
128 }
129
130 return false;
131 }
132
|
133 chip 1.3 void OperationContext::set(const OperationContext::Container & container)
134 {
|
135 kumpf 1.7 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
|
136 chip 1.3 {
|
137 kumpf 1.11 if(container.getName() == _rep->containers[i]->getName())
|
138 chip 1.3 {
139 // delete previous container
|
140 kumpf 1.11 _rep->containers[i]->destroy();
|
141 kumpf 1.7 _rep->containers.remove(i);
|
142 chip 1.3
143 // append current container
|
144 kumpf 1.7 _rep->containers.append(container.clone());
|
145 chip 1.3
146 return;
147 }
148 }
149
|
150 humberto 1.19 //l10n
151 MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
152 "object not found");
153 throw Exception(parms);
154 //throw Exception("object not found");
|
155 chip 1.3 }
156
157 void OperationContext::insert(const OperationContext::Container & container)
158 {
|
159 kumpf 1.7 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
|
160 chip 1.3 {
|
161 kumpf 1.11 if(container.getName() == _rep->containers[i]->getName())
|
162 chip 1.3 {
|
163 humberto 1.19 //l10n
164 MessageLoaderParms parms("Common.OperationContext.OBJECT_ALREADY_EXISTS",
165 "object already exists.");
166 throw Exception(parms);
167 //throw Exception("object already exists.");
|
168 chip 1.3 }
169 }
170
|
171 kumpf 1.7 _rep->containers.append(container.clone());
|
172 chip 1.3 }
173
|
174 kumpf 1.11 void OperationContext::remove(const String& containerName)
175 {
176 for(Uint32 i = 0, n = _rep->containers.size(); i < n; i++)
177 {
178 if(containerName == _rep->containers[i]->getName())
179 {
180 _rep->containers[i]->destroy();
181 _rep->containers.remove(i);
182
183 return;
184 }
185 }
186
|
187 humberto 1.19 //l10n
188 MessageLoaderParms parms("Common.OperationContext.OBJECT_NOT_FOUND",
189 "object not found");
190 throw Exception(parms);
191 //throw Exception("object not found");
|
192 kumpf 1.11 }
|
193 humberto 1.19
|
194 chip 1.3
|
195 chip 1.5 //
196 // OperationContext::Container
197 //
|
198 kumpf 1.11
|
199 chip 1.3 OperationContext::Container::~Container(void)
200 {
201 }
202
|
203 chip 1.5
204 //
|
205 kumpf 1.7 // IdentityContainer
|
206 chip 1.5 //
207
|
208 kumpf 1.11 class IdentityContainerRep
|
209 chip 1.3 {
|
210 kumpf 1.11 public:
211 String userName;
212 };
|
213 chip 1.3
|
214 kumpf 1.11 const String IdentityContainer::NAME = "IdentityContainer";
|
215 chip 1.5
|
216 kumpf 1.11 IdentityContainer::IdentityContainer(const OperationContext::Container & container)
|
217 chip 1.5 {
|
218 kumpf 1.11 const IdentityContainer * p = dynamic_cast<const IdentityContainer *>(&container);
|
219 chip 1.5
220 if(p == 0)
221 {
|
222 kumpf 1.9 throw DynamicCastFailedException();
|
223 chip 1.5 }
224
|
225 kumpf 1.11 _rep = new IdentityContainerRep();
226 _rep->userName = p->_rep->userName;
|
227 mike 1.2 }
228
|
229 kumpf 1.16 IdentityContainer::IdentityContainer(const IdentityContainer & container)
|
230 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined (PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
231 w.otsuka 1.31 : OperationContext::Container()
232 #endif
|
233 kumpf 1.16 {
234 _rep = new IdentityContainerRep();
235 _rep->userName = container._rep->userName;
236 }
237
|
238 kumpf 1.11 IdentityContainer::IdentityContainer(const String & userName)
|
239 chip 1.3 {
|
240 kumpf 1.11 _rep = new IdentityContainerRep();
241 _rep->userName = userName;
|
242 chip 1.3 }
243
|
244 kumpf 1.11 IdentityContainer::~IdentityContainer(void)
|
245 chip 1.5 {
|
246 kumpf 1.11 delete _rep;
|
247 kumpf 1.16 }
248
249 IdentityContainer & IdentityContainer::operator=(
250 const IdentityContainer & container)
251 {
252 if (this == &container)
253 {
254 return (*this);
255 }
256
257 _rep->userName = container._rep->userName;
258
259 return (*this);
|
260 chip 1.5 }
261
|
262 kumpf 1.11 String IdentityContainer::getName(void) const
|
263 chip 1.5 {
|
264 kumpf 1.11 return(NAME);
|
265 chip 1.5 }
266
|
267 kumpf 1.11 OperationContext::Container * IdentityContainer::clone(void) const
|
268 chip 1.5 {
|
269 kumpf 1.11 return(new IdentityContainer(_rep->userName));
|
270 chip 1.5 }
271
|
272 kumpf 1.11 void IdentityContainer::destroy(void)
|
273 chip 1.5 {
|
274 kumpf 1.11 delete this;
|
275 chip 1.5 }
276
|
277 kumpf 1.11 String IdentityContainer::getUserName(void) const
|
278 chip 1.3 {
|
279 kumpf 1.11 return(_rep->userName);
|
280 kumpf 1.15 }
281
|
282 kumpf 1.24
|
283 kumpf 1.15 //
284 // SubscriptionInstanceContainer
285 //
286
287 class SubscriptionInstanceContainerRep
288 {
289 public:
290 CIMInstance subscriptionInstance;
291 };
292
293 const String SubscriptionInstanceContainer::NAME =
294 "SubscriptionInstanceContainer";
295
296 SubscriptionInstanceContainer::SubscriptionInstanceContainer
297 (const OperationContext::Container & container)
298 {
299 const SubscriptionInstanceContainer * p =
300 dynamic_cast<const SubscriptionInstanceContainer *>(&container);
301
302 if(p == 0)
303 {
304 kumpf 1.15 throw DynamicCastFailedException();
305 }
306
307 _rep = new SubscriptionInstanceContainerRep();
308 _rep->subscriptionInstance = p->_rep->subscriptionInstance;
309 }
310
311 SubscriptionInstanceContainer::SubscriptionInstanceContainer
312 (const SubscriptionInstanceContainer & container)
|
313 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
314 w.otsuka 1.31 : OperationContext::Container()
315 #endif
|
316 kumpf 1.15 {
317 _rep = new SubscriptionInstanceContainerRep();
318 _rep->subscriptionInstance = container._rep->subscriptionInstance;
319 }
320
321 SubscriptionInstanceContainer::SubscriptionInstanceContainer
322 (const CIMInstance & subscriptionInstance)
323 {
324 _rep = new SubscriptionInstanceContainerRep();
325 _rep->subscriptionInstance = subscriptionInstance;
326 }
327
328 SubscriptionInstanceContainer::~SubscriptionInstanceContainer(void)
329 {
330 delete _rep;
331 }
332
333 SubscriptionInstanceContainer & SubscriptionInstanceContainer::operator=(
334 const SubscriptionInstanceContainer & container)
335 {
336 if (this == &container)
337 kumpf 1.15 {
338 return (*this);
339 }
340
341 _rep->subscriptionInstance = container._rep->subscriptionInstance;
342
343 return (*this);
344 }
345
346 String SubscriptionInstanceContainer::getName(void) const
347 {
348 return(NAME);
349 }
350
351 OperationContext::Container * SubscriptionInstanceContainer::clone(void) const
352 {
353 return(new SubscriptionInstanceContainer(_rep->subscriptionInstance));
354 }
355
356 void SubscriptionInstanceContainer::destroy(void)
357 {
358 kumpf 1.15 delete this;
359 }
360
361 CIMInstance SubscriptionInstanceContainer::getInstance(void) const
362 {
363 return(_rep->subscriptionInstance);
364 }
365
366
367 //
368 // SubscriptionInstanceNamesContainer
369 //
370
371 class SubscriptionInstanceNamesContainerRep
372 {
373 public:
374 Array<CIMObjectPath> subscriptionInstanceNames;
375 };
376
377 const String SubscriptionInstanceNamesContainer::NAME =
378 "SubscriptionInstanceNamesContainer";
379 kumpf 1.15
380 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
381 (const OperationContext::Container & container)
382 {
383 const SubscriptionInstanceNamesContainer * p =
384 dynamic_cast<const SubscriptionInstanceNamesContainer *>(&container);
385
386 if(p == 0)
387 {
388 throw DynamicCastFailedException();
389 }
390
391 _rep = new SubscriptionInstanceNamesContainerRep();
392 _rep->subscriptionInstanceNames = p->_rep->subscriptionInstanceNames;
393 }
394
395 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
396 (const SubscriptionInstanceNamesContainer & container)
|
397 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
398 w.otsuka 1.31 : OperationContext::Container()
399 #endif
|
400 kumpf 1.15 {
401 _rep = new SubscriptionInstanceNamesContainerRep();
402 _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
403 }
404
405 SubscriptionInstanceNamesContainer::SubscriptionInstanceNamesContainer
406 (const Array<CIMObjectPath> & subscriptionInstanceNames)
407 {
408 _rep = new SubscriptionInstanceNamesContainerRep();
409 _rep->subscriptionInstanceNames = subscriptionInstanceNames;
410 }
411
412 SubscriptionInstanceNamesContainer::~SubscriptionInstanceNamesContainer(void)
413 {
414 delete _rep;
415 }
416
417 SubscriptionInstanceNamesContainer &
418 SubscriptionInstanceNamesContainer::operator=(
419 const SubscriptionInstanceNamesContainer & container)
420 {
421 kumpf 1.15 if (this == &container)
422 {
423 return (*this);
424 }
425
426 _rep->subscriptionInstanceNames = container._rep->subscriptionInstanceNames;
427
428 return (*this);
429 }
430
431 String SubscriptionInstanceNamesContainer::getName(void) const
432 {
433 return(NAME);
434 }
435
436 OperationContext::Container *
437 SubscriptionInstanceNamesContainer::clone(void) const
438 {
439 return(new SubscriptionInstanceNamesContainer
440 (_rep->subscriptionInstanceNames));
441 }
442 kumpf 1.15
443 void SubscriptionInstanceNamesContainer::destroy(void)
444 {
445 delete this;
446 }
447
448 Array<CIMObjectPath>
449 SubscriptionInstanceNamesContainer::getInstanceNames(void) const
450 {
451 return(_rep->subscriptionInstanceNames);
452 }
453
|
454 kumpf 1.24
|
455 kumpf 1.15 //
456 // SubscriptionFilterConditionContainer
457 //
458
459 class SubscriptionFilterConditionContainerRep
460 {
461 public:
462 String filterCondition;
463 String queryLanguage;
464 };
465
466 const String SubscriptionFilterConditionContainer::NAME =
467 "SubscriptionFilterConditionContainer";
468
469 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
470 (const OperationContext::Container & container)
471 {
472 const SubscriptionFilterConditionContainer * p =
473 dynamic_cast<const SubscriptionFilterConditionContainer *>(&container);
474
475 if(p == 0)
476 kumpf 1.15 {
477 throw DynamicCastFailedException();
478 }
479
480 _rep = new SubscriptionFilterConditionContainerRep();
481 _rep->filterCondition = p->_rep->filterCondition;
482 _rep->queryLanguage = p->_rep->queryLanguage;
483 }
484
485 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer
486 (const SubscriptionFilterConditionContainer & container)
|
487 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
488 w.otsuka 1.31 : OperationContext::Container()
489 #endif
|
490 kumpf 1.15 {
491 _rep = new SubscriptionFilterConditionContainerRep();
492 _rep->filterCondition = container._rep->filterCondition;
493 _rep->queryLanguage = container._rep->queryLanguage;
494 }
495
496 SubscriptionFilterConditionContainer::SubscriptionFilterConditionContainer(
497 const String & filterCondition,
498 const String & queryLanguage)
499 {
500 _rep = new SubscriptionFilterConditionContainerRep();
501 _rep->filterCondition = filterCondition;
502 _rep->queryLanguage = queryLanguage;
503 }
504
505 SubscriptionFilterConditionContainer::~SubscriptionFilterConditionContainer
506 (void)
507 {
508 delete _rep;
509 }
510
511 kumpf 1.15 SubscriptionFilterConditionContainer &
512 SubscriptionFilterConditionContainer::operator=(
513 const SubscriptionFilterConditionContainer & container)
514 {
515 if (this == &container)
516 {
517 return (*this);
518 }
519
520 _rep->filterCondition = container._rep->filterCondition;
521 _rep->queryLanguage = container._rep->queryLanguage;
522
523 return (*this);
524 }
525
526 String SubscriptionFilterConditionContainer::getName(void) const
527 {
528 return(NAME);
529 }
530
531 OperationContext::Container * SubscriptionFilterConditionContainer::clone(void) const
532 kumpf 1.15 {
533 return(new SubscriptionFilterConditionContainer(_rep->filterCondition,
534 _rep->queryLanguage));
535 }
536
537 void SubscriptionFilterConditionContainer::destroy(void)
538 {
539 delete this;
540 }
541
542 String SubscriptionFilterConditionContainer::getFilterCondition(void) const
543 {
544 return(_rep->filterCondition);
545 }
546
547 String SubscriptionFilterConditionContainer::getQueryLanguage(void) const
548 {
549 return(_rep->queryLanguage);
|
550 chip 1.3 }
|
551 mike 1.2
|
552 kumpf 1.24
553 //
|
554 chuck 1.27 // SubscriptionFilterQueryContainer
555 //
556
557 class SubscriptionFilterQueryContainerRep
558 {
559 public:
560 String filterQuery;
561 String queryLanguage;
562 CIMNamespaceName sourceNameSpace;
563 };
564
565 const String SubscriptionFilterQueryContainer::NAME =
566 "SubscriptionFilterQueryContainer";
567
568 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
569 (const OperationContext::Container & container)
570 {
571 const SubscriptionFilterQueryContainer * p =
572 dynamic_cast<const SubscriptionFilterQueryContainer *>(&container);
573
574 if(p == 0)
575 chuck 1.27 {
576 throw DynamicCastFailedException();
577 }
578
579 _rep = new SubscriptionFilterQueryContainerRep();
580 _rep->filterQuery = p->_rep->filterQuery;
581 _rep->queryLanguage = p->_rep->queryLanguage;
582 _rep->sourceNameSpace = p->_rep->sourceNameSpace;
583 }
584
585 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer
586 (const SubscriptionFilterQueryContainer & container)
|
587 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
588 w.otsuka 1.31 : OperationContext::Container()
589 #endif
|
590 chuck 1.27 {
591 _rep = new SubscriptionFilterQueryContainerRep();
592 _rep->filterQuery = container._rep->filterQuery;
593 _rep->queryLanguage = container._rep->queryLanguage;
594 _rep->sourceNameSpace = container._rep->sourceNameSpace;
595 }
596
597 SubscriptionFilterQueryContainer::SubscriptionFilterQueryContainer(
598 const String & filterQuery,
599 const String & queryLanguage,
600 const CIMNamespaceName & sourceNameSpace)
601 {
602 _rep = new SubscriptionFilterQueryContainerRep();
603 _rep->filterQuery = filterQuery;
604 _rep->queryLanguage = queryLanguage;
605 _rep->sourceNameSpace = sourceNameSpace;
606 }
607
608 SubscriptionFilterQueryContainer::~SubscriptionFilterQueryContainer
609 (void)
610 {
611 chuck 1.27 delete _rep;
612 }
613 SubscriptionFilterQueryContainer &
614 SubscriptionFilterQueryContainer::operator=(
615 const SubscriptionFilterQueryContainer & container)
616 {
617 if (this == &container)
618 {
619 return (*this);
620 }
621
622 _rep->filterQuery = container._rep->filterQuery;
623 _rep->queryLanguage = container._rep->queryLanguage;
624 _rep->sourceNameSpace = container._rep->sourceNameSpace;
625
626 return (*this);
627 }
628
629 String SubscriptionFilterQueryContainer::getName(void) const
630 {
631 return(NAME);
632 chuck 1.27 }
633
634 OperationContext::Container * SubscriptionFilterQueryContainer::clone(void) const
635 {
636 return(new SubscriptionFilterQueryContainer(_rep->filterQuery,
637 _rep->queryLanguage,
638 _rep->sourceNameSpace));
639 }
640
641 void SubscriptionFilterQueryContainer::destroy(void)
642 {
643 delete this;
644 }
645
646 String SubscriptionFilterQueryContainer::getFilterQuery(void) const
647 {
648 return(_rep->filterQuery);
649 }
650
651 String SubscriptionFilterQueryContainer::getQueryLanguage(void) const
652 {
653 chuck 1.27 return(_rep->queryLanguage);
654 }
655
656 CIMNamespaceName SubscriptionFilterQueryContainer::getSourceNameSpace(void) const
657 {
658 return(_rep->sourceNameSpace);
659 }
660
661
662 //
|
663 kumpf 1.24 // TimeoutContainer
664 //
|
665 mday 1.17
666 const String TimeoutContainer::NAME = "TimeoutContainer";
667
668 TimeoutContainer::TimeoutContainer(const OperationContext::Container & container)
669 {
670 const TimeoutContainer * p = dynamic_cast<const TimeoutContainer *>(&container);
671 if(p == 0)
672 {
673 throw DynamicCastFailedException();
674 }
675 _value = p->_value;
676 }
677
678 TimeoutContainer::TimeoutContainer(Uint32 timeout)
679 {
680 _value = timeout;
681 }
682
683 String TimeoutContainer::getName(void) const
684 {
685 return (NAME);
686 mday 1.17 }
687
688 OperationContext::Container * TimeoutContainer::clone(void) const
689 {
690 return (new TimeoutContainer(_value));
691 }
692
693 void TimeoutContainer::destroy(void)
694 {
695 delete this;
696 }
697
698 Uint32 TimeoutContainer::getTimeOut(void) const
699 {
700 return _value;
701 }
702
703
|
704 chuck 1.18 //
705 // AcceptLanguageListContainer
706 //
|
707 mday 1.17
|
708 chuck 1.18 class AcceptLanguageListContainerRep
709 {
710 public:
|
711 kumpf 1.33 AcceptLanguageList languages;
|
712 chuck 1.18 };
713
714 const String AcceptLanguageListContainer::NAME =
715 "AcceptLanguageListContainer";
716
717 AcceptLanguageListContainer::AcceptLanguageListContainer
718 (const OperationContext::Container & container)
719 {
720 const AcceptLanguageListContainer * p =
721 dynamic_cast<const AcceptLanguageListContainer *>(&container);
722
723 if(p == 0)
724 {
725 throw DynamicCastFailedException();
726 }
727
728 _rep = new AcceptLanguageListContainerRep();
729 _rep->languages = p->_rep->languages;
730 }
731
732 AcceptLanguageListContainer::AcceptLanguageListContainer
733 chuck 1.18 (const AcceptLanguageListContainer & container)
|
734 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
735 w.otsuka 1.31 : OperationContext::Container()
736 #endif
|
737 chuck 1.18 {
738 _rep = new AcceptLanguageListContainerRep();
739 _rep->languages = container._rep->languages;
740 }
741
742 AcceptLanguageListContainer::AcceptLanguageListContainer
|
743 kumpf 1.33 (const AcceptLanguageList & languages)
|
744 chuck 1.18 {
745 _rep = new AcceptLanguageListContainerRep();
746 _rep->languages = languages;
747 }
748
749 AcceptLanguageListContainer::~AcceptLanguageListContainer(void)
750 {
751 delete _rep;
752 }
753
754 AcceptLanguageListContainer & AcceptLanguageListContainer::operator=(
755 const AcceptLanguageListContainer & container)
756 {
757 if (this == &container)
758 {
759 return (*this);
760 }
761
762 _rep->languages = container._rep->languages;
763
764 return (*this);
765 chuck 1.18 }
766
767 String AcceptLanguageListContainer::getName(void) const
768 {
769 return(NAME);
770 }
771
772 OperationContext::Container * AcceptLanguageListContainer::clone(void) const
773 {
774 return(new AcceptLanguageListContainer(_rep->languages));
775 }
776
777 void AcceptLanguageListContainer::destroy(void)
778 {
779 delete this;
780 }
781
|
782 kumpf 1.33 AcceptLanguageList AcceptLanguageListContainer::getLanguages(void) const
|
783 chuck 1.18 {
784 return(_rep->languages);
785 }
786
|
787 kumpf 1.24
|
788 chuck 1.18 //
789 // ContentLanguageListContainer
790 //
791
792 class ContentLanguageListContainerRep
793 {
794 public:
|
795 kumpf 1.33 ContentLanguageList languages;
|
796 chuck 1.18 };
797
798 const String ContentLanguageListContainer::NAME =
799 "ContentLanguageListContainer";
800
801 ContentLanguageListContainer::ContentLanguageListContainer
802 (const OperationContext::Container & container)
803 {
804 const ContentLanguageListContainer * p =
805 dynamic_cast<const ContentLanguageListContainer *>(&container);
806
807 if(p == 0)
808 {
809 throw DynamicCastFailedException();
810 }
811
812 _rep = new ContentLanguageListContainerRep();
813 _rep->languages = p->_rep->languages;
814 }
815
816 ContentLanguageListContainer::ContentLanguageListContainer
817 chuck 1.18 (const ContentLanguageListContainer & container)
|
818 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
819 w.otsuka 1.31 : OperationContext::Container()
820 #endif
|
821 chuck 1.18 {
822 _rep = new ContentLanguageListContainerRep();
823 _rep->languages = container._rep->languages;
824 }
825
826 ContentLanguageListContainer::ContentLanguageListContainer
|
827 kumpf 1.33 (const ContentLanguageList & languages)
|
828 chuck 1.18 {
829 _rep = new ContentLanguageListContainerRep();
830 _rep->languages = languages;
831 }
832
833 ContentLanguageListContainer::~ContentLanguageListContainer(void)
834 {
835 delete _rep;
836 }
837
838 ContentLanguageListContainer & ContentLanguageListContainer::operator=(
839 const ContentLanguageListContainer & container)
840 {
841 if (this == &container)
842 {
843 return (*this);
844 }
845
846 _rep->languages = container._rep->languages;
847
848 return (*this);
849 chuck 1.18 }
850
851 String ContentLanguageListContainer::getName(void) const
852 {
853 return(NAME);
854 }
855
856 OperationContext::Container * ContentLanguageListContainer::clone(void) const
857 {
858 return(new ContentLanguageListContainer(_rep->languages));
859 }
860
861 void ContentLanguageListContainer::destroy(void)
862 {
863 delete this;
864 }
865
|
866 kumpf 1.33 ContentLanguageList ContentLanguageListContainer::getLanguages(void) const
|
867 chuck 1.18 {
868 return(_rep->languages);
869 }
870
871
|
872 mday 1.17
|
873 kumpf 1.20 //
874 // SnmpTrapOidContainer
875 //
876
877 class SnmpTrapOidContainerRep
878 {
879 public:
880 String snmpTrapOid;
881 };
882
883 const String SnmpTrapOidContainer::NAME =
884 "SnmpTrapOidContainer";
885
886 SnmpTrapOidContainer::SnmpTrapOidContainer
887 (const OperationContext::Container & container)
888 {
889 const SnmpTrapOidContainer * p =
890 dynamic_cast<const SnmpTrapOidContainer *>(&container);
891
892 if(p == 0)
893 {
894 kumpf 1.20 throw DynamicCastFailedException();
895 }
896
897 _rep = new SnmpTrapOidContainerRep();
898 _rep->snmpTrapOid = p->_rep->snmpTrapOid;
899 }
900
901 SnmpTrapOidContainer::SnmpTrapOidContainer
902 (const SnmpTrapOidContainer & container)
|
903 joshi.swapnil 1.37 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
904 w.otsuka 1.31 : OperationContext::Container()
905 #endif
|
906 kumpf 1.20 {
907 _rep = new SnmpTrapOidContainerRep();
908 _rep->snmpTrapOid = container._rep->snmpTrapOid;
909 }
910
911 SnmpTrapOidContainer::SnmpTrapOidContainer
912 (const String & snmpTrapOid)
913 {
914 _rep = new SnmpTrapOidContainerRep();
915 _rep->snmpTrapOid = snmpTrapOid;
916 }
917
918 SnmpTrapOidContainer::~SnmpTrapOidContainer(void)
919 {
920 delete _rep;
921 }
922
923 SnmpTrapOidContainer & SnmpTrapOidContainer::operator=(
924 const SnmpTrapOidContainer & container)
925 {
926 if (this == &container)
927 kumpf 1.20 {
928 return (*this);
929 }
930
931 _rep->snmpTrapOid = container._rep->snmpTrapOid;
932
933 return (*this);
934 }
935
936 String SnmpTrapOidContainer::getName(void) const
937 {
938 return(NAME);
939 }
940
941 OperationContext::Container * SnmpTrapOidContainer::clone(void) const
942 {
943 return(new SnmpTrapOidContainer(_rep->snmpTrapOid));
944 }
945
946 void SnmpTrapOidContainer::destroy(void)
947 {
948 kumpf 1.20 delete this;
949 }
950
951 String SnmpTrapOidContainer::getSnmpTrapOid(void) const
952 {
953 return(_rep->snmpTrapOid);
954 }
|
955 kumpf 1.24
|
956 mike 1.2 PEGASUS_NAMESPACE_END
|
Return to
OperationContext.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common