1 mike 1.1.2.1 //%2006////////////////////////////////////////////////////////////////////////
2 //
3 // 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 // IBM Corp.; EMC Corporation, The Open Group.
7 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
13 //
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 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 mike 1.1.2.1 // 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 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include <cstdarg>
35 #include <cassert>
36 #include "MetaRepository.h"
37 #include <Pegasus/Common/System.h>
38
|
39 mike 1.1.2.2 #define TEST_META_REPOSITORY
40
41 #if defined(TEST_META_REPOSITORY)
42 # include "root_cimv2_namespace.h"
43 # include "root_PG_Internal_namespace.h"
44 # include "root_PG_InterOp_namespace.h"
|
45 mike 1.1.2.1 #endif
46
47 PEGASUS_NAMESPACE_BEGIN
48
49 static const size_t _MAX_NAMESPACES = 32;
50 static const MetaNameSpace* _nameSpaces[_MAX_NAMESPACES];
51 static size_t _nameSpacesSize = 0;
52
53 static const size_t _MAX_FEATURES = 1024;
54 static const size_t _MAX_QUALIFIERS = 1024;
55
|
56 mike 1.1.2.4 static inline void _init()
|
57 mike 1.1.2.1 {
|
58 mike 1.1.2.4 #if defined(TEST_META_REPOSITORY)
|
59 mike 1.1.2.1 if (_nameSpacesSize == 0)
60 {
61 MetaRepository::addNameSpace(&root_PG_InterOp_namespace);
62 MetaRepository::addNameSpace(&root_cimv2_namespace);
63 MetaRepository::addNameSpace(&root_PG_Internal_namespace);
64 }
65 #endif
|
66 mike 1.1.2.4 }
|
67 mike 1.1.2.1
68 static bool _eqi(const char* s1, const char* s2)
69 {
70 return System::strcasecmp(s1, s2) == 0;
71 }
72
73 //==============================================================================
74 //
75 // Local definitions:
76 //
77 //==============================================================================
78
79 class Str
80 {
81 public:
82 Str(const String& s) : _cstr(s.getCString()) { }
83 Str(const CIMName& n) : _cstr(n.getString().getCString()) { }
84 Str(const CIMNamespaceName& n) : _cstr(n.getString().getCString()) { }
85 Str(const Exception& e) : _cstr(e.getMessage().getCString()) { }
86 Str(const CIMDateTime& x) : _cstr(x.toString().getCString()) { }
87 Str(const CIMObjectPath& x) : _cstr(x.toString().getCString()) { }
88 mike 1.1.2.1 const char* operator*() const { return (const char*)_cstr; }
89 operator const char*() const { return (const char*)_cstr; }
90 private:
91 CString _cstr;
92 };
93
94 PEGASUS_FORMAT(2, 3)
95 static void _throw(CIMStatusCode code, const char* format, ...)
96 {
97 char buffer[4096];
98
99 va_list ap;
100 va_start(ap, format);
101 vsprintf(buffer, format, ap);
102 va_end(ap);
103 throw CIMException(code, buffer);
104 }
105
106 static const MetaNameSpace* _findNameSpace(const char* name)
107 {
108 for (size_t i = 0; i < _nameSpacesSize; i++)
109 mike 1.1.2.1 {
110 if (_eqi(_nameSpaces[i]->name, name))
111 return _nameSpaces[i];
112 }
113
114 // Not found!
115 return 0;
116 }
117
118 static bool _isSubClass(const MetaClass* super, const MetaClass* sub)
119 {
120 if (!super)
121 return true;
122
123 for (MetaClass* p = sub->super; p; p = p->super)
124 {
125 if (p == super)
126 return true;
127 }
128
129 return false;
130 mike 1.1.2.1 }
131
132 static inline bool _isDirectSubClass(
133 const MetaClass* super,
134 const MetaClass* sub)
135 {
136 return sub->super == super;
137 }
138
139 static const MetaClass* _findClass(
140 const MetaNameSpace* ns,
141 const char* name)
142 {
143 for (size_t i = 0; ns->classes[i]; i++)
144 {
|
145 mike 1.1.2.3 const MetaClass* mc = ns->classes[i];
|
146 mike 1.1.2.1
|
147 mike 1.1.2.3 if (_eqi(mc->name, name))
148 return mc;
|
149 mike 1.1.2.1 }
150
151 // Not found!
152 return 0;
153 }
154
|
155 mike 1.1.2.4 static const MetaQualifierDecl* _findQualifierDecl(
156 const MetaNameSpace* ns,
157 const char* name)
158 {
159 for (size_t i = 0; ns->classes[i]; i++)
160 {
161 const MetaQualifierDecl* mqd = ns->qualifiers[i];
162
163 if (_eqi(mqd->name, name))
164 return mqd;
165 }
166
167 // Not found!
168 return 0;
169 }
170
|
171 mike 1.1.2.1 static inline void _readBoolean(const char*& value, Boolean& x)
172 {
173 unsigned const char* p = (unsigned const char*)value;
174 x = Boolean(p[0]);
175 value++;
176 }
177
178 static inline void _readUint8(const char*& value, Uint8& x)
179 {
180 unsigned const char* p = (unsigned const char*)value;
181 x = Uint8(p[0]);
182 value += sizeof(x);
183 }
184
185 static inline void _readSint8(const char*& value, Sint8& x)
186 {
187 _readUint8(value, *((Uint8*)&x));
188 }
189
190 static inline void _readUint16(const char*& value, Uint16& x)
191 {
192 mike 1.1.2.1 unsigned const char* p = (unsigned const char*)value;
193 Uint16 x0 = Uint16(p[0]) << 8;
194 Uint16 x1 = Uint16(p[1]) << 0;
195 x = Uint16(x0 | x1);
196 value += sizeof(x);
197 }
198
199 static inline void _readSint16(const char*& value, Sint16& x)
200 {
201 _readUint16(value, *((Uint16*)&x));
202 value += sizeof(x);
203 }
204
205 static inline void _readUint32(const char*& value, Uint32& x)
206 {
207 unsigned const char* p = (unsigned const char*)value;
208 Uint32 x0 = Uint32(p[0]) << 24;
209 Uint32 x1 = Uint32(p[1]) << 16;
210 Uint32 x2 = Uint32(p[0]) << 8;
211 Uint32 x3 = Uint32(p[1]) << 0;
212 x = Uint32(x0 | x1 | x2 | x3);
213 mike 1.1.2.1 value += sizeof(x);
214 }
215
216 static inline void _readSint32(const char*& value, Sint32& x)
217 {
218 _readUint32(value, *((Uint32*)&x));
219 value += sizeof(x);
220 }
221
222 static inline void _readUint64(const char*& value, Uint64& x)
223 {
224 unsigned const char* p = (unsigned const char*)value;
225 Uint64 x0 = Uint64(p[0]) << 56;
226 Uint64 x1 = Uint64(p[1]) << 48;
227 Uint64 x2 = Uint64(p[2]) << 40;
228 Uint64 x3 = Uint64(p[3]) << 32;
229 Uint64 x4 = Uint64(p[4]) << 24;
230 Uint64 x5 = Uint64(p[5]) << 16;
231 Uint64 x6 = Uint64(p[6]) << 8;
232 Uint64 x7 = Uint64(p[7]) << 0;
233 x = Uint64(x0 | x1 | x2 | x3 | x4 | x5 | x6 | x7);
234 mike 1.1.2.1 value += sizeof(x);
235 }
236
237 static inline void _readSint64(const char*& value, Sint64& x)
238 {
239 _readUint64(value, *((Uint64*)&x));
240 value += sizeof(x);
241 }
242
243 static inline void _readReal32(const char*& value, Real32& x)
244 {
245 _readUint32(value, *((Uint32*)&x));
246 value += sizeof(x);
247 }
248
249 static inline void _readReal64(const char*& value, Real64& x)
250 {
251 _readUint64(value, *((Uint64*)&x));
252 value += sizeof(x);
253 }
254
255 mike 1.1.2.1 static inline void _readChar16(const char*& value, Char16& x)
256 {
257 _readUint16(value, *((Uint16*)&x));
258 value += sizeof(x);
259 }
260
261 static inline void _readString(const char*& value, String& x)
262 {
263 size_t n = strlen(value);
264 x.assign(value, n);
265 value += n + 1;
266 }
267
268 static inline void _readDateTime(const char*& value, CIMDateTime& x)
269 {
270 size_t n = strlen(value);
271 x.set(value);
272 value += n + 1;
273 }
274
275 static int _makeValue(
276 mike 1.1.2.1 CIMValue& cv,
277 Uint16 type,
278 Sint16 subscript,
279 const char* value)
280 {
281 // If null value:
282
283 if (value == 0)
284 {
285 if (subscript == -1)
286 cv.setNullValue(CIMType(type), false);
287 else
288 cv.setNullValue(CIMType(type), true, subscript);
289
290 return 0;
291 }
292
293 // If scalar, else array:
294
295 if (subscript == -1)
296 {
297 mike 1.1.2.1 switch (CIMType(type))
298 {
299 case CIMTYPE_BOOLEAN:
300 {
301 Boolean x;
302 _readBoolean(value, x);
303 cv.set(x);
304 return 0;
305 }
306 case CIMTYPE_UINT8:
307 {
308 Uint8 x;
309 _readUint8(value, x);
310 cv.set(x);
311 return 0;
312 }
313 case CIMTYPE_SINT8:
314 {
315 Sint8 x;
316 _readSint8(value, x);
317 cv.set(x);
318 mike 1.1.2.1 return 0;
319 }
320 case CIMTYPE_UINT16:
321 {
322 Uint16 x;
323 _readUint16(value, x);
324 cv.set(x);
325 return 0;
326 }
327 case CIMTYPE_SINT16:
328 {
329 Sint16 x;
330 _readSint16(value, x);
331 cv.set(x);
332 return 0;
333 }
334 case CIMTYPE_UINT32:
335 {
336 Uint32 x;
337 _readUint32(value, x);
338 cv.set(x);
339 mike 1.1.2.1 return 0;
340 }
341 case CIMTYPE_SINT32:
342 {
343 Sint32 x;
344 _readSint32(value, x);
345 cv.set(x);
346 return 0;
347 }
348 case CIMTYPE_UINT64:
349 {
350 Uint64 x;
351 _readUint64(value, x);
352 cv.set(x);
353 return 0;
354 }
355 case CIMTYPE_SINT64:
356 {
357 Sint64 x;
358 _readSint64(value, x);
359 cv.set(x);
360 mike 1.1.2.1 return 0;
361 }
362 case CIMTYPE_REAL32:
363 {
364 Real32 x;
365 _readReal32(value, x);
366 cv.set(x);
367 return 0;
368 }
369 case CIMTYPE_REAL64:
370 {
371 Real64 x;
372 _readReal64(value, x);
373 cv.set(x);
374 return 0;
375 }
376 case CIMTYPE_CHAR16:
377 {
378 Char16 x;
379 _readChar16(value, x);
380 cv.set(x);
381 mike 1.1.2.1 return 0;
382 }
383 case CIMTYPE_STRING:
384 {
385 String x;
386 _readString(value, x);
387 cv.set(x);
388 return 0;
389 }
390 case CIMTYPE_DATETIME:
391 {
392 CIMDateTime x;
393 _readDateTime(value, x);
394 cv.set(x);
395 return 0;
396 }
397
398 default:
399 printf("T[%u]\n", __LINE__);
400 return -1;
401 }
402 mike 1.1.2.1 }
403 else
404 {
405 // Read array size:
406
407 Uint16 size;
408 _readUint16(value, size);
409
410 // Read array elements:
411
412 switch (CIMType(type))
413 {
414 case CIMTYPE_BOOLEAN:
415 {
416 Array<Boolean> a;
417
418 for (Uint16 i = 0; i < size; i++)
419 {
420 Boolean x;
421 _readBoolean(value, x);
422 a.append(x);
423 mike 1.1.2.1 }
424
425 cv.set(a);
426 return 0;
427 }
428 case CIMTYPE_UINT8:
429 {
430 Array<Uint8> a;
431
432 for (Uint16 i = 0; i < size; i++)
433 {
434 Uint8 x;
435 _readUint8(value, x);
436 a.append(x);
437 }
438
439 cv.set(a);
440 return 0;
441 }
442 case CIMTYPE_SINT8:
443 {
444 mike 1.1.2.1 Array<Sint8> a;
445
446 for (Uint16 i = 0; i < size; i++)
447 {
448 Sint8 x;
449 _readSint8(value, x);
450 a.append(x);
451 }
452
453 cv.set(a);
454 return 0;
455 }
456 case CIMTYPE_UINT16:
457 {
458 Array<Uint16> a;
459
460 for (Uint16 i = 0; i < size; i++)
461 {
462 Uint16 x;
463 _readUint16(value, x);
464 a.append(x);
465 mike 1.1.2.1 }
466
467 cv.set(a);
468 return 0;
469 }
470 case CIMTYPE_SINT16:
471 {
472 Array<Sint16> a;
473
474 for (Uint16 i = 0; i < size; i++)
475 {
476 Sint16 x;
477 _readSint16(value, x);
478 a.append(x);
479 }
480
481 cv.set(a);
482 return 0;
483 }
484 case CIMTYPE_UINT32:
485 {
486 mike 1.1.2.1 Array<Uint32> a;
487
488 for (Uint16 i = 0; i < size; i++)
489 {
490 Uint32 x;
491 _readUint32(value, x);
492 a.append(x);
493 }
494
495 cv.set(a);
496 return 0;
497 }
498 case CIMTYPE_SINT32:
499 {
500 Array<Sint32> a;
501
502 for (Uint16 i = 0; i < size; i++)
503 {
504 Sint32 x;
505 _readSint32(value, x);
506 a.append(x);
507 mike 1.1.2.1 }
508
509 cv.set(a);
510 return 0;
511 }
512 case CIMTYPE_UINT64:
513 {
514 Array<Uint64> a;
515
516 for (Uint16 i = 0; i < size; i++)
517 {
518 Uint64 x;
519 _readUint64(value, x);
520 a.append(x);
521 }
522
523 cv.set(a);
524 return 0;
525 }
526 case CIMTYPE_SINT64:
527 {
528 mike 1.1.2.1 Array<Sint64> a;
529
530 for (Uint16 i = 0; i < size; i++)
531 {
532 Sint64 x;
533 _readSint64(value, x);
534 a.append(x);
535 }
536
537 cv.set(a);
538 return 0;
539 }
540 case CIMTYPE_REAL32:
541 {
542 Array<Real32> a;
543
544 for (Uint16 i = 0; i < size; i++)
545 {
546 Real32 x;
547 _readReal32(value, x);
548 a.append(x);
549 mike 1.1.2.1 }
550
551 cv.set(a);
552 return 0;
553 }
554 case CIMTYPE_REAL64:
555 {
556 Array<Real64> a;
557
558 for (Uint16 i = 0; i < size; i++)
559 {
560 Real64 x;
561 _readReal64(value, x);
562 a.append(x);
563 }
564
565 cv.set(a);
566 return 0;
567 }
568 case CIMTYPE_CHAR16:
569 {
570 mike 1.1.2.1 Array<Char16> a;
571
572 for (Uint16 i = 0; i < size; i++)
573 {
574 Char16 x;
575 _readChar16(value, x);
576 a.append(x);
577 }
578
579 cv.set(a);
580 return 0;
581 }
582 case CIMTYPE_STRING:
583 {
584 Array<String> a;
585
586 for (Uint16 i = 0; i < size; i++)
587 {
588 String x;
589 _readString(value, x);
590 a.append(x);
591 mike 1.1.2.1 }
592
593 cv.set(a);
594 return 0;
595 }
596 case CIMTYPE_DATETIME:
597 {
598 Array<CIMDateTime> a;
599
600 for (Uint16 i = 0; i < size; i++)
601 {
602 CIMDateTime x;
603 _readDateTime(value, x);
604 a.append(x);
605 }
606
607 cv.set(a);
608 return 0;
609 }
610
611 default:
612 mike 1.1.2.1 printf("T[%u]\n", __LINE__);
613 return -1;
614 }
615 }
616
617 // Unreachable!
618 printf("T[%u]\n", __LINE__);
619 return -1;
620 }
621
622 struct FeatureInfo
623 {
|
624 mike 1.1.2.3 const MetaFeature* mf;
625 const MetaClass* mc;
|
626 mike 1.1.2.1 };
627
628 static int _mergeFeatures(
|
629 mike 1.1.2.3 const MetaClass* mc,
630 bool localOnly,
|
631 mike 1.1.2.1 FeatureInfo features[_MAX_FEATURES],
632 size_t& numFeatures)
633 {
|
634 mike 1.1.2.3 if (!localOnly && mc->super)
|
635 mike 1.1.2.1 {
|
636 mike 1.1.2.3 if (_mergeFeatures(mc->super, localOnly, features, numFeatures) != 0)
|
637 mike 1.1.2.1 {
638 printf("T[%u]\n", __LINE__);
639 return -1;
640 }
641 }
642
643 // Process all features of this class:
644
|
645 mike 1.1.2.3 for (size_t i = 0; mc->features[i]; i++)
|
646 mike 1.1.2.1 {
|
647 mike 1.1.2.3 const MetaFeature* mf = mc->features[i];
|
648 mike 1.1.2.1
649 // Override feature if defined by ancestor class:
650
651 bool found = false;
652
653 for (size_t j = 0; j < numFeatures; j++)
654 {
|
655 mike 1.1.2.3 const MetaFeature* tmp = features[j].mf;
|
656 mike 1.1.2.1
|
657 mike 1.1.2.3 if (_eqi(mf->name, tmp->name))
|
658 mike 1.1.2.1 {
|
659 mike 1.1.2.3 features[j].mf = mf;
660 features[j].mc = mc;
|
661 mike 1.1.2.1 found = true;
662 break;
663 }
664 }
665
666 // Add new feature if not not defined by ancestor class:
667
668 if (!found)
669 {
670 if (numFeatures == _MAX_FEATURES)
671 {
672 printf("T[%u]\n", __LINE__);
673 return -1;
674 }
675
|
676 mike 1.1.2.3 features[numFeatures].mf = mf;
677 features[numFeatures].mc = mc;
|
678 mike 1.1.2.1 numFeatures++;
679 }
680 }
681
682 return 0;
683 }
684
685 struct QualifierInfo
686 {
687 const char* qualifier;
|
688 mike 1.1.2.3 const MetaClass* mc;
|
689 mike 1.1.2.1 };
690
691 static const MetaFeature* _findFeature(
|
692 mike 1.1.2.3 const MetaClass* mc,
|
693 mike 1.1.2.1 const char* name)
694 {
|
695 mike 1.1.2.3 for (size_t i = 0; mc->features[i]; i++)
|
696 mike 1.1.2.1 {
|
697 mike 1.1.2.3 const MetaFeature* mf = mc->features[i];
|
698 mike 1.1.2.1
|
699 mike 1.1.2.3 if (_eqi(mf->name, name))
700 return mf;
|
701 mike 1.1.2.1 }
702
703 // Not found!
704 return 0;
705 }
706
707 static const MetaFeature* _findParameter(
|
708 mike 1.1.2.3 const MetaMethod* mm,
|
709 mike 1.1.2.1 const char* name)
710 {
|
711 mike 1.1.2.3 for (size_t i = 0; mm->parameters[i]; i++)
|
712 mike 1.1.2.1 {
|
713 mike 1.1.2.3 const MetaFeature* mf = mm->parameters[i];
|
714 mike 1.1.2.1
|
715 mike 1.1.2.3 if (_eqi(mm->name, name))
716 return mf;
|
717 mike 1.1.2.1 }
718
719 // Not found!
720 return 0;
721 }
722
723 static int _mergeQualifiers(
724 const MetaNameSpace* ns,
|
725 mike 1.1.2.3 const MetaClass* mc,
|
726 mike 1.1.2.1 const char* featureName,
727 const char* parameterName,
728 bool depth,
729 QualifierInfo qualifiers[_MAX_QUALIFIERS],
730 size_t& numQualifiers)
731 {
732 // Merge super-class qualifiers:
733
|
734 mike 1.1.2.3 if (mc->super)
|
735 mike 1.1.2.1 {
|
736 mike 1.1.2.3 _mergeQualifiers(ns, mc->super, featureName, parameterName, depth + 1,
|
737 mike 1.1.2.1 qualifiers, numQualifiers);
738 }
739
740 const char** quals = 0;
741
742 // Find qualifiers of the given object:
743
744 if (!featureName && !parameterName)
745 {
746 // Case 1: get class qualifiers:
|
747 mike 1.1.2.3 quals = mc->qualifiers;
|
748 mike 1.1.2.1 }
749 else if (featureName && !parameterName)
750 {
751 // Case 2: get feature qualifiers:
752
|
753 mike 1.1.2.3 const MetaFeature* mf = _findFeature(mc, featureName);
|
754 mike 1.1.2.1
|
755 mike 1.1.2.3 if (mf)
756 quals = mf->qualifiers;
|
757 mike 1.1.2.1 }
758 else if (featureName && parameterName)
759 {
760 // Case 3: get parameter qualifiers:
761
|
762 mike 1.1.2.3 const MetaFeature* mf = _findFeature(mc, featureName);
|
763 mike 1.1.2.1
|
764 mike 1.1.2.3 if (mf && (mf->flags & META_FLAG_METHOD))
|
765 mike 1.1.2.1 {
|
766 mike 1.1.2.3 const MetaMethod* mm = (const MetaMethod*)mf;
767 const MetaFeature* p = _findParameter(mm, parameterName);
|
768 mike 1.1.2.1
769 if (p)
770 quals = p->qualifiers;
771 }
772 }
773
774 // Merge quals into the qualifiers array:
775
776 if (!quals)
777 return 0;
778
779 for (size_t i = 0; quals[i]; i++)
780 {
781 const char* qi = quals[i];
782
783 // Override existing qualifier if any:
784
785 bool found = false;
786
787 for (size_t j = 0; j < numQualifiers; j++)
788 {
789 mike 1.1.2.1 const char* qj = qualifiers[j].qualifier;
790
791 if (qi[0] == qj[0])
792 {
793 qualifiers[j].qualifier = qi;
|
794 mike 1.1.2.3 qualifiers[j].mc = mc;
|
795 mike 1.1.2.1 found = true;
796 break;
797 }
798 }
799
800 // Inject this qualifier not found:
801
802 if (!found)
803 {
804 MetaQualifierDecl* qd = ns->qualifiers[qi[0]];
805
806 if (depth == 0 || !(qd->flavor & META_FLAVOR_RESTRICTED))
807 {
808 if (numQualifiers == _MAX_QUALIFIERS)
809 {
810 printf("T[%u]\n", __LINE__);
811 return -1;
812 }
813
814 qualifiers[numQualifiers].qualifier = qi;
|
815 mike 1.1.2.3 qualifiers[numQualifiers].mc = mc;
|
816 mike 1.1.2.1 numQualifiers++;
817 }
818 }
819 }
820
821 return 0;
822 }
823
824 template<class C>
825 static int _addQualifiers(
826 const MetaNameSpace* ns,
|
827 mike 1.1.2.3 const MetaClass* mc,
|
828 mike 1.1.2.1 const char* featureName,
829 const char* parameterName,
830 C& c)
831 {
832 QualifierInfo qualifiers[_MAX_QUALIFIERS];
833 size_t numQualifiers = 0;
834
835 if (_mergeQualifiers(
|
836 mike 1.1.2.3 ns, mc, featureName, parameterName, 0, qualifiers, numQualifiers) != 0)
|
837 mike 1.1.2.1 {
838 printf("T[%u]\n", __LINE__);
839 return -1;
840 }
841
842 // Add qualifiers to container:
843
844 for (size_t i = 0; i < numQualifiers; i++)
845 {
846 const char* q = qualifiers[i].qualifier;
847
848 // Get qualifier id:
849
850 Uint8 qid = Uint8(q[0]);
851
852 // Get qualifier declaration:
853
854 MetaQualifierDecl* qd = ns->qualifiers[qid];
855
856 // Make CIMValue:
857
858 mike 1.1.2.1 CIMValue cv;
859
860 if (_makeValue(cv, qd->type, qd->subscript, q + 1) != 0)
861 {
862 printf("T[%u]\n", __LINE__);
863 return -1;
864 }
865
866 // Add qualifier:
867
868 c.addQualifier(CIMQualifier(qd->name, cv));
869 }
870
871 return 0;
872 }
873
874 static int _addProperty(
875 const MetaNameSpace* ns,
|
876 mike 1.1.2.3 const MetaClass* mc,
877 const MetaProperty* mp,
|
878 mike 1.1.2.1 const char* classOrigin,
879 bool propagated,
|
880 mike 1.1.2.3 bool includeQualifiers,
881 bool includeClassOrigin,
|
882 mike 1.1.2.1 CIMClass& cc)
883 {
884 // Make CIMvalue:
885
886 CIMValue cv;
887
|
888 mike 1.1.2.3 if (_makeValue(cv, mp->type, mp->subscript, mp->value) != 0)
|
889 mike 1.1.2.1 {
890 printf("T[%u]\n", __LINE__);
891 return -1;
892 }
893
894 // Create property:
895
|
896 mike 1.1.2.3 CIMProperty cp(mp->name, cv);
897
898 if (includeClassOrigin)
899 cp.setClassOrigin(classOrigin);
900
|
901 mike 1.1.2.1 cp.setPropagated(propagated);
902
903 // Add qualifiers:
904
|
905 mike 1.1.2.3 if (includeQualifiers)
|
906 mike 1.1.2.1 {
|
907 mike 1.1.2.3 if (_addQualifiers(ns, mc, mp->name, 0, cp) != 0)
908 {
909 printf("T[%u]\n", __LINE__);
910 return -1;
911 }
|
912 mike 1.1.2.1 }
913
914 // Add to class:
915
916 cc.addProperty(cp);
917 return 0;
918 }
919
920 static int _addReference(
921 const MetaNameSpace* ns,
|
922 mike 1.1.2.3 const MetaClass* mc,
923 const MetaReference* mr,
|
924 mike 1.1.2.1 const char* classOrigin,
925 bool propagated,
|
926 mike 1.1.2.3 bool includeQualifiers,
927 bool includeClassOrigin,
|
928 mike 1.1.2.1 CIMClass& cc)
929 {
930 // Set isArray and arraySize:
931
932 Boolean isArray;
933 Uint32 arraySize;
934
|
935 mike 1.1.2.3 if (mr->subscript == -1)
|
936 mike 1.1.2.1 {
937 isArray = false;
938 arraySize = 0;
939 }
940 else
941 {
942 isArray = true;
|
943 mike 1.1.2.3 arraySize = mr->subscript;
|
944 mike 1.1.2.1 }
945
946 // Set referenceClassName:
947
|
948 mike 1.1.2.3 CIMName rcn = mr->ref->name;
|
949 mike 1.1.2.1
950 // Create value:
951
952 CIMValue cv(CIMTYPE_REFERENCE, isArray, arraySize);
953
954 // Create property:
955
|
956 mike 1.1.2.3 CIMProperty cp(mr->name, cv, arraySize, rcn);
957
958 if (includeClassOrigin)
959 cp.setClassOrigin(classOrigin);
960
961 cp.setPropagated(propagated);
|
962 mike 1.1.2.1
963 // Add qualifiers:
964
|
965 mike 1.1.2.3 if (includeQualifiers)
|
966 mike 1.1.2.1 {
|
967 mike 1.1.2.3 if (_addQualifiers(ns, mc, mr->name, 0, cp) != 0)
968 {
969 printf("T[%u]\n", __LINE__);
970 return -1;
971 }
|
972 mike 1.1.2.1 }
973
974 // Add to class:
975
976 cc.addProperty(cp);
977 return 0;
978 }
979
980 static int _addPropertyParameter(
981 const MetaNameSpace* ns,
|
982 mike 1.1.2.3 const MetaClass* mc,
983 const MetaMethod* mm,
984 const MetaProperty* mp,
985 bool includeQualifiers,
|
986 mike 1.1.2.1 CIMMethod& cm)
987 {
988 // Create property:
989
990 bool isArray;
991 Uint32 arraySize;
992
|
993 mike 1.1.2.3 if (mp->subscript == -1)
|
994 mike 1.1.2.1 {
995 isArray = false;
996 arraySize = 0;
997 }
998 else
999 {
1000 isArray = true;
|
1001 mike 1.1.2.3 arraySize = Uint32(mp->subscript);
|
1002 mike 1.1.2.1 }
1003
|
1004 mike 1.1.2.3 CIMParameter cp(mp->name, CIMType(mp->type), isArray, arraySize);
|
1005 mike 1.1.2.1
1006 // Add qualifiers:
1007
|
1008 mike 1.1.2.3 if (includeQualifiers)
|
1009 mike 1.1.2.1 {
|
1010 mike 1.1.2.3 if (_addQualifiers(ns, mc, mm->name, mp->name, cm) != 0)
1011 {
1012 printf("T[%u]\n", __LINE__);
1013 return -1;
1014 }
|
1015 mike 1.1.2.1 }
1016
1017 // Add to method:
1018
1019 cm.addParameter(cp);
1020 return 0;
1021 }
1022
1023 static int _addReferenceParameter(
1024 const MetaNameSpace* ns,
|
1025 mike 1.1.2.3 const MetaClass* mc,
1026 const MetaMethod* mm,
1027 const MetaReference* mr,
1028 bool includeQualifiers,
|
1029 mike 1.1.2.1 CIMMethod& cm)
1030 {
1031 // Create property:
1032
1033 bool isArray;
1034 Uint32 arraySize;
1035
|
1036 mike 1.1.2.3 if (mr->subscript == -1)
|
1037 mike 1.1.2.1 {
1038 isArray = false;
1039 arraySize = 0;
1040 }
1041 else
1042 {
1043 isArray = true;
|
1044 mike 1.1.2.3 arraySize = Uint32(mr->subscript);
|
1045 mike 1.1.2.1 }
1046
|
1047 mike 1.1.2.3 CIMName rcn = mr->ref->name;
1048 CIMParameter cp(mr->name, CIMTYPE_REFERENCE, isArray, arraySize, rcn);
|
1049 mike 1.1.2.1
1050 // Add qualifiers:
1051
|
1052 mike 1.1.2.3 if (includeQualifiers)
|
1053 mike 1.1.2.1 {
|
1054 mike 1.1.2.3 if (_addQualifiers(ns, mc, mm->name, mr->name, cm) != 0)
1055 {
1056 printf("T[%u]\n", __LINE__);
1057 return -1;
1058 }
|
1059 mike 1.1.2.1 }
1060
1061 // Add to method:
1062
1063 cm.addParameter(cp);
1064 return 0;
1065 }
1066
1067 static int _addMethod(
1068 const MetaNameSpace* ns,
|
1069 mike 1.1.2.3 const MetaClass* mc,
1070 const MetaMethod* mm,
|
1071 mike 1.1.2.1 const char* classOrigin,
1072 bool propagated,
|
1073 mike 1.1.2.3 bool includeQualifiers,
1074 bool includeClassOrigin,
|
1075 mike 1.1.2.1 CIMClass& cc)
1076 {
1077 // Create method:
1078
|
1079 mike 1.1.2.3 CIMMethod cm(mm->name, CIMType(mm->type));
1080
1081 if (includeClassOrigin)
1082 cm.setClassOrigin(classOrigin);
1083
|
1084 mike 1.1.2.1 cm.setPropagated(propagated);
1085
1086 // Add parameters:
1087
|
1088 mike 1.1.2.3 for (size_t i = 0; mm->parameters[i]; i++)
|
1089 mike 1.1.2.1 {
|
1090 mike 1.1.2.3 MetaFeature* mf = mm->parameters[i];
|
1091 mike 1.1.2.1
|
1092 mike 1.1.2.3 if (mf->flags & META_FLAG_PROPERTY)
|
1093 mike 1.1.2.1 {
|
1094 mike 1.1.2.3 MetaProperty* mp = (MetaProperty*)mf;
1095 _addPropertyParameter(ns, mc, mm, mp, includeQualifiers, cm);
|
1096 mike 1.1.2.1 }
|
1097 mike 1.1.2.3 else if (mf->flags & META_FLAG_REFERENCE)
|
1098 mike 1.1.2.1 {
|
1099 mike 1.1.2.3 MetaReference* mr = (MetaReference*)mf;
1100 _addReferenceParameter(ns, mc, mm, mr, includeQualifiers, cm);
|
1101 mike 1.1.2.1 }
1102 }
1103
1104 // Add qualifiers:
1105
|
1106 mike 1.1.2.3 if (includeQualifiers)
|
1107 mike 1.1.2.1 {
|
1108 mike 1.1.2.3 if (_addQualifiers(ns, mc, mm->name, 0, cm) != 0)
1109 {
1110 printf("T[%u]\n", __LINE__);
1111 return -1;
1112 }
|
1113 mike 1.1.2.1 }
1114
1115 // Add to class:
1116
1117 cc.addMethod(cm);
1118 return 0;
1119 }
1120
|
1121 mike 1.1.2.3 static bool _hasProperty(const char* const* propertyList, const char* name)
1122 {
1123 for (size_t i = 0; propertyList[i]; i++)
1124 {
1125 if (_eqi(propertyList[i], name))
1126 return true;
1127 }
1128
1129 return false;
1130 }
1131
|
1132 mike 1.1.2.1 static int _addFeatures(
1133 const MetaNameSpace* ns,
|
1134 mike 1.1.2.3 const MetaClass* mc,
1135 bool localOnly,
1136 bool includeQualifiers,
1137 bool includeClassOrigin,
1138 const char* const* propertyList,
|
1139 mike 1.1.2.1 CIMClass& cc)
1140 {
1141 // Merge features from all inheritance levels into a single array:
1142
1143 FeatureInfo features[_MAX_FEATURES];
1144 size_t numFeatures = 0;
1145
|
1146 mike 1.1.2.3 if (_mergeFeatures(mc, localOnly, features, numFeatures) != 0)
|
1147 mike 1.1.2.1 {
1148 printf("T[%u]\n", __LINE__);
1149 return -1;
1150 }
1151
1152 // For each feature:
1153
1154 for (size_t i = 0; i < numFeatures; i++)
1155 {
1156 const FeatureInfo& fi = features[i];
1157
1158 // Set propagated flag:
1159
|
1160 mike 1.1.2.3 bool propagated = fi.mc != mc;
|
1161 mike 1.1.2.1
1162 // Set classOrigin:
1163
|
1164 mike 1.1.2.3 const char* classOrigin = fi.mc->name;
|
1165 mike 1.1.2.1
|
1166 mike 1.1.2.3 // Skip feature not in property list:
|
1167 mike 1.1.2.1
|
1168 mike 1.1.2.3 const MetaFeature* mf = fi.mf;
|
1169 mike 1.1.2.1
|
1170 mike 1.1.2.3 if (propertyList && !_hasProperty(propertyList, mf->name))
1171 continue;
1172
1173 // Add the feature:
1174
1175 if (mf->flags & META_FLAG_PROPERTY)
|
1176 mike 1.1.2.1 {
|
1177 mike 1.1.2.3 MetaProperty* mp = (MetaProperty*)mf;
|
1178 mike 1.1.2.1
|
1179 mike 1.1.2.3 if (_addProperty(ns, mc, mp, classOrigin, propagated,
1180 includeQualifiers, includeClassOrigin, cc) != 0)
|
1181 mike 1.1.2.1 {
1182 printf("T[%u]\n", __LINE__);
1183 return -1;
1184 }
1185 }
|
1186 mike 1.1.2.3 else if (mf->flags & META_FLAG_REFERENCE)
|
1187 mike 1.1.2.1 {
|
1188 mike 1.1.2.3 MetaReference* mr = (MetaReference*)mf;
|
1189 mike 1.1.2.1
|
1190 mike 1.1.2.3 if (_addReference(ns, mc, mr, classOrigin, propagated,
1191 includeQualifiers, includeClassOrigin, cc) != 0)
|
1192 mike 1.1.2.1 {
1193 printf("T[%u]\n", __LINE__);
1194 return -1;
1195 }
1196 }
|
1197 mike 1.1.2.3 else if (mf->flags & META_FLAG_METHOD)
|
1198 mike 1.1.2.1 {
|
1199 mike 1.1.2.3 MetaMethod* mm = (MetaMethod*)mf;
|
1200 mike 1.1.2.1
|
1201 mike 1.1.2.3 if (_addMethod(ns, mc, mm, classOrigin, propagated,
1202 includeQualifiers, includeClassOrigin, cc) != 0)
|
1203 mike 1.1.2.1 {
1204 printf("T[%u]\n", __LINE__);
1205 return -1;
1206 }
1207 }
1208 }
1209
1210 return 0;
1211 }
1212
1213 static int _makeClass(
1214 const MetaNameSpace* ns,
|
1215 mike 1.1.2.3 const MetaClass* mc,
1216 Boolean localOnly,
1217 Boolean includeQualifiers,
1218 Boolean includeClassOrigin,
1219 const char* const* propertyList,
1220 CIMClass& cc)
|
1221 mike 1.1.2.1 {
1222 try
1223 {
1224 // Create class:
1225 {
1226 CIMName scn;
1227
|
1228 mike 1.1.2.3 if (mc->super)
1229 scn = mc->super->name;
|
1230 mike 1.1.2.1
|
1231 mike 1.1.2.3 cc = CIMClass(mc->name, scn);
1232 }
|
1233 mike 1.1.2.1
1234 // Add qualifiers:
1235
|
1236 mike 1.1.2.3 if (includeQualifiers)
|
1237 mike 1.1.2.1 {
|
1238 mike 1.1.2.3 if (_addQualifiers(ns, mc, 0, 0, cc) != 0)
1239 {
1240 printf("T[%u]\n", __LINE__);
1241 return -1;
1242 }
|
1243 mike 1.1.2.1 }
1244
1245 // Features:
1246
|
1247 mike 1.1.2.3 if (_addFeatures(ns, mc, localOnly, includeQualifiers,
1248 includeClassOrigin, propertyList, cc) != 0)
|
1249 mike 1.1.2.1 {
1250 printf("T[%u]\n", __LINE__);
1251 return -1;
1252 }
1253 }
1254 catch (Exception& e)
1255 {
1256 printf("EXCEPTION[%s]\n", *Str(e));
1257 return -1;
1258 }
1259 catch (...)
1260 {
1261 printf("T[%u]\n", __LINE__);
1262 return -1;
1263 }
1264
1265 return 0;
1266 }
1267
|
1268 mike 1.1.2.3 static char** _makePropertyList(const CIMPropertyList& propertyList)
1269 {
1270 if (propertyList.isNull())
1271 return 0;
1272
1273 size_t size = propertyList.size();
1274 char** pl = (char**)malloc(sizeof(char*) * (size + 1));
1275
1276 for (size_t i = 0; i < size; i++)
1277 pl[i] = strdup(*Str(propertyList[i]));
1278
1279 pl[size] = 0;
1280
1281 return pl;
1282 }
1283
1284 static void _freePropertyList(char** pl)
1285 {
1286 if (!pl)
1287 return;
1288
1289 mike 1.1.2.3 for (size_t i = 0; pl[i]; i++)
1290 {
1291 free(pl[i]);
1292 }
1293
1294 free(pl);
1295 }
1296
1297 static void _printPropertyList(const char* const* pl)
1298 {
1299 if (!pl)
1300 return;
1301
1302 for (size_t i = 0; pl[i]; i++)
1303 printf("pl[%s]\n", pl[i]);
1304 }
1305
|
1306 mike 1.1.2.4 static int _makeQualifierDecl(
1307 const MetaNameSpace* ns,
1308 const MetaQualifierDecl* mqd,
1309 CIMQualifierDecl& cqd)
1310 {
1311 // Value:
1312
1313 CIMValue cv;
1314
1315 if (_makeValue(cv, mqd->type, mqd->subscript, mqd->value) != 0)
1316 {
1317 printf("T[%u]\n", __LINE__);
1318 return -1;
1319 }
1320
1321 // Scope:
1322
1323 CIMScope scope;
1324
1325 if (mqd->scope & META_SCOPE_CLASS)
1326 scope.addScope(CIMScope::CLASS);
1327 mike 1.1.2.4 if (mqd->scope & META_SCOPE_ASSOCIATION)
1328 scope.addScope(CIMScope::ASSOCIATION);
1329 if (mqd->scope & META_SCOPE_INDICATION)
1330 scope.addScope(CIMScope::INDICATION);
1331 if (mqd->scope & META_SCOPE_PROPERTY)
1332 scope.addScope(CIMScope::PROPERTY);
1333 if (mqd->scope & META_SCOPE_REFERENCE)
1334 scope.addScope(CIMScope::REFERENCE);
1335 if (mqd->scope & META_SCOPE_METHOD)
1336 scope.addScope(CIMScope::METHOD);
1337 if (mqd->scope & META_SCOPE_PARAMETER);
1338 scope.addScope(CIMScope::PARAMETER);
1339
1340 // Flavor:
1341
1342 CIMFlavor flavor;
1343
1344 if (mqd->flavor & META_FLAVOR_OVERRIDABLE)
1345 flavor.addFlavor(CIMFlavor::OVERRIDABLE);
1346 if (mqd->flavor & META_FLAVOR_TOSUBCLASS)
1347 flavor.addFlavor(CIMFlavor::TOSUBCLASS);
1348 mike 1.1.2.4 if (mqd->flavor & META_FLAVOR_TOINSTANCE)
1349 flavor.addFlavor(CIMFlavor::TOINSTANCE);
1350 if (mqd->flavor & META_FLAVOR_TRANSLATABLE)
1351 flavor.addFlavor(CIMFlavor::TRANSLATABLE);
1352 if (mqd->flavor & META_FLAVOR_DISABLEOVERRIDE)
1353 flavor.addFlavor(CIMFlavor::DISABLEOVERRIDE);
1354 if (mqd->flavor & META_FLAVOR_RESTRICTED)
1355 flavor.addFlavor(CIMFlavor::RESTRICTED);
1356
1357 // Array size:
1358
1359 Uint32 arraySize;
1360
1361 if (mqd->subscript == -1)
1362 arraySize = 0;
1363 else
1364 arraySize = mqd->subscript;
1365
1366 cqd = CIMQualifierDecl(mqd->name, cv, scope, flavor, arraySize);
1367
1368 return 0;
1369 mike 1.1.2.4 }
1370
|
1371 mike 1.1.2.1 //==============================================================================
1372 //
1373 // class MetaRepository
1374 //
1375 //==============================================================================
1376
1377 MetaRepository::MetaRepository()
1378 {
1379 }
1380
1381 MetaRepository::~MetaRepository()
1382 {
1383 }
1384
1385 bool MetaRepository::addNameSpace(const MetaNameSpace* nameSpace)
1386 {
1387 if (_nameSpacesSize == _MAX_NAMESPACES || !nameSpace)
1388 return false;
1389
1390 for (size_t i = 0; i < _nameSpacesSize; i++)
1391 {
1392 mike 1.1.2.1 if (_eqi(_nameSpaces[i]->name, nameSpace->name))
1393 return false;
1394 }
1395
1396 _nameSpaces[_nameSpacesSize++] = nameSpace;
1397 return true;
1398 }
1399
1400 CIMClass MetaRepository::getClass(
1401 const CIMNamespaceName& nameSpace,
1402 const CIMName& className,
1403 Boolean localOnly,
1404 Boolean includeQualifiers,
1405 Boolean includeClassOrigin,
1406 const CIMPropertyList& propertyList)
1407 {
|
1408 mike 1.1.2.3 printf("===== MetaRepository::getClass()\n");
1409 _init();
1410
1411 // Lookup namespace:
1412
1413 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1414
1415 if (!ns)
1416 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1417
1418 // Lookup class:
1419
1420 const MetaClass* mc = _findClass(ns, *Str(className));
1421
1422 if (!mc)
1423 _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));
1424
1425 // Build property list:
1426
1427 char** pl = _makePropertyList(propertyList);
1428
1429 mike 1.1.2.3 // Make class:
1430
1431 CIMClass cc;
1432
1433 if (_makeClass(ns, mc, localOnly, includeQualifiers,
1434 includeQualifiers, pl, cc) != 0)
1435 {
1436 _freePropertyList(pl);
1437 _throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);
1438 }
1439
1440 _freePropertyList(pl);
1441 return cc;
|
1442 mike 1.1.2.1 }
1443
1444 Array<CIMClass> MetaRepository::enumerateClasses(
1445 const CIMNamespaceName& nameSpace,
1446 const CIMName& className,
1447 Boolean deepInheritance,
1448 Boolean localOnly,
1449 Boolean includeQualifiers,
1450 Boolean includeClassOrigin)
1451 {
|
1452 mike 1.1.2.3 printf("===== MetaRepository::enumerateClasses()\n");
|
1453 mike 1.1.2.1 _init();
1454
1455 // Lookup namespace:
1456
1457 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1458
1459 if (!ns)
1460 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1461
1462 // Lookup class:
1463
1464 const MetaClass* super = 0;
1465
1466 if (!className.isNull())
1467 {
1468 super = _findClass(ns, *Str(className));
1469
1470 if (!super)
1471 _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));
1472 }
1473
1474 mike 1.1.2.1 // Iterate all classes looking for matches:
1475
1476 Array<CIMClass> result;
1477
1478 for (size_t i = 0; ns->classes[i]; i++)
1479 {
|
1480 mike 1.1.2.3 MetaClass* mc = ns->classes[i];
|
1481 mike 1.1.2.1
|
1482 mike 1.1.2.3 bool flag = false;
|
1483 mike 1.1.2.1
1484 if (deepInheritance)
1485 {
|
1486 mike 1.1.2.3 if (_isSubClass(super, mc))
1487 flag = true;
|
1488 mike 1.1.2.1 }
1489 else
1490 {
|
1491 mike 1.1.2.3 if (_isDirectSubClass(super, mc))
1492 flag = true;
1493 }
1494
1495 if (flag)
1496 {
1497 CIMClass cc;
|
1498 mike 1.1.2.1
|
1499 mike 1.1.2.3 if (_makeClass(ns, mc, localOnly, includeQualifiers,
1500 includeQualifiers, 0, cc) != 0)
1501 {
1502 _throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);
|
1503 mike 1.1.2.1 }
|
1504 mike 1.1.2.3 else
1505 result.append(cc);
|
1506 mike 1.1.2.1 }
1507 }
1508
1509 return result;
1510 }
1511
1512 Array<CIMName> MetaRepository::enumerateClassNames(
1513 const CIMNamespaceName& nameSpace,
1514 const CIMName& className,
1515 Boolean deepInheritance)
1516 {
|
1517 mike 1.1.2.3 printf("===== MetaRepository::enumerateClassNames()\n");
1518 _init();
1519
|
1520 mike 1.1.2.1 // Lookup namespace:
1521
1522 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1523
1524 if (!ns)
1525 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1526
1527 // Lookup class:
1528
1529 const MetaClass* super = 0;
1530
1531 if (!className.isNull())
1532 {
1533 super = _findClass(ns, *Str(className));
1534
1535 if (!super)
1536 _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));
1537 }
1538
1539 // Iterate all classes looking for matches:
1540
1541 mike 1.1.2.1 Array<CIMName> result;
1542
1543 for (size_t i = 0; ns->classes[i]; i++)
1544 {
|
1545 mike 1.1.2.3 MetaClass* mc = ns->classes[i];
|
1546 mike 1.1.2.1
1547 if (deepInheritance)
1548 {
|
1549 mike 1.1.2.3 if (_isSubClass(super, mc))
1550 result.append(mc->name);
|
1551 mike 1.1.2.1 }
1552 else
1553 {
|
1554 mike 1.1.2.3 if (_isDirectSubClass(super, mc))
1555 result.append(mc->name);
|
1556 mike 1.1.2.1 }
1557 }
1558
1559 return result;
1560 }
1561
1562 void MetaRepository::deleteClass(
1563 const CIMNamespaceName& nameSpace,
1564 const CIMName& className)
1565 {
1566 _throw(CIM_ERR_NOT_SUPPORTED, "deleteClass()");
1567 }
1568
1569 void MetaRepository::createClass(
1570 const CIMNamespaceName& nameSpace,
1571 const CIMClass& newClass)
1572 {
1573 _throw(CIM_ERR_NOT_SUPPORTED, "createClass()");
1574 }
1575
1576 void MetaRepository::modifyClass(
1577 mike 1.1.2.1 const CIMNamespaceName& nameSpace,
1578 const CIMClass& newClass)
1579 {
1580 _throw(CIM_ERR_NOT_SUPPORTED, "modifyClass()");
1581 }
1582
|
1583 mike 1.1.2.4 void MetaRepository::getSubClassNames(
1584 const CIMNamespaceName& nameSpace,
1585 const CIMName& className,
1586 Boolean deepInheritance,
1587 Array<CIMName>& subClassNames)
1588 {
1589 printf("===== MetaRepository::getSubClassNames()\n");
1590 _init();
1591
1592 subClassNames = MetaRepository::enumerateClassNames(
1593 nameSpace, className, deepInheritance);
1594 }
1595
1596 void MetaRepository::getSuperClassNames(
1597 const CIMNamespaceName& nameSpace,
1598 const CIMName& className,
1599 Array<CIMName>& superClassNames)
1600 {
1601 printf("===== MetaRepository::getSuperClassNames()\n");
1602 _init();
1603
1604 mike 1.1.2.4 superClassNames.clear();
1605
1606 // Lookup namespace:
1607
1608 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1609
1610 if (!ns)
1611 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1612
1613 // Lookup class:
1614
1615 const MetaClass* mc = _findClass(ns, *Str(className));
1616
1617 if (!mc)
1618 _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));
1619
1620 // Append superclass names:
1621
1622 for (const MetaClass* p = mc->super; p; p = p->super)
1623 superClassNames.append(p->name);
1624 }
1625 mike 1.1.2.4
1626 void MetaRepository::createNameSpace(
1627 const CIMNamespaceName& nameSpace,
1628 const NameSpaceAttributes& attributes)
1629 {
1630 printf("===== MetaRepository::createNameSpace()\n");
1631
1632 _throw(CIM_ERR_NOT_SUPPORTED, "createNameSpace()");
1633 }
1634
1635 void MetaRepository::modifyNameSpace(
1636 const CIMNamespaceName& nameSpace,
1637 const NameSpaceAttributes& attributes)
1638 {
1639 printf("===== MetaRepository::modifyNameSpace()\n");
1640
1641 _throw(CIM_ERR_NOT_SUPPORTED, "modifyNameSpace()");
1642 }
1643
1644 Array<CIMNamespaceName> MetaRepository::enumerateNameSpaces()
1645 {
1646 mike 1.1.2.4 printf("===== MetaRepository::enumerateNameSpaces()\n");
1647 _init();
1648
1649 Array<CIMNamespaceName> nameSpaces;
1650
1651 for (size_t i = 0; i < _nameSpacesSize; i++)
1652 nameSpaces.append(_nameSpaces[i]->name);
1653
1654 return Array<CIMNamespaceName>();
1655 }
1656
1657 void MetaRepository::deleteNameSpace(
1658 const CIMNamespaceName& nameSpace)
1659 {
1660 printf("===== MetaRepository::deleteNameSpace()\n");
1661
1662 _throw(CIM_ERR_NOT_SUPPORTED, "deleteNameSpace()");
1663 }
1664
1665 Boolean MetaRepository::getNameSpaceAttributes(
1666 const CIMNamespaceName& nameSpace,
1667 mike 1.1.2.4 NameSpaceAttributes& attributes)
1668 {
1669 printf("===== MetaRepository::getNameSpaceAttributes()\n");
1670
1671 _throw(CIM_ERR_NOT_SUPPORTED, "getNameSpaceAttributes()");
1672
1673 return false;
1674 }
1675
1676 Boolean MetaRepository::isRemoteNameSpace(
1677 const CIMNamespaceName& nameSpace,
1678 String& remoteInfo)
1679 {
1680 printf("===== MetaRepository::isRemoteNameSpace()\n");
1681
1682 return false;
1683 }
1684
1685 CIMQualifierDecl MetaRepository::getQualifier(
1686 const CIMNamespaceName& nameSpace,
1687 const CIMName& qualifierName)
1688 mike 1.1.2.4 {
1689 printf("===== MetaRepository::getQualifier()\n");
1690 _init();
1691
1692 // Lookup namespace:
1693
1694 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1695
1696 if (!ns)
1697 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1698
1699 // Lookup qualifier:
1700
1701 const MetaQualifierDecl* mqd = _findQualifierDecl(ns, *Str(qualifierName));
1702
1703 if (!mqd)
1704 _throw(CIM_ERR_NOT_FOUND, "unknown qualifier: %s", *Str(qualifierName));
1705
1706 // Make the qualifier declaration:
1707
1708 CIMQualifierDecl cqd;
1709 mike 1.1.2.4
1710 if (_makeQualifierDecl(ns, mqd, cqd) != 0)
1711 {
1712 _throw(CIM_ERR_FAILED, "conversion failed: %s", mqd->name);
1713 }
1714
1715 return cqd;
1716 }
1717
1718 void MetaRepository::setQualifier(
1719 const CIMNamespaceName& nameSpace,
1720 const CIMQualifierDecl& qualifierDecl)
1721 {
1722 printf("===== MetaRepository::setQualifier()\n");
1723
1724 _throw(CIM_ERR_NOT_SUPPORTED, "setQualifier()");
1725
1726 }
1727
1728 void MetaRepository::deleteQualifier(
1729 const CIMNamespaceName& nameSpace,
1730 mike 1.1.2.4 const CIMName& qualifierName)
1731 {
1732 printf("===== MetaRepository::deleteQualifier()\n");
1733
1734 _throw(CIM_ERR_NOT_SUPPORTED, "deleteQualifier()");
1735 }
1736
1737 Array<CIMQualifierDecl> MetaRepository::enumerateQualifiers(
1738 const CIMNamespaceName& nameSpace)
1739 {
1740 printf("===== MetaRepository::enumerateQualifiers()\n");
1741 _init();
1742
1743 // Lookup namespace:
1744
1745 const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
1746
1747 if (!ns)
1748 _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
1749
1750 // Build the array of qualifier declarations:
1751 mike 1.1.2.4
1752 Array<CIMQualifierDecl> result;
1753
1754 for (size_t i = 0; ns->qualifiers[i]; i++)
1755 {
1756 const MetaQualifierDecl* mqd = ns->qualifiers[i];
1757 CIMQualifierDecl cqd;
1758
1759 if (_makeQualifierDecl(ns, mqd, cqd) != 0)
1760 {
1761 _throw(CIM_ERR_FAILED, "conversion failed: %s", mqd->name);
1762 }
1763
1764 result.append(cqd);
1765 }
1766
1767 return result;
1768 }
1769
|
1770 mike 1.1.2.1 PEGASUS_NAMESPACE_END
|