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

Diff for /pegasus/src/Pegasus/Repository/Attic/SourceRepository.cpp between version 1.1.2.1 and 1.1.2.2

version 1.1.2.1, 2007/10/01 00:49:29 version 1.1.2.2, 2007/10/02 00:50:13
Line 36 
Line 36 
 #include "SourceRepository.h" #include "SourceRepository.h"
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
  
   /*
   ATTN-MEB: take these out!
   */
   #include "root_cimv2_namespace.h"
   #include "root_PG_Internal_namespace.h"
   #include "root_PG_InterOp_namespace.h"
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 static const size_t _MAX_NAMESPACES = 32; static const size_t _MAX_NAMESPACES = 32;
 static const SourceNameSpace* _nameSpaces[_MAX_NAMESPACES]; static const SourceNameSpace* _nameSpaces[_MAX_NAMESPACES];
 static size_t _nameSpacesSize = 0; static size_t _nameSpacesSize = 0;
  
   static const size_t _MAX_FEATURES = 1024;
   static const size_t _MAX_QUALIFIERS = 1024;
   
   /*
   ATTN-MEB: take this out!
   */
   static void _init()
   {
       if (_nameSpacesSize == 0)
       {
           SourceRepository::addNameSpace(&root_PG_InterOp_namespace);
           SourceRepository::addNameSpace(&root_cimv2_namespace);
           SourceRepository::addNameSpace(&root_PG_Internal_namespace);
       }
   }
   
   static bool _eqi(const char* s1, const char* s2)
   {
       return System::strcasecmp(s1, s2) == 0;
   }
   
 //============================================================================== //==============================================================================
 // //
 // Local definitions: // Local definitions:
Line 72 
Line 100 
     va_start(ap, format);     va_start(ap, format);
     vsprintf(buffer, format, ap);     vsprintf(buffer, format, ap);
     va_end(ap);     va_end(ap);
     throw CIMException(code, format);      throw CIMException(code, buffer);
 } }
  
 static const SourceNameSpace* _findNameSpace(const char* name) static const SourceNameSpace* _findNameSpace(const char* name)
 { {
     for (size_t i = 0; i < _nameSpacesSize; i++)     for (size_t i = 0; i < _nameSpacesSize; i++)
     {     {
         if (System::strcasecmp(_nameSpaces[i]->name, name))          if (_eqi(_nameSpaces[i]->name, name))
             return _nameSpaces[i];             return _nameSpaces[i];
     }     }
  
Line 116 
Line 144 
     {     {
         const SourceClass* sc = ns->classes[i];         const SourceClass* sc = ns->classes[i];
  
         if (System::strcasecmp(sc->name, name) == 0)          if (_eqi(sc->name, name))
             return sc;             return sc;
     }     }
  
Line 124 
Line 152 
     return 0;     return 0;
 } }
  
 static const CIMValue _TRUE(Boolean(true));  
 static const CIMValue _FALSE(Boolean(false));  
   
 static inline void _readBoolean(const char*& value, Boolean& x) static inline void _readBoolean(const char*& value, Boolean& x)
 { {
     unsigned const char* p = (unsigned const char*)value;     unsigned const char* p = (unsigned const char*)value;
Line 355 
Line 380 
             }             }
  
             default:             default:
                   printf("T[%u]\n", __LINE__);
                 return -1;                 return -1;
         }         }
     }     }
Line 567 
Line 593 
             }             }
  
             default:             default:
                   printf("T[%u]\n", __LINE__);
                 return -1;                 return -1;
         }         }
     }     }
  
     // Unreachable!     // Unreachable!
       printf("T[%u]\n", __LINE__);
       return -1;
   }
   
   struct FeatureInfo
   {
       const SourceFeature* sf;
       const SourceClass* sc;
   };
   
   static int _mergeFeatures(
       const SourceClass* 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 SourceFeature* sf = sc->features[i];
   
           // Override feature if defined by ancestor class:
   
           bool found = false;
   
           for (size_t j = 0; j < numFeatures; j++)
           {
               const SourceFeature* 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 SourceClass* sc;
   };
   
   static const SourceFeature* _findFeature(
       const SourceClass* sc,
       const char* name)
   {
       for (size_t i = 0; sc->features[i]; i++)
       {
           const SourceFeature* sf = sc->features[i];
   
           if (_eqi(sf->name, name))
               return sf;
       }
   
       // Not found!
       return 0;
   }
   
   static const SourceFeature* _findParameter(
       const SourceMethod* sm,
       const char* name)
   {
       for (size_t i = 0; sm->parameters[i]; i++)
       {
           const SourceFeature* sf = sm->parameters[i];
   
           if (_eqi(sm->name, name))
               return sf;
       }
   
       // Not found!
       return 0;
   }
   
   static int _mergeQualifiers(
       const SourceNameSpace* ns,
       const SourceClass* 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 SourceFeature* sf = _findFeature(sc, featureName);
   
           if (sf)
               quals = sf->qualifiers;
       }
       else if (featureName && parameterName)
       {
           // Case 3: get parameter qualifiers:
   
           const SourceFeature* sf = _findFeature(sc, featureName);
   
           if (sf && (sf->flags & PEGASUS_FLAG_METHOD))
           {
               const SourceMethod* sm = (const SourceMethod*)sf;
               const SourceFeature* 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)
           {
               SourceQualifierDecl* qd = ns->qualifiers[qi[0]];
   
               if (depth == 0 || !(qd->flavor & PEGASUS_FLAVOR_RESTRICTED))
               {
                   if (numQualifiers == _MAX_QUALIFIERS)
                   {
                       printf("T[%u]\n", __LINE__);
     return -1;     return -1;
 } }
  
                   qualifiers[numQualifiers].qualifier = qi;
                   qualifiers[numQualifiers].sc = sc;
                   numQualifiers++;
               }
           }
       }
   
       return 0;
   }
   
 template<class C> template<class C>
 static void _addQualifiers(  static int _addQualifiers(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     C& c,      const SourceClass* sc,
     Uint32 flags,      const char* featureName,
     const char** qualifiers)      const char* parameterName,
 {      C& c)
     // ATTN: handle qualifier propagation:  {
       QualifierInfo qualifiers[_MAX_QUALIFIERS];
     // Add the boolean qualifiers:      size_t numQualifiers = 0;
   
     if (flags & PEGASUS_FLAG_ABSTRACT)      if (_mergeQualifiers(
         c.addQualifier(CIMQualifier("Abstract", _TRUE));          ns, sc, featureName, parameterName, 0, qualifiers, numQualifiers) != 0)
     if (flags & PEGASUS_FLAG_AGGREGATE)      {
         c.addQualifier(CIMQualifier("Aggregate", _TRUE));          printf("T[%u]\n", __LINE__);
     if (flags & PEGASUS_FLAG_AGGREGATION)          return -1;
         c.addQualifier(CIMQualifier("Aggregation", _TRUE));      }
     if (flags & PEGASUS_FLAG_ASSOCIATION)  
         c.addQualifier(CIMQualifier("Association", _TRUE));  
     if (flags & PEGASUS_FLAG_COMPOSITION)  
         c.addQualifier(CIMQualifier("Composition", _TRUE));  
     if (flags & PEGASUS_FLAG_COUNTER)  
         c.addQualifier(CIMQualifier("Counter", _TRUE));  
     if (flags & PEGASUS_FLAG_DELETE)  
         c.addQualifier(CIMQualifier("Delete", _TRUE));  
     if (flags & PEGASUS_FLAG_DN)  
         c.addQualifier(CIMQualifier("DN", _TRUE));  
     if (flags & PEGASUS_FLAG_EMBEDDEDOBJECT)  
         c.addQualifier(CIMQualifier("EmbeddedObject", _TRUE));  
     if (flags & PEGASUS_FLAG_EXCEPTION)  
         c.addQualifier(CIMQualifier("Exception", _TRUE));  
     if (flags & PEGASUS_FLAG_EXPENSIVE)  
         c.addQualifier(CIMQualifier("Expensive", _TRUE));  
     if (flags & PEGASUS_FLAG_EXPERIMENTAL)  
         c.addQualifier(CIMQualifier("Experimental", _TRUE));  
     if (flags & PEGASUS_FLAG_GAUGE)  
         c.addQualifier(CIMQualifier("Gauge", _TRUE));  
     if (flags & PEGASUS_FLAG_IFDELETED)  
         c.addQualifier(CIMQualifier("IfDeleted", _TRUE));  
     if (flags & PEGASUS_FLAG_IN)  
         c.addQualifier(CIMQualifier("In", _TRUE));  
     if (flags & PEGASUS_FLAG_INDICATION)  
         c.addQualifier(CIMQualifier("Indication", _TRUE));  
     if (flags & PEGASUS_FLAG_INVISIBLE)  
         c.addQualifier(CIMQualifier("Invisible", _TRUE));  
     if (flags & PEGASUS_FLAG_KEY)  
         c.addQualifier(CIMQualifier("Key", _TRUE));  
     if (flags & PEGASUS_FLAG_LARGE)  
         c.addQualifier(CIMQualifier("Large", _TRUE));  
     if (flags & PEGASUS_FLAG_OCTETSTRING)  
         c.addQualifier(CIMQualifier("OctetString", _TRUE));  
     if (flags & PEGASUS_FLAG_OUT)  
         c.addQualifier(CIMQualifier("Out", _TRUE));  
     if (flags & PEGASUS_FLAG_READ)  
         c.addQualifier(CIMQualifier("Read", _TRUE));  
     if (flags & PEGASUS_FLAG_REQUIRED)  
         c.addQualifier(CIMQualifier("Required", _TRUE));  
     if (flags & PEGASUS_FLAG_STATIC)  
         c.addQualifier(CIMQualifier("Static", _TRUE));  
     if (flags & PEGASUS_FLAG_TERMINAL)  
         c.addQualifier(CIMQualifier("Terminal", _TRUE));  
     if (flags & PEGASUS_FLAG_WEAK)  
         c.addQualifier(CIMQualifier("Weak", _TRUE));  
     if (flags & PEGASUS_FLAG_WRITE)  
         c.addQualifier(CIMQualifier("Write", _TRUE));  
     if (flags & PEGASUS_FLAG_EMBEDDEDINSTANCE)  
         c.addQualifier(CIMQualifier("EmbeddedInstance", _TRUE));  
   
     // Add non-boolean qualifiers:  
  
     for (const char** p = qualifiers; *p; p++)      // Add qualifiers to container:
   
       for (size_t i = 0; i < numQualifiers; i++)
     {     {
         const char* q = *p;          const char* q = qualifiers[i].qualifier;
  
         // Read qualifier id:          // Get qualifier id:
  
         Uint8 qid;          Uint8 qid = Uint8(q[0]);
         _readUint8(q, qid);  
  
         // Get qualifier declaration:         // Get qualifier declaration:
  
Line 661 
Line 839 
         // Make CIMValue:         // Make CIMValue:
  
         CIMValue cv;         CIMValue cv;
         int status = _makeValue(cv, qd->type, qd->subscript, q);  
         assert(status == 0);          if (_makeValue(cv, qd->type, qd->subscript, q + 1) != 0)
           {
               printf("T[%u]\n", __LINE__);
               return -1;
           }
  
         // Add qualifier:         // Add qualifier:
  
         c.addQualifier(CIMQualifier(qd->name, cv));         c.addQualifier(CIMQualifier(qd->name, cv));
     }     }
   
       return 0;
 } }
  
 static void _addProperty(  static int _addProperty(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMClass& cc,      const SourceClass* sc,
     const SourceProperty* sp)      const SourceProperty* sp,
       const char* classOrigin,
       bool propagated,
       CIMClass& cc)
 { {
     // Make CIMvalue:     // Make CIMvalue:
  
     CIMValue cv;     CIMValue cv;
     int status = _makeValue(cv, sp->type, sp->subscript, sp->value);  
     assert(status == 0);      if (_makeValue(cv, sp->type, sp->subscript, sp->value) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Create property:     // Create property:
  
     CIMProperty cp(sp->name, cv);     CIMProperty cp(sp->name, cv);
       cp.setClassOrigin(classOrigin);
       cp.setPropagated(propagated);
  
     // Add qualifiers:     // Add qualifiers:
  
     _addQualifiers(ns, cp, sp->flags, sp->qualifiers);      if (_addQualifiers(ns, sc, sp->name, 0, cp) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Add to class:     // Add to class:
  
     cc.addProperty(cp);     cc.addProperty(cp);
       return 0;
 } }
  
 static void _addReference(  static int _addReference(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMClass& cc,      const SourceClass* sc,
     const SourceReference* sr)      const SourceReference* sr,
       const char* classOrigin,
       bool propagated,
       CIMClass& cc)
 { {
     // Create reference property:      // Set isArray and arraySize:
  
     CIMValue cv;      Boolean isArray;
       Uint32 arraySize;
  
     if (sr->subscript == -1)     if (sr->subscript == -1)
         cv.setNullValue(CIMTYPE_REFERENCE, false, 0);      {
           isArray = false;
           arraySize = 0;
       }
     else     else
         cv.setNullValue(CIMTYPE_REFERENCE, true, sr->subscript);      {
           isArray = true;
           arraySize = sr->subscript;
       }
   
       // Set referenceClassName:
  
     CIMProperty cp(sr->name, cv);      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:     // Add qualifiers:
  
     _addQualifiers(ns, cp, sr->flags, sr->qualifiers);      if (_addQualifiers(ns, sc, sr->name, 0, cp) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Add to class:     // Add to class:
  
     cc.addProperty(cp);     cc.addProperty(cp);
       return 0;
 } }
  
 static void _addPropertyParameter(  static int _addPropertyParameter(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMMethod& cm,      const SourceClass* sc,
     const SourceProperty* sp)      const SourceMethod* sm,
       const SourceProperty* sp,
       CIMMethod& cm)
 { {
     // Create property:     // Create property:
  
Line 744 
Line 969 
  
     // Add qualifiers:     // Add qualifiers:
  
     _addQualifiers(ns, cp, sp->flags, sp->qualifiers);      if (_addQualifiers(ns, sc, sm->name, sp->name, cm) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Add to method:     // Add to method:
  
     cm.addParameter(cp);     cm.addParameter(cp);
       return 0;
 } }
  
 static void _addReferenceParameter(  static int _addReferenceParameter(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMMethod& cm,      const SourceClass* sc,
     const SourceReference* sp)      const SourceMethod* sm,
       const SourceReference* sr,
       CIMMethod& cm)
 { {
     // Create property:     // Create property:
  
     bool isArray;     bool isArray;
     Uint32 arraySize;     Uint32 arraySize;
  
     if (sp->subscript == -1)      if (sr->subscript == -1)
     {     {
         isArray = false;         isArray = false;
         arraySize = 0;         arraySize = 0;
Line 769 
Line 1001 
     else     else
     {     {
         isArray = true;         isArray = true;
         arraySize = Uint32(sp->subscript);          arraySize = Uint32(sr->subscript);
     }     }
  
     assert(sp->ref != 0);      CIMName rcn = sr->ref->name;
     CIMName rcn = sp->ref->name;      CIMParameter cp(sr->name, CIMTYPE_REFERENCE, isArray, arraySize, rcn);
   
     CIMParameter cp(sp->name, CIMTYPE_REFERENCE, isArray, arraySize, rcn);  
  
     // Add qualifiers:     // Add qualifiers:
  
     _addQualifiers(ns, cp, sp->flags, sp->qualifiers);      if (_addQualifiers(ns, sc, sm->name, sr->name, cm) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Add to method:     // Add to method:
  
     cm.addParameter(cp);     cm.addParameter(cp);
       return 0;
 } }
  
 static void _addMethod(  static int _addMethod(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMClass& cc,      const SourceClass* sc,
     const SourceMethod* sm)      const SourceMethod* sm,
       const char* classOrigin,
       bool propagated,
       CIMClass& cc)
 { {
     // Create method:     // Create method:
  
     CIMMethod cm(sm->name, CIMType(sm->type));     CIMMethod cm(sm->name, CIMType(sm->type));
       cm.setClassOrigin(classOrigin);
       cm.setPropagated(propagated);
  
     // Add parameters:     // Add parameters:
  
     for (SourceFeature** p = sm->parameters; *p; p++)      for (size_t i = 0; sm->parameters[i]; i++)
     {     {
         SourceFeature* sf = *p;          SourceFeature* sf = sm->parameters[i];
  
         if (sf->flags & PEGASUS_FLAG_PROPERTY)         if (sf->flags & PEGASUS_FLAG_PROPERTY)
         {         {
             SourceProperty* sp = (SourceProperty*)sf;             SourceProperty* sp = (SourceProperty*)sf;
             _addPropertyParameter(ns, cm, sp);              _addPropertyParameter(ns, sc, sm, sp, cm);
         }         }
         else if (sf->flags & PEGASUS_FLAG_REFERENCE)         else if (sf->flags & PEGASUS_FLAG_REFERENCE)
         {         {
             SourceReference* sr = (SourceReference*)sf;             SourceReference* sr = (SourceReference*)sf;
             _addReferenceParameter(ns, cm, sr);              _addReferenceParameter(ns, sc, sm, sr, cm);
         }         }
     }     }
  
     // Add qualifiers:     // Add qualifiers:
  
     _addQualifiers(ns, cm, sm->flags, sm->qualifiers);      if (_addQualifiers(ns, sc, sm->name, 0, cm) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // Add to class:     // Add to class:
  
     cc.addMethod(cm);     cc.addMethod(cm);
       return 0;
 } }
  
 static void _addFeatures(  static int _addFeatures(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMClass& cc,      const SourceClass* sc,
     const SourceClass* sc)      CIMClass& cc)
 { {
     // Add superclass properties first:  
  
     // ATTN: handle feature overriding.      // Merge features from all inheritance levels into a single array:
     // ATTN: set the feature propagated flag.  
     // ATTN: set the class origin.  
  
     if (sc->super)      FeatureInfo features[_MAX_FEATURES];
         _addFeatures(ns, cc, sc->super);      size_t numFeatures = 0;
   
       if (_mergeFeatures(sc, features, numFeatures) != 0)
       {
           printf("T[%u]\n", __LINE__);
           return -1;
       }
  
     // For each feature:     // For each feature:
  
     for (SourceFeature** p = sc->features; *p; p++)      for (size_t i = 0; i < numFeatures; i++)
     {     {
         SourceFeature* sf = *p;          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 SourceFeature* sf = fi.sf;
  
         if (sf->flags & PEGASUS_FLAG_PROPERTY)         if (sf->flags & PEGASUS_FLAG_PROPERTY)
         {         {
             SourceProperty* sp = (SourceProperty*)sf;             SourceProperty* sp = (SourceProperty*)sf;
             _addProperty(ns, cc, sp);  
               if (_addProperty(ns, sc, sp, classOrigin, propagated, cc) != 0)
               {
                   printf("T[%u]\n", __LINE__);
                   return -1;
               }
         }         }
         else if (sf->flags & PEGASUS_FLAG_REFERENCE)         else if (sf->flags & PEGASUS_FLAG_REFERENCE)
         {         {
             SourceReference* sr = (SourceReference*)sf;             SourceReference* sr = (SourceReference*)sf;
             _addReference(ns, cc, sr);  
               if (_addReference(ns, sc, sr, classOrigin, propagated, cc) != 0)
               {
                   printf("T[%u]\n", __LINE__);
                   return -1;
               }
         }         }
         else if (sf->flags & PEGASUS_FLAG_METHOD)         else if (sf->flags & PEGASUS_FLAG_METHOD)
         {         {
             SourceMethod* sm = (SourceMethod*)sf;             SourceMethod* sm = (SourceMethod*)sf;
             _addMethod(ns, cc, sm);  
               if (_addMethod(ns, sc, sm, classOrigin, propagated, cc) != 0)
               {
                   printf("T[%u]\n", __LINE__);
                   return -1;
         }         }
     }     }
 } }
  
 static bool _makeCIMClass(      return 0;
   }
   
   static int _makeClass(
     const SourceNameSpace* ns,     const SourceNameSpace* ns,
     CIMClass& cc,     CIMClass& cc,
     const SourceClass* sc)     const SourceClass* sc)
Line 868 
Line 1145 
     try     try
     {     {
         // Create class:         // Create class:
           {
         CIMName scn;         CIMName scn;
  
         if (sc->super)         if (sc->super)
             scn = sc->super->name;             scn = sc->super->name;
  
         cc = CIMClass(sc->name, scn);         cc = CIMClass(sc->name, scn);
       }
  
         // Add qualifiers:         // Add qualifiers:
  
         _addQualifiers(ns, cc, sc->flags, sc->qualifiers);          if (_addQualifiers(ns, sc, 0, 0, cc) != 0)
           {
               printf("T[%u]\n", __LINE__);
               return -1;
           }
  
         // Features:         // Features:
  
         _addFeatures(ns, cc, sc);          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 (...)     catch (...)
     {     {
         return false;          printf("T[%u]\n", __LINE__);
           return -1;
     }     }
  
     return true;      return 0;
 } }
  
 //============================================================================== //==============================================================================
Line 913 
Line 1205 
  
     for (size_t i = 0; i < _nameSpacesSize; i++)     for (size_t i = 0; i < _nameSpacesSize; i++)
     {     {
         if (System::strcasecmp(_nameSpaces[i]->name, nameSpace->name) == 0)          if (_eqi(_nameSpaces[i]->name, nameSpace->name))
             return false;             return false;
     }     }
  
Line 932 
Line 1224 
     return CIMClass();     return CIMClass();
 } }
  
 Array<CIMClass> enumerateClasses(  Array<CIMClass> SourceRepository::enumerateClasses(
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className,     const CIMName& className,
     Boolean deepInheritance,     Boolean deepInheritance,
Line 940 
Line 1232 
     Boolean includeQualifiers,     Boolean includeQualifiers,
     Boolean includeClassOrigin)     Boolean includeClassOrigin)
 { {
     return Array<CIMClass>();      _init();
   
       printf("SourceRepository::enumerateClasses()\n");
   
       // Lookup namespace:
   
       const SourceNameSpace* ns = _findNameSpace(*Str(nameSpace));
   
       if (!ns)
           _throw(CIM_ERR_INVALID_NAMESPACE, "%s", *Str(nameSpace));
   
       // Lookup class:
   
       const SourceClass* 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++)
       {
           SourceClass* 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> enumerateClassNames(  Array<CIMName> SourceRepository::enumerateClassNames(
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className,     const CIMName& className,
     Boolean deepInheritance)     Boolean deepInheritance)
Line 959 
Line 1310 
  
     const SourceClass* super = 0;     const SourceClass* super = 0;
  
     if (!nameSpace.isNull())      if (!className.isNull())
     {     {
         super = _findClass(ns, *Str(className));         super = _findClass(ns, *Str(className));
  

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