![]() ![]() |
![]() |
File: [Pegasus] / pegasus / src / Pegasus / Repository / Attic / MetaRepository.cpp
(download)
Revision: 1.1.2.2, Tue Oct 2 13:28:38 2007 UTC (16 years, 9 months ago) by mike Branch: TASK-PEP305_VXWORKS-branch Changes since 1.1.2.1: +8 -12 lines PEP#: 305 TITLE: VxWorks Port DESCRIPTION: Ongoing VxWorks porting. |
//%2006//////////////////////////////////////////////////////////////////////// // // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; // IBM Corp.; EMC Corporation, The Open Group. // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // EMC Corporation; VERITAS Software Corporation; The Open Group. // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; // EMC Corporation; Symantec Corporation; The Open Group. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to // deal in the Software without restriction, including without limitation the // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or // sell copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // //============================================================================== // //%///////////////////////////////////////////////////////////////////////////// #include <cstdarg> #include <cassert> #include "MetaRepository.h" #include <Pegasus/Common/System.h> #define TEST_META_REPOSITORY #if defined(TEST_META_REPOSITORY) # include "root_cimv2_namespace.h" # include "root_PG_Internal_namespace.h" # include "root_PG_InterOp_namespace.h" #endif PEGASUS_NAMESPACE_BEGIN static const size_t _MAX_NAMESPACES = 32; static const MetaNameSpace* _nameSpaces[_MAX_NAMESPACES]; static size_t _nameSpacesSize = 0; static const size_t _MAX_FEATURES = 1024; static const size_t _MAX_QUALIFIERS = 1024; #if defined(TEST_META_REPOSITORY) static void _init() { if (_nameSpacesSize == 0) { MetaRepository::addNameSpace(&root_PG_InterOp_namespace); MetaRepository::addNameSpace(&root_cimv2_namespace); MetaRepository::addNameSpace(&root_PG_Internal_namespace); } } #endif static bool _eqi(const char* s1, const char* s2) { return System::strcasecmp(s1, s2) == 0; } //============================================================================== // // Local definitions: // //============================================================================== class Str { public: Str(const String& s) : _cstr(s.getCString()) { } Str(const CIMName& n) : _cstr(n.getString().getCString()) { } Str(const CIMNamespaceName& n) : _cstr(n.getString().getCString()) { } Str(const Exception& e) : _cstr(e.getMessage().getCString()) { } Str(const CIMDateTime& x) : _cstr(x.toString().getCString()) { } Str(const CIMObjectPath& x) : _cstr(x.toString().getCString()) { } const char* operator*() const { return (const char*)_cstr; } operator const char*() const { return (const char*)_cstr; } private: CString _cstr; }; PEGASUS_FORMAT(2, 3) static void _throw(CIMStatusCode code, const char* format, ...) { char buffer[4096]; va_list ap; va_start(ap, format); vsprintf(buffer, format, ap); va_end(ap); throw CIMException(code, buffer); } static const MetaNameSpace* _findNameSpace(const char* name) { for (size_t i = 0; i < _nameSpacesSize; i++) { if (_eqi(_nameSpaces[i]->name, name)) return _nameSpaces[i]; } // Not found! return 0; } static bool _isSubClass(const MetaClass* super, const MetaClass* sub) { if (!super) return true; for (MetaClass* p = sub->super; p; p = p->super) { if (p == super) return true; } return false; } static inline bool _isDirectSubClass( const MetaClass* super, const MetaClass* sub) { return sub->super == super; } static const MetaClass* _findClass( const MetaNameSpace* ns, const char* name) { for (size_t i = 0; ns->classes[i]; i++) { const MetaClass* sc = ns->classes[i]; if (_eqi(sc->name, name)) return sc; } // Not found! return 0; } static inline void _readBoolean(const char*& value, Boolean& x) { unsigned const char* p = (unsigned const char*)value; x = Boolean(p[0]); value++; } static inline void _readUint8(const char*& value, Uint8& x) { unsigned const char* p = (unsigned const char*)value; x = Uint8(p[0]); value += sizeof(x); } static inline void _readSint8(const char*& value, Sint8& x) { _readUint8(value, *((Uint8*)&x)); } static inline void _readUint16(const char*& value, Uint16& x) { unsigned const char* p = (unsigned const char*)value; Uint16 x0 = Uint16(p[0]) << 8; Uint16 x1 = Uint16(p[1]) << 0; x = Uint16(x0 | x1); value += sizeof(x); } static inline void _readSint16(const char*& value, Sint16& x) { _readUint16(value, *((Uint16*)&x)); value += sizeof(x); } static inline void _readUint32(const char*& value, Uint32& x) { unsigned const char* p = (unsigned const char*)value; Uint32 x0 = Uint32(p[0]) << 24; Uint32 x1 = Uint32(p[1]) << 16; Uint32 x2 = Uint32(p[0]) << 8; Uint32 x3 = Uint32(p[1]) << 0; x = Uint32(x0 | x1 | x2 | x3); value += sizeof(x); } static inline void _readSint32(const char*& value, Sint32& x) { _readUint32(value, *((Uint32*)&x)); value += sizeof(x); } static inline void _readUint64(const char*& value, Uint64& x) { unsigned const char* p = (unsigned const char*)value; Uint64 x0 = Uint64(p[0]) << 56; Uint64 x1 = Uint64(p[1]) << 48; Uint64 x2 = Uint64(p[2]) << 40; Uint64 x3 = Uint64(p[3]) << 32; Uint64 x4 = Uint64(p[4]) << 24; Uint64 x5 = Uint64(p[5]) << 16; Uint64 x6 = Uint64(p[6]) << 8; Uint64 x7 = Uint64(p[7]) << 0; x = Uint64(x0 | x1 | x2 | x3 | x4 | x5 | x6 | x7); value += sizeof(x); } static inline void _readSint64(const char*& value, Sint64& x) { _readUint64(value, *((Uint64*)&x)); value += sizeof(x); } static inline void _readReal32(const char*& value, Real32& x) { _readUint32(value, *((Uint32*)&x)); value += sizeof(x); } static inline void _readReal64(const char*& value, Real64& x) { _readUint64(value, *((Uint64*)&x)); value += sizeof(x); } static inline void _readChar16(const char*& value, Char16& x) { _readUint16(value, *((Uint16*)&x)); value += sizeof(x); } static inline void _readString(const char*& value, String& x) { size_t n = strlen(value); x.assign(value, n); value += n + 1; } static inline void _readDateTime(const char*& value, CIMDateTime& x) { size_t n = strlen(value); x.set(value); value += n + 1; } static int _makeValue( CIMValue& cv, Uint16 type, Sint16 subscript, const char* value) { // If null value: if (value == 0) { if (subscript == -1) cv.setNullValue(CIMType(type), false); else cv.setNullValue(CIMType(type), true, subscript); return 0; } // If scalar, else array: if (subscript == -1) { switch (CIMType(type)) { case CIMTYPE_BOOLEAN: { Boolean x; _readBoolean(value, x); cv.set(x); return 0; } case CIMTYPE_UINT8: { Uint8 x; _readUint8(value, x); cv.set(x); return 0; } case CIMTYPE_SINT8: { Sint8 x; _readSint8(value, x); cv.set(x); return 0; } case CIMTYPE_UINT16: { Uint16 x; _readUint16(value, x); cv.set(x); return 0; } case CIMTYPE_SINT16: { Sint16 x; _readSint16(value, x); cv.set(x); return 0; } case CIMTYPE_UINT32: { Uint32 x; _readUint32(value, x); cv.set(x); return 0; } case CIMTYPE_SINT32: { Sint32 x; _readSint32(value, x); cv.set(x); return 0; } case CIMTYPE_UINT64: { Uint64 x; _readUint64(value, x); cv.set(x); return 0; } case CIMTYPE_SINT64: { Sint64 x; _readSint64(value, x); cv.set(x); return 0; } case CIMTYPE_REAL32: { Real32 x; _readReal32(value, x); cv.set(x); return 0; } case CIMTYPE_REAL64: { Real64 x; _readReal64(value, x); cv.set(x); return 0; } case CIMTYPE_CHAR16: { Char16 x; _readChar16(value, x); cv.set(x); return 0; } case CIMTYPE_STRING: { String x; _readString(value, x); cv.set(x); return 0; } case CIMTYPE_DATETIME: { CIMDateTime x; _readDateTime(value, x); cv.set(x); return 0; } default: printf("T[%u]\n", __LINE__); return -1; } } else { // Read array size: Uint16 size; _readUint16(value, size); // Read array elements: switch (CIMType(type)) { case CIMTYPE_BOOLEAN: { Array<Boolean> a; for (Uint16 i = 0; i < size; i++) { Boolean x; _readBoolean(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_UINT8: { Array<Uint8> a; for (Uint16 i = 0; i < size; i++) { Uint8 x; _readUint8(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_SINT8: { Array<Sint8> a; for (Uint16 i = 0; i < size; i++) { Sint8 x; _readSint8(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_UINT16: { Array<Uint16> a; for (Uint16 i = 0; i < size; i++) { Uint16 x; _readUint16(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_SINT16: { Array<Sint16> a; for (Uint16 i = 0; i < size; i++) { Sint16 x; _readSint16(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_UINT32: { Array<Uint32> a; for (Uint16 i = 0; i < size; i++) { Uint32 x; _readUint32(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_SINT32: { Array<Sint32> a; for (Uint16 i = 0; i < size; i++) { Sint32 x; _readSint32(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_UINT64: { Array<Uint64> a; for (Uint16 i = 0; i < size; i++) { Uint64 x; _readUint64(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_SINT64: { Array<Sint64> a; for (Uint16 i = 0; i < size; i++) { Sint64 x; _readSint64(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_REAL32: { Array<Real32> a; for (Uint16 i = 0; i < size; i++) { Real32 x; _readReal32(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_REAL64: { Array<Real64> a; for (Uint16 i = 0; i < size; i++) { Real64 x; _readReal64(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_CHAR16: { Array<Char16> a; for (Uint16 i = 0; i < size; i++) { Char16 x; _readChar16(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_STRING: { Array<String> a; for (Uint16 i = 0; i < size; i++) { String x; _readString(value, x); a.append(x); } cv.set(a); return 0; } case CIMTYPE_DATETIME: { Array<CIMDateTime> a; for (Uint16 i = 0; i < size; i++) { CIMDateTime x; _readDateTime(value, x); a.append(x); } cv.set(a); return 0; } default: printf("T[%u]\n", __LINE__); return -1; } } // Unreachable! printf("T[%u]\n", __LINE__); return -1; } struct FeatureInfo { const MetaFeature* sf; const MetaClass* sc; }; static int _mergeFeatures( const MetaClass* sc, FeatureInfo features[_MAX_FEATURES], size_t& numFeatures) { if (sc->super) { if (_mergeFeatures(sc->super, features, numFeatures) != 0) { printf("T[%u]\n", __LINE__); return -1; } } // Process all features of this class: for (size_t i = 0; sc->features[i]; i++) { const MetaFeature* sf = sc->features[i]; // Override feature if defined by ancestor class: bool found = false; for (size_t j = 0; j < numFeatures; j++) { const MetaFeature* tmp = features[j].sf; if (_eqi(sf->name, tmp->name)) { features[j].sf = sf; features[j].sc = sc; found = true; break; } } // Add new feature if not not defined by ancestor class: if (!found) { if (numFeatures == _MAX_FEATURES) { printf("T[%u]\n", __LINE__); return -1; } features[numFeatures].sf = sf; features[numFeatures].sc = sc; numFeatures++; } } return 0; } struct QualifierInfo { const char* qualifier; const MetaClass* sc; }; static const MetaFeature* _findFeature( const MetaClass* sc, const char* name) { for (size_t i = 0; sc->features[i]; i++) { const MetaFeature* sf = sc->features[i]; if (_eqi(sf->name, name)) return sf; } // Not found! return 0; } static const MetaFeature* _findParameter( const MetaMethod* sm, const char* name) { for (size_t i = 0; sm->parameters[i]; i++) { const MetaFeature* sf = sm->parameters[i]; if (_eqi(sm->name, name)) return sf; } // Not found! return 0; } static int _mergeQualifiers( const MetaNameSpace* ns, const MetaClass* sc, const char* featureName, const char* parameterName, bool depth, QualifierInfo qualifiers[_MAX_QUALIFIERS], size_t& numQualifiers) { // Merge super-class qualifiers: if (sc->super) { _mergeQualifiers(ns, sc->super, featureName, parameterName, depth + 1, qualifiers, numQualifiers); } const char** quals = 0; // Find qualifiers of the given object: if (!featureName && !parameterName) { // Case 1: get class qualifiers: quals = sc->qualifiers; } else if (featureName && !parameterName) { // Case 2: get feature qualifiers: const MetaFeature* sf = _findFeature(sc, featureName); if (sf) quals = sf->qualifiers; } else if (featureName && parameterName) { // Case 3: get parameter qualifiers: const MetaFeature* sf = _findFeature(sc, featureName); if (sf && (sf->flags & META_FLAG_METHOD)) { const MetaMethod* sm = (const MetaMethod*)sf; const MetaFeature* p = _findParameter(sm, parameterName); if (p) quals = p->qualifiers; } } // Merge quals into the qualifiers array: if (!quals) return 0; for (size_t i = 0; quals[i]; i++) { const char* qi = quals[i]; // Override existing qualifier if any: bool found = false; for (size_t j = 0; j < numQualifiers; j++) { const char* qj = qualifiers[j].qualifier; if (qi[0] == qj[0]) { qualifiers[j].qualifier = qi; qualifiers[j].sc = sc; found = true; break; } } // Inject this qualifier not found: if (!found) { MetaQualifierDecl* qd = ns->qualifiers[qi[0]]; if (depth == 0 || !(qd->flavor & META_FLAVOR_RESTRICTED)) { if (numQualifiers == _MAX_QUALIFIERS) { printf("T[%u]\n", __LINE__); return -1; } qualifiers[numQualifiers].qualifier = qi; qualifiers[numQualifiers].sc = sc; numQualifiers++; } } } return 0; } template<class C> static int _addQualifiers( const MetaNameSpace* ns, const MetaClass* sc, const char* featureName, const char* parameterName, C& c) { QualifierInfo qualifiers[_MAX_QUALIFIERS]; size_t numQualifiers = 0; if (_mergeQualifiers( ns, sc, featureName, parameterName, 0, qualifiers, numQualifiers) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add qualifiers to container: for (size_t i = 0; i < numQualifiers; i++) { const char* q = qualifiers[i].qualifier; // Get qualifier id: Uint8 qid = Uint8(q[0]); // Get qualifier declaration: MetaQualifierDecl* qd = ns->qualifiers[qid]; // Make CIMValue: CIMValue cv; if (_makeValue(cv, qd->type, qd->subscript, q + 1) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add qualifier: c.addQualifier(CIMQualifier(qd->name, cv)); } return 0; } static int _addProperty( const MetaNameSpace* ns, const MetaClass* sc, const MetaProperty* sp, const char* classOrigin, bool propagated, CIMClass& cc) { // Make CIMvalue: CIMValue cv; if (_makeValue(cv, sp->type, sp->subscript, sp->value) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Create property: CIMProperty cp(sp->name, cv); cp.setClassOrigin(classOrigin); cp.setPropagated(propagated); // Add qualifiers: if (_addQualifiers(ns, sc, sp->name, 0, cp) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add to class: cc.addProperty(cp); return 0; } static int _addReference( const MetaNameSpace* ns, const MetaClass* sc, const MetaReference* sr, const char* classOrigin, bool propagated, CIMClass& cc) { // Set isArray and arraySize: Boolean isArray; Uint32 arraySize; if (sr->subscript == -1) { isArray = false; arraySize = 0; } else { isArray = true; arraySize = sr->subscript; } // Set referenceClassName: CIMName rcn = sr->ref->name; // Create value: CIMValue cv(CIMTYPE_REFERENCE, isArray, arraySize); // Create property: CIMProperty cp(sr->name, cv, arraySize, rcn, classOrigin, propagated); // Add qualifiers: if (_addQualifiers(ns, sc, sr->name, 0, cp) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add to class: cc.addProperty(cp); return 0; } static int _addPropertyParameter( const MetaNameSpace* ns, const MetaClass* sc, const MetaMethod* sm, const MetaProperty* sp, CIMMethod& cm) { // Create property: bool isArray; Uint32 arraySize; if (sp->subscript == -1) { isArray = false; arraySize = 0; } else { isArray = true; arraySize = Uint32(sp->subscript); } CIMParameter cp(sp->name, CIMType(sp->type), isArray, arraySize); // Add qualifiers: if (_addQualifiers(ns, sc, sm->name, sp->name, cm) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add to method: cm.addParameter(cp); return 0; } static int _addReferenceParameter( const MetaNameSpace* ns, const MetaClass* sc, const MetaMethod* sm, const MetaReference* sr, CIMMethod& cm) { // Create property: bool isArray; Uint32 arraySize; if (sr->subscript == -1) { isArray = false; arraySize = 0; } else { isArray = true; arraySize = Uint32(sr->subscript); } CIMName rcn = sr->ref->name; CIMParameter cp(sr->name, CIMTYPE_REFERENCE, isArray, arraySize, rcn); // Add qualifiers: if (_addQualifiers(ns, sc, sm->name, sr->name, cm) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add to method: cm.addParameter(cp); return 0; } static int _addMethod( const MetaNameSpace* ns, const MetaClass* sc, const MetaMethod* sm, const char* classOrigin, bool propagated, CIMClass& cc) { // Create method: CIMMethod cm(sm->name, CIMType(sm->type)); cm.setClassOrigin(classOrigin); cm.setPropagated(propagated); // Add parameters: for (size_t i = 0; sm->parameters[i]; i++) { MetaFeature* sf = sm->parameters[i]; if (sf->flags & META_FLAG_PROPERTY) { MetaProperty* sp = (MetaProperty*)sf; _addPropertyParameter(ns, sc, sm, sp, cm); } else if (sf->flags & META_FLAG_REFERENCE) { MetaReference* sr = (MetaReference*)sf; _addReferenceParameter(ns, sc, sm, sr, cm); } } // Add qualifiers: if (_addQualifiers(ns, sc, sm->name, 0, cm) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Add to class: cc.addMethod(cm); return 0; } static int _addFeatures( const MetaNameSpace* ns, const MetaClass* sc, CIMClass& cc) { // Merge features from all inheritance levels into a single array: FeatureInfo features[_MAX_FEATURES]; size_t numFeatures = 0; if (_mergeFeatures(sc, features, numFeatures) != 0) { printf("T[%u]\n", __LINE__); return -1; } // For each feature: for (size_t i = 0; i < numFeatures; i++) { const FeatureInfo& fi = features[i]; // Set propagated flag: bool propagated = fi.sc != sc; // Set classOrigin: const char* classOrigin = fi.sc->name; // Add the feature: const MetaFeature* sf = fi.sf; if (sf->flags & META_FLAG_PROPERTY) { MetaProperty* sp = (MetaProperty*)sf; if (_addProperty(ns, sc, sp, classOrigin, propagated, cc) != 0) { printf("T[%u]\n", __LINE__); return -1; } } else if (sf->flags & META_FLAG_REFERENCE) { MetaReference* sr = (MetaReference*)sf; if (_addReference(ns, sc, sr, classOrigin, propagated, cc) != 0) { printf("T[%u]\n", __LINE__); return -1; } } else if (sf->flags & META_FLAG_METHOD) { MetaMethod* sm = (MetaMethod*)sf; if (_addMethod(ns, sc, sm, classOrigin, propagated, cc) != 0) { printf("T[%u]\n", __LINE__); return -1; } } } return 0; } static int _makeClass( const MetaNameSpace* ns, CIMClass& cc, const MetaClass* sc) { try { // Create class: { CIMName scn; if (sc->super) scn = sc->super->name; cc = CIMClass(sc->name, scn); } // Add qualifiers: if (_addQualifiers(ns, sc, 0, 0, cc) != 0) { printf("T[%u]\n", __LINE__); return -1; } // Features: if (_addFeatures(ns, sc, cc) != 0) { printf("T[%u]\n", __LINE__); return -1; } } catch (Exception& e) { printf("EXCEPTION[%s]\n", *Str(e)); return -1; } catch (...) { printf("T[%u]\n", __LINE__); return -1; } return 0; } //============================================================================== // // class MetaRepository // //============================================================================== MetaRepository::MetaRepository() { } MetaRepository::~MetaRepository() { } bool MetaRepository::addNameSpace(const MetaNameSpace* nameSpace) { if (_nameSpacesSize == _MAX_NAMESPACES || !nameSpace) return false; for (size_t i = 0; i < _nameSpacesSize; i++) { if (_eqi(_nameSpaces[i]->name, nameSpace->name)) return false; } _nameSpaces[_nameSpacesSize++] = nameSpace; return true; } CIMClass MetaRepository::getClass( const CIMNamespaceName& nameSpace, const CIMName& className, Boolean localOnly, Boolean includeQualifiers, Boolean includeClassOrigin, const CIMPropertyList& propertyList) { return CIMClass(); } Array<CIMClass> MetaRepository::enumerateClasses( const CIMNamespaceName& nameSpace, const CIMName& className, Boolean deepInheritance, Boolean localOnly, Boolean includeQualifiers, Boolean includeClassOrigin) { #if defined(TEST_META_REPOSITORY) _init(); #endif printf("MetaRepository::enumerateClasses()\n"); // Lookup namespace: const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace)); if (!ns) _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)); // Lookup class: const MetaClass* super = 0; if (!className.isNull()) { super = _findClass(ns, *Str(className)); if (!super) _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)); } // Iterate all classes looking for matches: Array<CIMClass> result; for (size_t i = 0; ns->classes[i]; i++) { MetaClass* sc = ns->classes[i]; // printf("CLASSNAME[%s]\n", sc->name); if (deepInheritance) { if (_isSubClass(super, sc)) { CIMClass cc; if (_makeClass(ns, cc, sc) != 0) _throw(CIM_ERR_FAILED, "conversion failed: %s", sc->name); else result.append(cc); } } else { if (_isDirectSubClass(super, sc)) { CIMClass cc; if (_makeClass(ns, cc, sc) != 0) _throw(CIM_ERR_FAILED, "conversion failed: %s", sc->name); else result.append(cc); } } } return result; } Array<CIMName> MetaRepository::enumerateClassNames( const CIMNamespaceName& nameSpace, const CIMName& className, Boolean deepInheritance) { // Lookup namespace: const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace)); if (!ns) _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)); // Lookup class: const MetaClass* super = 0; if (!className.isNull()) { super = _findClass(ns, *Str(className)); if (!super) _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)); } // Iterate all classes looking for matches: Array<CIMName> result; for (size_t i = 0; ns->classes[i]; i++) { MetaClass* sc = ns->classes[i]; if (deepInheritance) { if (_isSubClass(super, sc)) result.append(sc->name); } else { if (_isDirectSubClass(super, sc)) result.append(sc->name); } } return result; } void MetaRepository::deleteClass( const CIMNamespaceName& nameSpace, const CIMName& className) { _throw(CIM_ERR_NOT_SUPPORTED, "deleteClass()"); } void MetaRepository::createClass( const CIMNamespaceName& nameSpace, const CIMClass& newClass) { _throw(CIM_ERR_NOT_SUPPORTED, "createClass()"); } void MetaRepository::modifyClass( const CIMNamespaceName& nameSpace, const CIMClass& newClass) { _throw(CIM_ERR_NOT_SUPPORTED, "modifyClass()"); } PEGASUS_NAMESPACE_END
No CVS admin address has been configured |
Powered by ViewCVS 0.9.2 |