pegasus/src/Pegasus/Repository/MetaRepository.cpp - annotate

Return to MetaRepository.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Repository

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

No CVS admin address has been configured