(file) Return to MetaRepository.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Repository / Attic

Diff for /pegasus/src/Pegasus/Repository/Attic/MetaRepository.cpp between version 1.1.2.3 and 1.1.2.11

version 1.1.2.3, 2007/10/02 15:40:30 version 1.1.2.11, 2007/11/03 22:42:34
Line 35 
Line 35 
 #include <cassert> #include <cassert>
 #include "MetaRepository.h" #include "MetaRepository.h"
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
   #include <Pegasus/Common/Once.h>
 #define TEST_META_REPOSITORY  #include "MetaTypes.h"
   
 #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 PEGASUS_NAMESPACE_BEGIN
  
 static const size_t _MAX_NAMESPACES = 32;  typedef const MetaClass* ConstMetaClassPtr;
 static const MetaNameSpace* _nameSpaces[_MAX_NAMESPACES];  #define PEGASUS_ARRAY_T ConstMetaClassPtr
 static size_t _nameSpacesSize = 0;  # include <Pegasus/Common/ArrayInter.h>
   # include <Pegasus/Common/ArrayImpl.h>
   #undef PEGASUS_ARRAY_T
   
   //
   // Callback function and client data used to obtain namespaces from client.
   //
   static const MetaNameSpace* const* _nameSpaces;
  
 static const size_t _MAX_FEATURES = 1024;  static const size_t _MAX_FEATURES = 128;
 static const size_t _MAX_QUALIFIERS = 1024;  static const size_t _MAX_QUALIFIERS = 128;
  
 #if defined(TEST_META_REPOSITORY)  class ThrowContext
 static void _init()  
 { {
     if (_nameSpacesSize == 0)  public:
   
       PEGASUS_FORMAT(3, 4)
       ThrowContext(CIMStatusCode code_, const char* format, ...) : code(code_)
     {     {
         MetaRepository::addNameSpace(&root_PG_InterOp_namespace);          char buffer[1024];
         MetaRepository::addNameSpace(&root_cimv2_namespace);          va_list ap;
         MetaRepository::addNameSpace(&root_PG_Internal_namespace);          va_start(ap, format);
     }          vsprintf(buffer, format, ap);
           va_end(ap);
           msg = buffer;
 } }
 #endif      CIMStatusCode code;
       String msg;
   };
   
   #define Throw(ARGS) \
       do \
       { \
           ThrowContext c ARGS; \
           throw CIMException(c.code, c.msg); \
       } \
       while (0)
  
 static bool _eqi(const char* s1, const char* s2) static bool _eqi(const char* s1, const char* s2)
 { {
     return System::strcasecmp(s1, s2) == 0;     return System::strcasecmp(s1, s2) == 0;
 } }
  
 //==============================================================================  
 //  
 // Local definitions:  
 //  
 //==============================================================================  
   
 class Str class Str
 { {
 public: public:
Line 91 
Line 100 
     CString _cstr;     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) static const MetaNameSpace* _findNameSpace(const char* name)
 { {
     for (size_t i = 0; i < _nameSpacesSize; i++)      if (!_nameSpaces)
           return 0;
   
       for (const MetaNameSpace* const* p = _nameSpaces; *p; p++)
     {     {
         if (_eqi(_nameSpaces[i]->name, name))          const MetaNameSpace* ns = *p;
             return _nameSpaces[i];  
           if (_eqi(ns->name, name))
               return ns;
     }     }
  
     // Not found!     // Not found!
Line 136 
Line 138 
     return sub->super == super;     return sub->super == super;
 } }
  
 static const MetaClass* _findClass(  static char** _makePropertyList(const CIMPropertyList& propertyList)
     const MetaNameSpace* ns,  
     const char* name)  
 {  
     for (size_t i = 0; ns->classes[i]; i++)  
     {  
         const MetaClass* mc = ns->classes[i];  
   
         if (_eqi(mc->name, name))  
             return mc;  
     }  
   
     // 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* mf;  
     const MetaClass* mc;  
 };  
   
 static int _mergeFeatures(  
     const MetaClass* mc,  
     bool localOnly,  
     FeatureInfo features[_MAX_FEATURES],  
     size_t& numFeatures)  
 {  
     if (!localOnly && mc->super)  
     {  
         if (_mergeFeatures(mc->super, localOnly, features, numFeatures) != 0)  
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }  
     }  
   
     // Process all features of this class:  
   
     for (size_t i = 0; mc->features[i]; i++)  
     {  
         const MetaFeature* mf = mc->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].mf;  
   
             if (_eqi(mf->name, tmp->name))  
             {  
                 features[j].mf = mf;  
                 features[j].mc = mc;  
                 found = true;  
                 break;  
             }  
         }  
   
         // Add new feature if not not defined by ancestor class:  
   
         if (!found)  
         {  
             if (numFeatures == _MAX_FEATURES)  
             {             {
                 printf("T[%u]\n", __LINE__);      if (propertyList.isNull())
                 return -1;  
             }  
   
             features[numFeatures].mf = mf;  
             features[numFeatures].mc = mc;  
             numFeatures++;  
         }  
     }  
   
     return 0;     return 0;
 }  
   
 struct QualifierInfo  
 {  
     const char* qualifier;  
     const MetaClass* mc;  
 };  
   
 static const MetaFeature* _findFeature(  
     const MetaClass* mc,  
     const char* name)  
 {  
     for (size_t i = 0; mc->features[i]; i++)  
     {  
         const MetaFeature* mf = mc->features[i];  
   
         if (_eqi(mf->name, name))  
             return mf;  
     }  
  
     // Not found!      size_t size = propertyList.size();
     return 0;      char** pl = (char**)malloc(sizeof(char*) * (size + 1));
 }  
  
 static const MetaFeature* _findParameter(      for (size_t i = 0; i < size; i++)
     const MetaMethod* mm,          pl[i] = strdup(*Str(propertyList[i]));
     const char* name)  
 {  
     for (size_t i = 0; mm->parameters[i]; i++)  
     {  
         const MetaFeature* mf = mm->parameters[i];  
  
         if (_eqi(mm->name, name))      pl[size] = 0;
             return mf;  
     }  
  
     // Not found!      return pl;
     return 0;  
 } }
  
 static int _mergeQualifiers(  static void _freePropertyList(char** pl)
     const MetaNameSpace* ns,  
     const MetaClass* mc,  
     const char* featureName,  
     const char* parameterName,  
     bool depth,  
     QualifierInfo qualifiers[_MAX_QUALIFIERS],  
     size_t& numQualifiers)  
 {  
     // Merge super-class qualifiers:  
   
     if (mc->super)  
     {     {
         _mergeQualifiers(ns, mc->super, featureName, parameterName, depth + 1,      if (!pl)
             qualifiers, numQualifiers);          return;
     }  
   
     const char** quals = 0;  
   
     // Find qualifiers of the given object:  
  
     if (!featureName && !parameterName)      for (size_t i = 0; pl[i]; i++)
     {  
         // Case 1: get class qualifiers:  
         quals = mc->qualifiers;  
     }  
     else if (featureName && !parameterName)  
     {     {
         // Case 2: get feature qualifiers:          free(pl[i]);
   
         const MetaFeature* mf = _findFeature(mc, featureName);  
   
         if (mf)  
             quals = mf->qualifiers;  
     }     }
     else if (featureName && parameterName)  
     {  
         // Case 3: get parameter qualifiers:  
   
         const MetaFeature* mf = _findFeature(mc, featureName);  
  
         if (mf && (mf->flags & META_FLAG_METHOD))      free(pl);
         {  
             const MetaMethod* mm = (const MetaMethod*)mf;  
             const MetaFeature* p = _findParameter(mm, parameterName);  
   
             if (p)  
                 quals = p->qualifiers;  
         }  
     }     }
  
     // Merge quals into the qualifiers array:  static void _printPropertyList(const char* const* pl)
   
     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 (!pl)
           return;
  
             if (qi[0] == qj[0])      for (size_t i = 0; pl[i]; i++)
             {          printf("pl[%s]\n", pl[i]);
                 qualifiers[j].qualifier = qi;  
                 qualifiers[j].mc = mc;  
                 found = true;  
                 break;  
             }  
         }         }
  
         // Inject this qualifier not found:  static bool _contains(const Array<const MetaClass*>& x, const MetaClass* mc)
   
         if (!found)  
         {         {
             MetaQualifierDecl* qd = ns->qualifiers[qi[0]];      Uint32 n = x.size();
       const MetaClass* const* p = x.getData();
  
             if (depth == 0 || !(qd->flavor & META_FLAVOR_RESTRICTED))      while (n--)
             {  
                 if (numQualifiers == _MAX_QUALIFIERS)  
                 {                 {
                     printf("T[%u]\n", __LINE__);          if (*p++ == mc)
                     return -1;              return true;
                 }  
   
                 qualifiers[numQualifiers].qualifier = qi;  
                 qualifiers[numQualifiers].mc = mc;  
                 numQualifiers++;  
             }  
         }  
     }     }
  
     return 0;      return false;
 } }
  
 template<class C>  static void _associators(
 static int _addQualifiers(  
     const MetaNameSpace* ns,     const MetaNameSpace* ns,
     const MetaClass* mc,      const CIMName& className,
     const char* featureName,      const CIMName& assocClass,
     const char* parameterName,      const CIMName& resultClass,
     C& c)      const String& role,
 {      const String& resultRole,
     QualifierInfo qualifiers[_MAX_QUALIFIERS];      Array<const MetaClass*>& result)
     size_t numQualifiers = 0;  
   
     if (_mergeQualifiers(  
         ns, mc, 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;      // Lookup source class:
  
         // Get qualifier id:      const MetaClass* mc = FindClass(ns, *Str(className));
  
         Uint8 qid = Uint8(q[0]);      if (!mc)
           Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
         // Get qualifier declaration:  
  
         MetaQualifierDecl* qd = ns->qualifiers[qid];  
  
         // Make CIMValue:      // Lookup result class (if any).
  
         CIMValue cv;      const MetaClass* rmc = 0;
  
         if (_makeValue(cv, qd->type, qd->subscript, q + 1) != 0)      if (!resultClass.isNull())
         {         {
             printf("T[%u]\n", __LINE__);          rmc = FindClass(ns, *Str(resultClass));
             return -1;  
         }  
   
         // Add qualifier:  
  
         c.addQualifier(CIMQualifier(qd->name, cv));          if (!rmc)
               Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass)));
     }     }
  
     return 0;      // Convert these to UTF8 now to avoid doing so in loop below.
 }  
  
 static int _addProperty(      Str ac(assocClass);
     const MetaNameSpace* ns,      Str r(role);
     const MetaClass* mc,      Str rr(resultRole);
     const MetaProperty* mp,  
     const char* classOrigin,  
     bool propagated,  
     bool includeQualifiers,  
     bool includeClassOrigin,  
     CIMClass& cc)  
 {  
     // Make CIMvalue:  
  
     CIMValue cv;      // Process association classes:
  
     if (_makeValue(cv, mp->type, mp->subscript, mp->value) != 0)      for (size_t i = 0; ns->classes[i]; i++)
     {     {
         printf("T[%u]\n", __LINE__);          MetaClass* amc = ns->classes[i];
         return -1;  
     }  
   
     // Create property:  
   
     CIMProperty cp(mp->name, cv);  
   
     if (includeClassOrigin)  
         cp.setClassOrigin(classOrigin);  
   
     cp.setPropagated(propagated);  
  
     // Add qualifiers:          // Skip non-association classes:
  
     if (includeQualifiers)          if (!(amc->flags & META_FLAG_ASSOCIATION))
     {              continue;
         if (_addQualifiers(ns, mc, mp->name, 0, cp) != 0)  
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }  
     }  
  
     // Add to class:          // Filter by assocClass parameter:
  
     cc.addProperty(cp);          if (!assocClass.isNull() && !_eqi(ac, amc->name))
     return 0;              continue;
 }  
  
 static int _addReference(          // Process reference properties:
     const MetaNameSpace* ns,  
     const MetaClass* mc,  
     const MetaReference* mr,  
     const char* classOrigin,  
     bool propagated,  
     bool includeQualifiers,  
     bool includeClassOrigin,  
     CIMClass& cc)  
 {  
     // Set isArray and arraySize:  
  
     Boolean isArray;          MetaFeatureInfo features[META_MAX_FEATURES];
     Uint32 arraySize;          size_t size = 0;
           MergeFeatures(amc, false, META_FLAG_REFERENCE, features, size);
  
     if (mr->subscript == -1)          for (size_t j = 0; j < size; j++)
     {  
         isArray = false;  
         arraySize = 0;  
     }  
     else  
     {     {
         isArray = true;              const MetaFeature* mf = features[j].mf;
         arraySize = mr->subscript;  
     }  
   
     // Set referenceClassName:  
  
     CIMName rcn = mr->ref->name;              // Skip non references:
  
     // Create value:              if (!(mf->flags & META_FLAG_REFERENCE))
                   continue;
  
     CIMValue cv(CIMTYPE_REFERENCE, isArray, arraySize);              const MetaReference* mr = (const MetaReference*)mf;
  
     // Create property:              // Filter by role parameter.
  
     CIMProperty cp(mr->name, cv, arraySize, rcn);              if (role.size() && !_eqi(r, mf->name))
                   continue;
  
     if (includeClassOrigin)              // Filter by source class:
         cp.setClassOrigin(classOrigin);  
  
     cp.setPropagated(propagated);              if (!IsA(mr->ref, mc))
                   continue;
  
     // Add qualifiers:              // Process result reference:
  
     if (includeQualifiers)              for (size_t k = 0; k < size; k++)
     {     {
         if (_addQualifiers(ns, mc, mr->name, 0, cp) != 0)                  const MetaFeature* rmf = features[k].mf;
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }  
     }  
   
     // Add to class:  
  
     cc.addProperty(cp);                  // Skip the feature under consideration:
     return 0;  
 }  
  
 static int _addPropertyParameter(                  if (rmf == mf)
     const MetaNameSpace* ns,                      continue;
     const MetaClass* mc,  
     const MetaMethod* mm,  
     const MetaProperty* mp,  
     bool includeQualifiers,  
     CIMMethod& cm)  
 {  
     // Create property:  
  
     bool isArray;                  // Skip non references:
     Uint32 arraySize;  
  
     if (mp->subscript == -1)                  if (!(rmf->flags & META_FLAG_REFERENCE))
     {                      continue;
         isArray = false;  
         arraySize = 0;  
     }  
     else  
     {  
         isArray = true;  
         arraySize = Uint32(mp->subscript);  
     }  
  
     CIMParameter cp(mp->name, CIMType(mp->type), isArray, arraySize);                  const MetaReference* rmr = (const MetaReference*)rmf;
  
     // Add qualifiers:                  // Filter by resultRole parameter.
  
     if (includeQualifiers)                  if (resultRole.size() && !_eqi(rr, rmf->name))
     {                      continue;
         if (_addQualifiers(ns, mc, mm->name, mp->name, cm) != 0)  
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }  
     }  
  
     // Add to method:                  // Skip references not of the result class kind:
  
     cm.addParameter(cp);                  if (rmc && !IsA(rmr->ref, rmc))
     return 0;                      continue;
 }  
  
 static int _addReferenceParameter(                  // ATTN: should we include entire class hierarchy under
     const MetaNameSpace* ns,                  // result class?
     const MetaClass* mc,  
     const MetaMethod* mm,  
     const MetaReference* mr,  
     bool includeQualifiers,  
     CIMMethod& cm)  
 {  
     // Create property:  
  
     bool isArray;                  // If reached, then save this one.
     Uint32 arraySize;  
  
     if (mr->subscript == -1)                  if (!_contains(result, rmr->ref))
     {                      result.append(rmr->ref);
         isArray = false;  
         arraySize = 0;  
     }     }
     else  
     {  
         isArray = true;  
         arraySize = Uint32(mr->subscript);  
     }  
   
     CIMName rcn = mr->ref->name;  
     CIMParameter cp(mr->name, CIMTYPE_REFERENCE, isArray, arraySize, rcn);  
   
     // Add qualifiers:  
   
     if (includeQualifiers)  
     {  
         if (_addQualifiers(ns, mc, mm->name, mr->name, cm) != 0)  
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }         }
     }     }
   
     // Add to method:  
   
     cm.addParameter(cp);  
     return 0;  
 } }
  
 static int _addMethod(  static void _references(
     const MetaNameSpace* ns,     const MetaNameSpace* ns,
     const MetaClass* mc,      const CIMName& className,
     const MetaMethod* mm,      const CIMName& resultClass,
     const char* classOrigin,      const String& role,
     bool propagated,      Array<const MetaClass*>& result)
     bool includeQualifiers,  
     bool includeClassOrigin,  
     CIMClass& cc)  
 {  
     // Create method:  
   
     CIMMethod cm(mm->name, CIMType(mm->type));  
   
     if (includeClassOrigin)  
         cm.setClassOrigin(classOrigin);  
   
     cm.setPropagated(propagated);  
   
     // Add parameters:  
   
     for (size_t i = 0; mm->parameters[i]; i++)  
     {  
         MetaFeature* mf = mm->parameters[i];  
   
         if (mf->flags & META_FLAG_PROPERTY)  
         {  
             MetaProperty* mp = (MetaProperty*)mf;  
             _addPropertyParameter(ns, mc, mm, mp, includeQualifiers, cm);  
         }  
         else if (mf->flags & META_FLAG_REFERENCE)  
         {         {
             MetaReference* mr = (MetaReference*)mf;      // Lookup source class:
             _addReferenceParameter(ns, mc, mm, mr, includeQualifiers, cm);  
         }  
     }  
  
     // Add qualifiers:      const MetaClass* mc = FindClass(ns, *Str(className));
  
     if (includeQualifiers)      if (!mc)
     {          Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
         if (_addQualifiers(ns, mc, mm->name, 0, cm) != 0)  
         {  
             printf("T[%u]\n", __LINE__);  
             return -1;  
         }  
     }  
  
     // Add to class:      // Lookup result class (if any).
  
     cc.addMethod(cm);      const MetaClass* rmc = 0;
     return 0;  
 }  
  
 static bool _hasProperty(const char* const* propertyList, const char* name)      if (!resultClass.isNull())
 {  
     for (size_t i = 0; propertyList[i]; i++)  
     {     {
         if (_eqi(propertyList[i], name))          rmc = FindClass(ns, *Str(resultClass));
             return true;  
     }  
  
     return false;          if (!rmc)
               Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(resultClass)));
 } }
  
 static int _addFeatures(      // Convert these to UTF8 now to avoid doing so in loop below.
     const MetaNameSpace* ns,  
     const MetaClass* mc,  
     bool localOnly,  
     bool includeQualifiers,  
     bool includeClassOrigin,  
     const char* const* propertyList,  
     CIMClass& cc)  
 {  
     // Merge features from all inheritance levels into a single array:  
  
     FeatureInfo features[_MAX_FEATURES];      Str r(role);
     size_t numFeatures = 0;  
   
     if (_mergeFeatures(mc, localOnly, features, numFeatures) != 0)  
     {  
         printf("T[%u]\n", __LINE__);  
         return -1;  
     }  
  
     // For each feature:      // Process association classes:
  
     for (size_t i = 0; i < numFeatures; i++)      for (size_t i = 0; ns->classes[i]; i++)
     {     {
         const FeatureInfo& fi = features[i];          MetaClass* amc = ns->classes[i];
   
         // Set propagated flag:  
   
         bool propagated = fi.mc != mc;  
  
         // Set classOrigin:          // Skip non-association classes:
  
         const char* classOrigin = fi.mc->name;          if (!(amc->flags & META_FLAG_ASSOCIATION))
   
         // Skip feature not in property list:  
   
         const MetaFeature* mf = fi.mf;  
   
         if (propertyList && !_hasProperty(propertyList, mf->name))  
             continue;             continue;
  
         // Add the feature:          // Filter by result class:
  
         if (mf->flags & META_FLAG_PROPERTY)          if (rmc && !IsA(rmc, amc))
         {              continue;
             MetaProperty* mp = (MetaProperty*)mf;  
  
             if (_addProperty(ns, mc, mp, classOrigin, propagated,          // Process reference properties:
                 includeQualifiers, includeClassOrigin, cc) != 0)  
             {  
                 printf("T[%u]\n", __LINE__);  
                 return -1;  
             }  
         }  
         else if (mf->flags & META_FLAG_REFERENCE)  
         {  
             MetaReference* mr = (MetaReference*)mf;  
  
             if (_addReference(ns, mc, mr, classOrigin, propagated,          MetaFeatureInfo features[META_MAX_FEATURES];
                 includeQualifiers, includeClassOrigin, cc) != 0)          size_t size = 0;
             {          MergeFeatures(amc, false, META_FLAG_REFERENCE, features, size);
                 printf("T[%u]\n", __LINE__);  
                 return -1;  
             }  
         }  
         else if (mf->flags & META_FLAG_METHOD)  
         {  
             MetaMethod* mm = (MetaMethod*)mf;  
  
             if (_addMethod(ns, mc, mm, classOrigin, propagated,          for (size_t j = 0; j < size; j++)
                 includeQualifiers, includeClassOrigin, cc) != 0)  
             {             {
                 printf("T[%u]\n", __LINE__);              const MetaFeature* mf = features[j].mf;
                 return -1;  
             }  
         }  
     }  
  
     return 0;              // Skip non references:
 }  
  
 static int _makeClass(              if (!(mf->flags & META_FLAG_REFERENCE))
     const MetaNameSpace* ns,                  continue;
     const MetaClass* mc,  
     Boolean localOnly,  
     Boolean includeQualifiers,  
     Boolean includeClassOrigin,  
     const char* const* propertyList,  
     CIMClass& cc)  
 {  
     try  
     {  
         // Create class:  
         {  
             CIMName scn;  
   
             if (mc->super)  
                 scn = mc->super->name;  
   
             cc = CIMClass(mc->name, scn);  
         }  
   
         // Add qualifiers:  
  
         if (includeQualifiers)              const MetaReference* mr = (const MetaReference*)mf;
         {  
             if (_addQualifiers(ns, mc, 0, 0, cc) != 0)  
             {  
                 printf("T[%u]\n", __LINE__);  
                 return -1;  
             }  
         }  
  
         // Features:              // Filter by role parameter.
  
         if (_addFeatures(ns, mc, localOnly, includeQualifiers,              if (role.size() && !_eqi(r, mf->name))
             includeClassOrigin, propertyList, cc) != 0)                  continue;
         {  
             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;  
 }  
   
 static char** _makePropertyList(const CIMPropertyList& propertyList)  
 {  
     if (propertyList.isNull())  
         return 0;  
  
     size_t size = propertyList.size();              // Filter by source class:
     char** pl = (char**)malloc(sizeof(char*) * (size + 1));  
  
     for (size_t i = 0; i < size; i++)              if (!IsA(mr->ref, mc))
         pl[i] = strdup(*Str(propertyList[i]));                  continue;
  
     pl[size] = 0;              // Add this one to the output:
  
     return pl;              if (!_contains(result, amc))
                   result.append((MetaClass*)amc);
           }
       }
 } }
  
 static void _freePropertyList(char** pl)  //==============================================================================
 {  //
     if (!pl)  // _getHostName()
         return;  //
   //==============================================================================
  
     for (size_t i = 0; pl[i]; i++)  static Once _once = PEGASUS_ONCE_INITIALIZER;
     {  static const char* _hostName = 0;
         free(pl[i]);  
     }  
  
     free(pl);  static void _initHostName()
   {
       String hn = System::getHostName();
       _hostName = strdup(*Str(hn));
 } }
  
 static void _printPropertyList(const char* const* pl)  static inline const char* _getHostName()
 { {
     if (!pl)      once(&_once, _initHostName);
         return;      return _hostName;
   
     for (size_t i = 0; pl[i]; i++)  
         printf("pl[%s]\n", pl[i]);  
 } }
  
 //============================================================================== //==============================================================================
Line 1301 
Line 424 
 { {
 } }
  
 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( CIMClass MetaRepository::getClass(
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className,     const CIMName& className,
Line 1324 
Line 432 
     Boolean includeClassOrigin,     Boolean includeClassOrigin,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     printf("===== MetaRepository::getClass()\n");  
   
     // ATTN-MEB: propertyList ignored!  
   
 #if defined(TEST_META_REPOSITORY)  
     _init();  
 #endif  
   
     // Lookup namespace:     // Lookup namespace:
  
     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
  
     if (!ns)     if (!ns)
         _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));          Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
  
     // Lookup class:     // Lookup class:
  
     const MetaClass* mc = _findClass(ns, *Str(className));      const MetaClass* mc = FindClass(ns, *Str(className));
  
     if (!mc)     if (!mc)
         _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));      {
           Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
       }
  
     // Build property list:     // Build property list:
  
Line 1354 
Line 456 
  
     CIMClass cc;     CIMClass cc;
  
     if (_makeClass(ns, mc, localOnly, includeQualifiers,      if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,
         includeQualifiers, pl, cc) != 0)          includeClassOrigin, pl, cc) != 0)
     {     {
         _freePropertyList(pl);         _freePropertyList(pl);
         _throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);          Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
     }     }
  
     _freePropertyList(pl);     _freePropertyList(pl);
Line 1373 
Line 475 
     Boolean includeQualifiers,     Boolean includeQualifiers,
     Boolean includeClassOrigin)     Boolean includeClassOrigin)
 { {
     printf("===== MetaRepository::enumerateClasses()\n");  
   
 #if defined(TEST_META_REPOSITORY)  
     _init();  
 #endif  
   
     // Lookup namespace:     // Lookup namespace:
  
     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
  
     if (!ns)     if (!ns)
         _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));          Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
  
     // Lookup class:     // Lookup class:
  
Line 1392 
Line 488 
  
     if (!className.isNull())     if (!className.isNull())
     {     {
         super = _findClass(ns, *Str(className));          super = FindClass(ns, *Str(className));
  
         if (!super)         if (!super)
             _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));              Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
     }     }
  
     // Iterate all classes looking for matches:     // Iterate all classes looking for matches:
Line 1423 
Line 519 
         {         {
             CIMClass cc;             CIMClass cc;
  
             if (_makeClass(ns, mc, localOnly, includeQualifiers,              if (MakeClass(_getHostName(), ns, mc, localOnly, includeQualifiers,
                 includeQualifiers, 0, cc) != 0)                  includeClassOrigin, 0, cc) != 0)
             {             {
                 _throw(CIM_ERR_FAILED, "conversion failed: %s", mc->name);                  Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
             }             }
             else  
                 result.append(cc);                 result.append(cc);
         }         }
     }     }
Line 1441 
Line 537 
     const CIMName& className,     const CIMName& className,
     Boolean deepInheritance)     Boolean deepInheritance)
 { {
     printf("===== MetaRepository::enumerateClassNames()\n");  
   
 #if defined(TEST_META_REPOSITORY)  
     _init();  
 #endif  
   
     // Lookup namespace:     // Lookup namespace:
  
     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));     const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
  
     if (!ns)     if (!ns)
         _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));          Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
  
     // Lookup class:     // Lookup class:
  
Line 1460 
Line 550 
  
     if (!className.isNull())     if (!className.isNull())
     {     {
         super = _findClass(ns, *Str(className));          super = FindClass(ns, *Str(className));
  
         if (!super)         if (!super)
             _throw(CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className));              Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
     }     }
  
     // Iterate all classes looking for matches:     // Iterate all classes looking for matches:
Line 1493 
Line 583 
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className)     const CIMName& className)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "deleteClass()");      Throw((CIM_ERR_NOT_SUPPORTED, "deleteClass()"));
 } }
  
 void MetaRepository::createClass( void MetaRepository::createClass(
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMClass& newClass)     const CIMClass& newClass)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "createClass()");      Throw((CIM_ERR_NOT_SUPPORTED, "createClass()"));
 } }
  
 void MetaRepository::modifyClass( void MetaRepository::modifyClass(
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMClass& newClass)     const CIMClass& newClass)
 { {
     _throw(CIM_ERR_NOT_SUPPORTED, "modifyClass()");      Throw((CIM_ERR_NOT_SUPPORTED, "modifyClass()"));
   }
   
   void MetaRepository::getSubClassNames(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       Boolean deepInheritance,
       Array<CIMName>& subClassNames)
   {
       subClassNames = MetaRepository::enumerateClassNames(
           nameSpace, className, deepInheritance);
   }
   
   void MetaRepository::getSuperClassNames(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       Array<CIMName>& superClassNames)
   {
       superClassNames.clear();
   
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Lookup class:
   
       const MetaClass* mc = FindClass(ns, *Str(className));
   
       if (!mc)
           Throw((CIM_ERR_NOT_FOUND, "unknown class: %s", *Str(className)));
   
       // Append superclass names:
   
       for (const MetaClass* p = mc->super; p; p = p->super)
           superClassNames.append(p->name);
   }
   
   void MetaRepository::createNameSpace(
       const CIMNamespaceName& nameSpace,
       const NameSpaceAttributes& attributes)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "createNameSpace()"));
   }
   
   void MetaRepository::modifyNameSpace(
       const CIMNamespaceName& nameSpace,
       const NameSpaceAttributes& attributes)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "modifyNameSpace()"));
   }
   
   Array<CIMNamespaceName> MetaRepository::enumerateNameSpaces()
   {
       Array<CIMNamespaceName> result;
   
       if (!_nameSpaces)
           return Array<CIMNamespaceName>();
   
       for (const MetaNameSpace* const* p = _nameSpaces; *p; p++)
       {
           const MetaNameSpace* ns = *p;
           result.append(ns->name);
       }
   
       return result;
   }
   
   void MetaRepository::deleteNameSpace(
       const CIMNamespaceName& nameSpace)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "deleteNameSpace()"));
   }
   
   Boolean MetaRepository::getNameSpaceAttributes(
       const CIMNamespaceName& nameSpace,
       NameSpaceAttributes& attributes)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "getNameSpaceAttributes()"));
   
       return false;
   }
   
   Boolean MetaRepository::isRemoteNameSpace(
       const CIMNamespaceName& nameSpace,
       String& remoteInfo)
   {
       return false;
   }
   
   CIMQualifierDecl MetaRepository::getQualifier(
       const CIMNamespaceName& nameSpace,
       const CIMName& qualifierName)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Lookup qualifier:
   
       const MetaQualifierDecl* mqd = FindQualifierDecl(ns, *Str(qualifierName));
   
       if (!mqd)
           Throw((CIM_ERR_NOT_FOUND,
               "unknown qualifier: %s", *Str(qualifierName)));
   
       // Make the qualifier declaration:
   
       CIMQualifierDecl cqd;
   
       if (MakeQualifierDecl(ns, mqd, cqd) != 0)
       {
           Throw((CIM_ERR_FAILED, "conversion failed: %s", mqd->name));
       }
   
       return cqd;
   }
   
   void MetaRepository::setQualifier(
       const CIMNamespaceName& nameSpace,
       const CIMQualifierDecl& qualifierDecl)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "setQualifier()"));
   
   }
   
   void MetaRepository::deleteQualifier(
       const CIMNamespaceName& nameSpace,
       const CIMName& qualifierName)
   {
       Throw((CIM_ERR_NOT_SUPPORTED, "deleteQualifier()"));
   }
   
   Array<CIMQualifierDecl> MetaRepository::enumerateQualifiers(
       const CIMNamespaceName& nameSpace)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Build the array of qualifier declarations:
   
       Array<CIMQualifierDecl> result;
   
       for (size_t i = 0; ns->qualifiers[i]; i++)
       {
           const MetaQualifierDecl* mqd = ns->qualifiers[i];
           CIMQualifierDecl cqd;
   
           if (MakeQualifierDecl(ns, mqd, cqd) != 0)
           {
               Throw((CIM_ERR_FAILED, "conversion failed: %s", mqd->name));
           }
   
           result.append(cqd);
       }
   
       return result;
   }
   
   Array<CIMObjectPath> MetaRepository::associatorClassPaths(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       const CIMName& assocClass,
       const CIMName& resultClass,
       const String& role,
       const String& resultRole)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Get associator meta-classes:
   
       Array<const MetaClass*> mcs;
       _associators(ns, className, assocClass, resultClass, role, resultRole, mcs);
   
       // Convert meta-classes to object names:
   
       Array<CIMObjectPath> result;
   
       for (Uint32 i = 0; i < mcs.size(); i++)
           result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));
   
       return result;
   }
   
   Array<CIMObject> MetaRepository::associatorClasses(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       const CIMName& assocClass,
       const CIMName& resultClass,
       const String& role,
       const String& resultRole,
       Boolean includeQualifiers,
       Boolean includeClassOrigin,
       const CIMPropertyList& propertyList)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Get associator meta-classes:
   
       Array<const MetaClass*> mcs;
       _associators(ns, className, assocClass, resultClass, role, resultRole, mcs);
   
       // Convert meta-classes to classes.
   
       Array<CIMObject> result;
   
       char** pl = _makePropertyList(propertyList);
   
       for (Uint32 i = 0; i < mcs.size(); i++)
       {
           const MetaClass* mc = mcs[i];
           CIMClass cc;
   
           if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,
               includeClassOrigin, pl, cc) != 0)
           {
               _freePropertyList(pl);
               Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
           }
   
           result.append(cc);
       }
   
       _freePropertyList(pl);
       return result;
   }
   
   Array<CIMObject> MetaRepository::referenceClasses(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       const CIMName& resultClass,
       const String& role,
       Boolean includeQualifiers,
       Boolean includeClassOrigin,
       const CIMPropertyList& propertyList)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Get reference meta-classes:
   
       Array<const MetaClass*> mcs;
       _references(ns, className, resultClass, role, mcs);
   
       // Convert meta-classes to classes.
   
       Array<CIMObject> result;
   
       char** pl = _makePropertyList(propertyList);
   
       for (Uint32 i = 0; i < mcs.size(); i++)
       {
           const MetaClass* mc = mcs[i];
           CIMClass cc;
   
           if (MakeClass(_getHostName(), ns, mc, false, includeQualifiers,
               includeClassOrigin, pl, cc) != 0)
           {
               _freePropertyList(pl);
               Throw((CIM_ERR_FAILED, "conversion failed: %s", mc->name));
           }
   
           result.append(cc);
       }
   
       _freePropertyList(pl);
       return result;
   }
   
   Array<CIMObjectPath> MetaRepository::referenceClassPaths(
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       const CIMName& resultClass,
       const String& role)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           Throw((CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace)));
   
       // Get reference meta-classes:
   
       Array<const MetaClass*> mcs;
       _references(ns, className, resultClass, role, mcs);
   
       // Convert meta-classes to object paths.
   
       Array<CIMObjectPath> result;
   
       for (Uint32 i = 0; i < mcs.size(); i++)
           result.append(CIMObjectPath(_getHostName(), nameSpace, mcs[i]->name));
   
       return result;
   }
   
   const MetaClass* MetaRepository::findMetaClass(
       const char* nameSpace,
       const char* className)
   {
       // Lookup namespace:
   
       const MetaNameSpace* ns = _findNameSpace(nameSpace);
   
       if (!ns)
           return 0;
   
       return FindClass(ns, className);
   }
   
   void MetaRepository::installNameSpaces(const MetaNameSpace* const* nameSpaces)
   {
       _nameSpaces = nameSpaces;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1.2.3  
changed lines
  Added in v.1.1.2.11
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2