(file) Return to CIMClassRep.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMClassRep.cpp between version 1.49 and 1.55

version 1.49, 2002/07/30 16:14:53 version 1.55, 2002/08/27 23:38:44
Line 59 
Line 59 
  
 Boolean CIMClassRep::isAssociation() const Boolean CIMClassRep::isAssociation() const
 { {
     Uint32 pos = findQualifier(CIMQualifierNames::ASSOCIATION);      Uint32 index = findQualifier(CIMQualifierNames::ASSOCIATION);
  
     if (pos == PEG_NOT_FOUND)      if (index == PEG_NOT_FOUND)
         return false;         return false;
  
     Boolean flag;     Boolean flag;
  
     const CIMValue& value = getQualifier(pos).getValue();      const CIMValue& value = getQualifier(index).getValue();
  
     if (value.getType() != CIMTYPE_BOOLEAN)     if (value.getType() != CIMTYPE_BOOLEAN)
         return false;         return false;
Line 77 
Line 77 
  
 Boolean CIMClassRep::isAbstract() const Boolean CIMClassRep::isAbstract() const
 { {
     Uint32 pos = findQualifier(CIMQualifierNames::ABSTRACT);      Uint32 index = findQualifier(CIMQualifierNames::ABSTRACT);
  
     if (pos == PEG_NOT_FOUND)      if (index == PEG_NOT_FOUND)
         return false;         return false;
  
     Boolean flag;     Boolean flag;
     const CIMValue& value = getQualifier(pos).getValue();      const CIMValue& value = getQualifier(index).getValue();
   
     if (value.getType() != CIMTYPE_BOOLEAN)  
         return false;  
   
     value.get(flag);  
     return flag;  
 }  
   
 Boolean CIMClassRep::isTrueQualifier(const CIMName& name) const  
 {  
     Uint32 pos = findQualifier(name);  
   
     if (pos == PEG_NOT_FOUND)  
         return false;  
   
     Boolean flag;  
     const CIMValue& value = getQualifier(pos).getValue();  
  
     if (value.getType() != CIMTYPE_BOOLEAN)     if (value.getType() != CIMTYPE_BOOLEAN)
         return false;         return false;
Line 116 
Line 99 
  
 void CIMClassRep::addProperty(const CIMProperty& x) void CIMClassRep::addProperty(const CIMProperty& x)
 { {
     if (x.isNull())      if (x.isUninitialized())
         throw UninitializedHandle();          throw UninitializedObjectException();
  
     // Reject addition of duplicate property name:     // Reject addition of duplicate property name:
  
     if (findProperty(x.getName()) != PEG_NOT_FOUND)     if (findProperty(x.getName()) != PEG_NOT_FOUND)
         throw AlreadyExists();          throw AlreadyExistsException("property \"" + x.getName() + "\"");
   
     // Reject addition of references to non-associations:  
   
     if (!isAssociation() && x.getValue().getType() == CIMTYPE_REFERENCE)  
         throw AddedReferenceToClass(_reference.getClassName());  
  
     // Set the class origin:     // Set the class origin:
     // ATTN: put this check in other places:     // ATTN: put this check in other places:
Line 142 
Line 120 
  
 void CIMClassRep::addMethod(const CIMMethod& x) void CIMClassRep::addMethod(const CIMMethod& x)
 { {
     if (x.isNull())      if (x.isUninitialized())
         throw UninitializedHandle();          throw UninitializedObjectException();
  
     // Reject duplicate method names:     // Reject duplicate method names:
  
     if (findMethod(x.getName()) != PEG_NOT_FOUND)     if (findMethod(x.getName()) != PEG_NOT_FOUND)
         throw AlreadyExists();          throw AlreadyExistsException("method \"" + x.getName() + "\"");
  
     // Add the method:     // Add the method:
  
Line 166 
Line 144 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 CIMMethod CIMClassRep::getMethod(Uint32 pos)  CIMMethod CIMClassRep::getMethod(Uint32 index)
 { {
     if (pos >= _methods.size())      if (index >= _methods.size())
         throw OutOfBounds();          throw IndexOutOfBoundsException();
  
     return _methods[pos];      return _methods[index];
 } }
  
 Uint32 CIMClassRep::getMethodCount() const Uint32 CIMClassRep::getMethodCount() const
Line 179 
Line 157 
     return _methods.size();     return _methods.size();
 } }
  
 void CIMClassRep::removeMethod(Uint32 pos)  void CIMClassRep::removeMethod(Uint32 index)
 { {
     if (pos >= _methods.size())      if (index >= _methods.size())
         throw OutOfBounds();          throw IndexOutOfBoundsException();
  
     _methods.remove(pos);      _methods.remove(index);
 } }
  
 void CIMClassRep::resolve( void CIMClassRep::resolve(
Line 214 
Line 192 
                 CIMConstClass superClass                 CIMConstClass superClass
                         = context->lookupClass(nameSpace, _superClassName);                         = context->lookupClass(nameSpace, _superClassName);
  
                 if (superClass.isNull())                  if (superClass.isUninitialized())
                         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_SUPERCLASS,_superClassName);                         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_SUPERCLASS,_superClassName);
  
 #if 0 #if 0
Line 235 
Line 213 
                 // set the class-origin:                 // set the class-origin:
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
  
                   Boolean isAssociationClass = isAssociation();
   
                 for (Uint32 i = 0, n = _properties.size(); i < n; i++)                 for (Uint32 i = 0, n = _properties.size(); i < n; i++)
                 {                 {
                         CIMProperty& property = _properties[i];                         CIMProperty& property = _properties[i];
                         Uint32 pos = superClass.findProperty(property.getName());  
  
                         if (pos == PEG_NOT_FOUND)                          if (!isAssociationClass &&
                               property.getValue().getType() == CIMTYPE_REFERENCE)
                           {
                               throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
                                   "Non-assocation class contains reference property");
                           }
   
                           Uint32 index = superClass.findProperty(property.getName());
   
                           if (index == PEG_NOT_FOUND)
                         {                         {
                             Resolver::resolveProperty (property, context,                             Resolver::resolveProperty (property, context,
                                 nameSpace, false, true);                                 nameSpace, false, true);
Line 248 
Line 236 
                         else                         else
                         {                         {
                                 CIMConstProperty superClassProperty =                                 CIMConstProperty superClassProperty =
                                 superClass.getProperty(pos);                                  superClass.getProperty(index);
                             Resolver::resolveProperty (property, context,                             Resolver::resolveProperty (property, context,
                                 nameSpace, false, superClassProperty, true);                                 nameSpace, false, superClassProperty, true);
                         }                         }
Line 269 
Line 257 
                         // insert it (setting the propagated flag). Otherwise, change                         // insert it (setting the propagated flag). Otherwise, change
                         // the class-origin and propagated flag accordingly.                         // the class-origin and propagated flag accordingly.
  
                         Uint32 pos = PEG_NOT_FOUND;                          Uint32 index = PEG_NOT_FOUND;
                         /*       ATTN: KS move to simpler version of the find                         /*       ATTN: KS move to simpler version of the find
                         for (Uint32 j = m, n = _properties.size(); j < n; j++)                         for (Uint32 j = m, n = _properties.size(); j < n; j++)
                         {                         {
                                 if (CIMName::equal(_properties[j].getName(),                                 if (CIMName::equal(_properties[j].getName(),
                                                                    superClassProperty.getName()))                                                                    superClassProperty.getName()))
                                 {                                 {
                                         pos = j;                                          index = j;
                                         break;                                         break;
                                 }                                 }
                         }                         }
                         */                         */
                         pos = findProperty(superClassProperty.getName());                          index = findProperty(superClassProperty.getName());
  
                         // If property exists in super class but not in this one, then                         // If property exists in super class but not in this one, then
                         // clone and insert it. Otherwise, the properties class                         // clone and insert it. Otherwise, the properties class
                         // origin was set above.                         // origin was set above.
  
                         CIMProperty superproperty = superClassProperty.clone(true);                          CIMProperty superproperty = superClassProperty.clone();
  
                         if (pos == PEG_NOT_FOUND)                          if (index == PEG_NOT_FOUND)
                         {                         {
                                 superproperty.setPropagated(true);                                 superproperty.setPropagated(true);
                                 _properties.insert(m++, superproperty);                                 _properties.insert(m++, superproperty);
Line 302 
Line 290 
                                 // If a qualifier is defined on the superclass's property                                 // If a qualifier is defined on the superclass's property
                                 // but not on the subclass's, then add it to the subclass's                                 // but not on the subclass's, then add it to the subclass's
                                 // property's qualifier list.                                 // property's qualifier list.
                                 CIMProperty subproperty = _properties[pos];                                  CIMProperty subproperty = _properties[index];
                                 for (Uint32 i = 0, n = superproperty.getQualifierCount();                                 for (Uint32 i = 0, n = superproperty.getQualifierCount();
                                         i < n; i++)                                         i < n; i++)
                                 {                                 {
                                         Uint32 pos = PEG_NOT_FOUND;                                          Uint32 index = PEG_NOT_FOUND;
                                         CIMQualifier superClassQualifier =                                         CIMQualifier superClassQualifier =
                                                                                         superproperty.getQualifier(i);                                                                                         superproperty.getQualifier(i);
                                         const CIMName name = superClassQualifier.getName();                                         const CIMName name = superClassQualifier.getName();
Line 324 
Line 312 
                                                 CIMConstQualifier q = subproperty.getQualifier(j);                                                 CIMConstQualifier q = subproperty.getQualifier(j);
                                                 if (name.equal(q.getName()))                                                 if (name.equal(q.getName()))
                                                 {                                                 {
                                                         pos = j;                                                          index = j;
                                                         break;                                                         break;
                                                 }                                                 }
                                         }  // end comparison of subclass property's qualifiers                                         }  // end comparison of subclass property's qualifiers
                                         if (pos == PEG_NOT_FOUND)                                          if (index == PEG_NOT_FOUND)
                                         {                                         {
                                                 subproperty.addQualifier(superClassQualifier);                                                 subproperty.addQualifier(superClassQualifier);
                                         }                                         }
                                         /*                                         /*
                                         if ((pos = subproperty.findQualifier(name)) == PEG_NOT_FOUND)                                          if ((index = subproperty.findQualifier(name)) == PEG_NOT_FOUND)
                                         {                                         {
                                                 subproperty.addQualifier(superClassQualifier);                                                 subproperty.addQualifier(superClassQualifier);
                                         }                                         }
Line 350 
Line 338 
                 for (Uint32 i = 0, n = _methods.size(); i < n; i++)                 for (Uint32 i = 0, n = _methods.size(); i < n; i++)
                 {                 {
                         CIMMethod& method = _methods[i];                         CIMMethod& method = _methods[i];
                         Uint32 pos = superClass.findMethod(method.getName());                          Uint32 index = superClass.findMethod(method.getName());
  
                         if (pos == PEG_NOT_FOUND)                          if (index == PEG_NOT_FOUND)
                         {                         {
                             Resolver::resolveMethod (method, context,                             Resolver::resolveMethod (method, context,
                                 nameSpace);                                 nameSpace);
                         }                         }
                         else                         else
                         {                         {
                                 CIMConstMethod superClassMethod = superClass.getMethod(pos);                                  CIMConstMethod superClassMethod = superClass.getMethod(index);
                             Resolver::resolveMethod (method, context,                             Resolver::resolveMethod (method, context,
                                 nameSpace, superClassMethod);                                 nameSpace, superClassMethod);
                         }                         }
Line 378 
Line 366 
                         // insert it (setting the propagated flag). Otherwise, change                         // insert it (setting the propagated flag). Otherwise, change
                         // the class-origin and propagated flag accordingly.                         // the class-origin and propagated flag accordingly.
  
                         Uint32 pos = PEG_NOT_FOUND;                          Uint32 index = PEG_NOT_FOUND;
                         /**********************  KS move to simpler version                         /**********************  KS move to simpler version
                         for (Uint32 j = m, n = _methods.size(); j < n; j++)                         for (Uint32 j = m, n = _methods.size(); j < n; j++)
                         {                         {
                                 if (CIMName::equal(_methods[j].getName(),                                 if (CIMName::equal(_methods[j].getName(),
                                                                         superClassMethod.getName()))                                                                         superClassMethod.getName()))
                                 {                                 {
                                         pos = j;                                          index = j;
                                         break;                                         break;
                                 }                                 }
                         }                         }
Line 394 
Line 382 
                         // clone and insert it. Otherwise, the method's class origin                         // clone and insert it. Otherwise, the method's class origin
                         // has already been set above.                         // has already been set above.
  
                         if (pos == PEG_NOT_FOUND)                          if (index == PEG_NOT_FOUND)
                         {                         {
                                 CIMMethod method = superClassMethod.clone();                                 CIMMethod method = superClassMethod.clone();
                                 method.setPropagated(true);                                 method.setPropagated(true);
                                 _methods.insert(m++, method);                                 _methods.insert(m++, method);
                         }                         }
                         */                         */
                         if((pos = findMethod(superClassMethod.getName())) == PEG_NOT_FOUND)                          if((index = findMethod(superClassMethod.getName())) == PEG_NOT_FOUND)
                         {                         {
                                 CIMMethod method = superClassMethod.clone();                                 CIMMethod method = superClassMethod.clone();
                                 method.setPropagated(true);                                 method.setPropagated(true);
Line 523 
Line 511 
     // format the Properties:     // format the Properties:
     for (Uint32 i = 0, n = _properties.size(); i < n; i++)     for (Uint32 i = 0, n = _properties.size(); i < n; i++)
     {     {
         // Generate MOF if this property not propogated          // Generate MOF if this property not propagated
         // Note that the test is required only because         // Note that the test is required only because
         // there is an error in getclass that does not         // there is an error in getclass that does not
         // test the localOnly flag.         // test the localOnly flag.
Line 607 
Line 595 
     {     {
         CIMConstProperty property = getProperty(i);         CIMConstProperty property = getProperty(i);
  
         if (property.isKey())          Uint32 index;
           if ((index = property.findQualifier ("key")) != PEG_NOT_FOUND)
           {
               CIMValue value;
               value = property.getQualifier (index).getValue ();
               if (!value.isNull ())
               {
                   Boolean isKey;
                   value.get (isKey);
                   if (isKey)
             keyNames.append(property.getName());             keyNames.append(property.getName());
     }     }
 } }
       }
   }
  
 Boolean CIMClassRep::hasKeys() const Boolean CIMClassRep::hasKeys() const
 { {
Line 618 
Line 617 
     {     {
         CIMConstProperty property = getProperty(i);         CIMConstProperty property = getProperty(i);
  
         if (getProperty(i).isKey())          Uint32 index;
           if ((index = property.findQualifier ("key")) != PEG_NOT_FOUND)
           {
               CIMValue value;
               value = property.getQualifier (index).getValue ();
               if (!value.isNull ())
               {
                   Boolean isKey;
                   value.get (isKey);
                   if (isKey)
             return true;             return true;
     }     }
           }
       }
  
     return false;     return false;
 } }


Legend:
Removed from v.1.49  
changed lines
  Added in v.1.55

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2