(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.47 and 1.74

version 1.47, 2002/07/23 17:01:48 version 1.74, 2006/07/21 18:40:55
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 35 
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 40 
Line 50 
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "MofWriter.h" #include "MofWriter.h"
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/MessageLoader.h> //l10n
   #include "CIMNameUnchecked.h"
   #include "StrLit.h"
   #include "CIMInstanceRep.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 CIMClassRep::CIMClassRep( CIMClassRep::CIMClassRep(
     const CIMObjectPath& reference,      const CIMName& className,
     const String& superClassName)      const CIMName& superClassName)
     :     :
     CIMObjectRep(reference),      CIMObjectRep(CIMObjectPath(String(), CIMNamespaceName(), className)),
     _superClassName(superClassName)     _superClassName(superClassName)
 { {
     if (superClassName.size() && !CIMName::legal(superClassName))  
         throw IllegalName();  
 } }
  
 CIMClassRep::~CIMClassRep() CIMClassRep::~CIMClassRep()
 { {
   
 } }
  
 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;
  
     value.get(flag);     value.get(flag);
Line 80 
Line 91 
  
 Boolean CIMClassRep::isAbstract() const Boolean CIMClassRep::isAbstract() const
 { {
     Uint32 pos = findQualifier(CIMQualifierNames::ABSTRACT);      Uint32 index = findQualifier(CIMQualifierNames::ABSTRACT);
   
     if (pos == PEG_NOT_FOUND)  
         return false;  
   
     Boolean flag;  
     const CIMValue& value = getQualifier(pos).getValue();  
   
     if (value.getType() != CIMType::BOOLEAN)  
         return false;  
   
     value.get(flag);  
     return flag;  
 }  
   
 Boolean CIMClassRep::isTrueQualifier(const String& name) const  
 {  
     Uint32 pos = findQualifier(name);  
  
     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;
  
     value.get(flag);     value.get(flag);
     return flag;     return flag;
 } }
   void CIMClassRep::setSuperClassName(const CIMName& superClassName)
 void CIMClassRep::setSuperClassName(const String& superClassName)  
 { {
     if (!CIMName::legal(superClassName))  
         throw IllegalName();  
   
     _superClassName = superClassName;     _superClassName = superClassName;
 } }
  
 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();          //l10n
                   //throw AlreadyExistsException
               //("property \"" + x.getName().getString () + "\"");
           MessageLoaderParms parms("Common.CIMClassRep.PROPERTY",
                                                            "property \"$0\"",
                                                            x.getName().getString());
           throw AlreadyExistsException(parms);
  
     // Reject addition of references to non-associations:      }
   
     if (!isAssociation() && x.getValue().getType() == CIMType::REFERENCE)  
         throw AddedReferenceToClass(_reference.getClassName());  
  
     // Set the class origin:      // Reject addition of a reference property without a referenceClassName
     // ATTN: put this check in other places:  
  
     if (x.getClassOrigin().size() == 0)      if ((x.getType() == CIMTYPE_REFERENCE) &&
         CIMProperty(x).setClassOrigin(_reference.getClassName());          (x.getReferenceClassName().isNull()))
       {
           throw TypeMismatchException();
       }
  
     // Add the property:     // Add the property:
  
Line 148 
Line 143 
  
 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();          //l10n
                   //throw AlreadyExistsException
               //("method \"" + x.getName().getString() + "\"");
           MessageLoaderParms parms("Common.CIMClassRep.METHOD",
                                                            "method \"$0\"",
                                                            x.getName().getString());
           throw AlreadyExistsException(parms);
   
       }
  
     // Add the method:     // Add the method:
  
     _methods.append(x);     _methods.append(x);
 } }
  
 Uint32 CIMClassRep::findMethod(const String& name) const  Uint32 CIMClassRep::findMethod(const CIMName& name) const
 { {
     for (Uint32 i = 0, n = _methods.size(); i < n; i++)     for (Uint32 i = 0, n = _methods.size(); i < n; i++)
     {     {
         if (CIMName::equal(_methods[i].getName(), name))          if (name.equal(_methods[i].getName()))
             return i;             return i;
     }     }
  
     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 185 
Line 188 
     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(
     DeclContext* context,     DeclContext* context,
     const String& nameSpace)      const CIMNamespaceName& nameSpace)
 { {
         PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMClassRep::resolve()");         PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMClassRep::resolve()");
 #if 0 #if 0
Line 207 
Line 210 
  
         PEG_TRACE_STRING(TRC_OBJECTRESOLUTION, Tracer::LEVEL3,         PEG_TRACE_STRING(TRC_OBJECTRESOLUTION, Tracer::LEVEL3,
                 String("CIMClassRep::resolve  class = ") +                 String("CIMClassRep::resolve  class = ") +
                 _reference.getClassName() + ", superclass = " +                  _reference.getClassName().getString() + ", superclass = " +
                 _superClassName);                  _superClassName.getString());
  
     if (_superClassName.size())      if (!_superClassName.isNull())
         {         {
                 //cout << "KSTEST Class Resolve with Super class " << getClassName()                 //cout << "KSTEST Class Resolve with Super class " << getClassName()
                 //<< " superClass " << _superClassName << endl;                 //<< " superClass " << _superClassName << endl;
Line 220 
Line 223 
                 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.getString());
   
  
 #if 0 #if 0
                 if (!superClass._rep->_resolved)                 if (!superClass._rep->_resolved)
Line 241 
Line 246 
                 // 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)
               {
                                   //l10n
                               //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER,
                                   //"Non-assocation class contains reference property");
                               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                                                   MessageLoaderParms("Common.CIMClassRep.NON_ASSOCIATION_CLASS_CONTAINS_REFERENCE_PROPERTY",
                                                                                      "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);
                               if (property.getClassOrigin().isNull())
                               {
                                   property.setClassOrigin(getClassName());
                               }
                               property.setPropagated(false);
                         }                         }
                         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);
                               if (property.getClassOrigin().isNull())
                               {
                                   property.setClassOrigin(
                                       superClassProperty.getClassOrigin());
                               }
                         }                         }
                 }                 }
  
Line 275 
Line 307 
                         // 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 308 
Line 340 
                                 // 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 String name = superClassQualifier.getName();                                          const CIMName name = superClassQualifier.getName();
                                         /* ATTN KS This is replacement find function.                                         /* ATTN KS This is replacement find function.
                                         if((Uint32 j = subproperty.findQualifier(q.getName()) == PEG_NOT_FOUND)                                         if((Uint32 j = subproperty.findQualifier(q.getName()) == PEG_NOT_FOUND)
                                         {                                         {
Line 328 
Line 360 
                                                  j++)                                                  j++)
                                         {                                         {
                                                 CIMConstQualifier q = subproperty.getQualifier(j);                                                 CIMConstQualifier q = subproperty.getQualifier(j);
                                                 if (CIMName::equal(name,                                                  if (name.equal(q.getName()))
                                                            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 357 
Line 388 
                 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 385 
Line 416 
                         // 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 401 
Line 432 
                         // 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 436 
Line 467 
                 //cout << "KSTEST Class Resolve, No Super class " << getClassName() << endl;                 //cout << "KSTEST Class Resolve, No Super class " << getClassName() << endl;
  
                 for (Uint32 i = 0, n = _properties.size(); i < n; i++)                 for (Uint32 i = 0, n = _properties.size(); i < n; i++)
                   {
                     Resolver::resolveProperty (_properties[i], context,                     Resolver::resolveProperty (_properties[i], context,
                         nameSpace, false, true);                         nameSpace, false, true);
                       _properties[i].setClassOrigin(getClassName());
                       _properties[i].setPropagated(false);
                   }
  
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // Resolve each method:                 // Resolve each method:
Line 464 
Line 499 
     // _resolved = true;     // _resolved = true;
 } }
  
 void CIMClassRep::toXml(Array<Sint8>& out) const  CIMInstance CIMClassRep::buildInstance(Boolean includeQualifiers,
       Boolean includeClassOrigin,
       const CIMPropertyList& propertyList) const
   {
   
       // Create the new instance representation
       CIMInstanceRep* newInstanceRep = new CIMInstanceRep(
           CIMObjectPath(String::EMPTY,
                         CIMNamespaceName(),
                         _reference.getClassName()));
   
       // Copy qualifiers if required
       if (includeQualifiers)
       {
           for (Uint32 i = 0 ; i < getQualifierCount() ; i++)
           {
               newInstanceRep->_qualifiers.add(getQualifier(i).clone());
           }
       }
   
       newInstanceRep->_properties.reserveCapacity(_properties.size());
   
       // Copy Properties
       for (Uint32 i = 0 ; i < _properties.size() ; i++)
       {
           CIMConstProperty cp = getProperty(i);
           CIMName name = cp.getName();
           Array<CIMName> pl = propertyList.getPropertyNameArray();
           if (propertyList.isNull() || Contains(pl, name))
           {
               CIMProperty p;
   
               if (includeQualifiers)
               {
                   p = getProperty(i).clone();
               }
               else
               {
                   p = CIMProperty(cp.getName(),
                                   cp.getValue(),
                                   cp.getArraySize(),
                                   cp.getReferenceClassName(),
                                   cp.getClassOrigin());
               }
   
               // Delete class origin attribute if required
               if (!includeClassOrigin)
               {
                   p.setClassOrigin(CIMName());
               }
   
               newInstanceRep->_properties.append(p);
           }
       }
   
       // Create new CIMInstance from CIMInstanceRep
       CIMInstance newInstance(newInstanceRep);
   
       return(newInstance);
   }
   
   void CIMClassRep::toXml(Buffer& out) const
 { {
     // Class opening element:     // Class opening element:
  
     out << "<CLASS ";      out << STRLIT("<CLASS ");
     out << " NAME=\"" << _reference.getClassName() << "\" ";      out << STRLIT(" NAME=\"") << _reference.getClassName() << STRLIT("\" ");
  
     if (_superClassName.size())      if (!_superClassName.isNull())
         out << " SUPERCLASS=\"" << _superClassName << "\" ";          out << STRLIT(" SUPERCLASS=\"") << _superClassName << STRLIT("\" ");
  
     out << ">\n";      out << STRLIT(">\n");
  
     // Qualifiers:      // Append Class Qualifiers:
  
     _qualifiers.toXml(out);     _qualifiers.toXml(out);
  
     // Parameters:      // Append Property definitions:
  
     for (Uint32 i = 0, n = _properties.size(); i < n; i++)     for (Uint32 i = 0, n = _properties.size(); i < n; i++)
         XmlWriter::appendPropertyElement(out, _properties[i]);         XmlWriter::appendPropertyElement(out, _properties[i]);
  
     // Methods:      // Append Method definitions:
  
     for (Uint32 i = 0, n = _methods.size(); i < n; i++)     for (Uint32 i = 0, n = _methods.size(); i < n; i++)
         XmlWriter::appendMethodElement(out, _methods[i]);         XmlWriter::appendMethodElement(out, _methods[i]);
  
     // Class closing element:     // Class closing element:
  
     out << "</CLASS>\n";      out << STRLIT("</CLASS>\n");
 } }
 /** toMof prepares an 8-bit string with the MOF for the class. /** toMof prepares an 8-bit string with the MOF for the class.
     The BNF for this is:     The BNF for this is:
Line 507 
Line 603 
  
 */ */
  
 void CIMClassRep::toMof(Array<Sint8>& out) const  void CIMClassRep::toMof(Buffer& out) const
 { {
     // Get and format the class qualifiers     // Get and format the class qualifiers
     out << "\n//    Class " << _reference.getClassName();      out << STRLIT("\n//    Class ") << _reference.getClassName();
     if (_qualifiers.getCount())     if (_qualifiers.getCount())
         out << "\n";          out.append('\n');
     out << "\n";      out.append('\n');
     _qualifiers.toMof(out);     _qualifiers.toMof(out);
  
     // Separate qualifiers from Class Name     // Separate qualifiers from Class Name
     out << "\n";      out.append('\n');
  
     // output class statement     // output class statement
     out << "class " << _reference.getClassName();      out << STRLIT("class ") << _reference.getClassName();
  
     if (_superClassName.size())      if (!_superClassName.isNull())
         out << " : " << _superClassName;          out << STRLIT(" : ") << _superClassName;
  
     out << "\n{";      out << STRLIT("\n{");
  
     // 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
           // The inital "false" indicates to format as property declaration.
         if (!_properties[i].getPropagated())         if (!_properties[i].getPropagated())
             MofWriter::appendPropertyElement(out, _properties[i]);              MofWriter::appendPropertyElement(true, out, _properties[i]);
     }     }
  
     // Format the Methods:  for non-propagated methods     // Format the Methods:  for non-propagated methods
Line 546 
Line 643 
     }     }
  
     // Class closing element:     // Class closing element:
     out << "\n};\n";      out << STRLIT("\n};\n");
 } }
  
  
Line 573 
Line 670 
     if (!tmprep)     if (!tmprep)
         return false;         return false;
  
     if (_superClassName != tmprep->_superClassName)      if (!_superClassName.equal (tmprep->_superClassName))
         return false;         return false;
  
     //     //
Line 592 
Line 689 
             if (!tmp1[i].identical(tmp2[i]))             if (!tmp1[i].identical(tmp2[i]))
                 return false;                 return false;
  
             if (tmp1[i].getClassOrigin() != tmp2[i].getClassOrigin())              if (!tmp1[i].getClassOrigin().equal (tmp2[i].getClassOrigin()))
                 return false;                 return false;
  
             if (tmp1[i].getPropagated() != tmp2[i].getPropagated())             if (tmp1[i].getPropagated() != tmp2[i].getPropagated())
Line 606 
Line 703 
     return true;     return true;
 } }
  
 void CIMClassRep::getKeyNames(Array<String>& keyNames) const  void CIMClassRep::getKeyNames(Array<CIMName>& keyNames) const
 { {
     keyNames.clear();     keyNames.clear();
  
Line 614 
Line 711 
     {     {
         CIMConstProperty property = getProperty(i);         CIMConstProperty property = getProperty(i);
  
         if (property.isKey())          Uint32 index;
           if ((index = property.findQualifier(
               CIMNameUnchecked("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 625 
Line 734 
     {     {
         CIMConstProperty property = getProperty(i);         CIMConstProperty property = getProperty(i);
  
         if (getProperty(i).isKey())          Uint32 index;
           if ((index = property.findQualifier(
               CIMNameUnchecked("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.47  
changed lines
  Added in v.1.74
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2