(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.44 and 1.49

version 1.44, 2002/06/01 00:56:22 version 1.49, 2002/07/30 16:14:53
Line 25 
Line 25 
 // //
 // Modified By: Karl Schopmeyer(k.schopmeyer@attglobal.net) // Modified By: Karl Schopmeyer(k.schopmeyer@attglobal.net)
 //              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
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMClassRep.h" #include "CIMClassRep.h"
 #include "DeclContext.h" #include "DeclContext.h"
   #include "Resolver.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "CIMQualifierNames.h" #include "CIMQualifierNames.h"
Line 42 
Line 45 
 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
Line 68 
Line 68 
  
     const CIMValue& value = getQualifier(pos).getValue();     const CIMValue& value = getQualifier(pos).getValue();
  
     if (value.getType() != CIMType::BOOLEAN)      if (value.getType() != CIMTYPE_BOOLEAN)
         return false;         return false;
  
     value.get(flag);     value.get(flag);
Line 85 
Line 85 
     Boolean flag;     Boolean flag;
     const CIMValue& value = getQualifier(pos).getValue();     const CIMValue& value = getQualifier(pos).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;
 } }
  
 Boolean CIMClassRep::isTrueQualifier(const String& name) const  Boolean CIMClassRep::isTrueQualifier(const CIMName& name) const
 { {
     Uint32 pos = findQualifier(name);     Uint32 pos = findQualifier(name);
  
Line 102 
Line 102 
     Boolean flag;     Boolean flag;
     const CIMValue& value = getQualifier(pos).getValue();     const CIMValue& value = getQualifier(pos).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 String& superClassName)  void CIMClassRep::setSuperClassName(const CIMName& superClassName)
 { {
     if (!CIMName::legal(superClassName))  
         throw IllegalName();  
   
     _superClassName = superClassName;     _superClassName = superClassName;
 } }
  
Line 129 
Line 126 
  
     // Reject addition of references to non-associations:     // Reject addition of references to non-associations:
  
     if (!isAssociation() && x.getValue().getType() == CIMType::REFERENCE)      if (!isAssociation() && x.getValue().getType() == CIMTYPE_REFERENCE)
         throw AddedReferenceToClass(_reference.getClassName());         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:
  
     if (x.getClassOrigin().size() == 0)      if (x.getClassOrigin().isNull())
         CIMProperty(x).setClassOrigin(_reference.getClassName());         CIMProperty(x).setClassOrigin(_reference.getClassName());
  
     // Add the property:     // Add the property:
Line 158 
Line 155 
     _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;
 } }
  
 Boolean CIMClassRep::existsMethod(const String& name) const  
 {  
     return(findMethod(name) == PEG_NOT_FOUND) ? false : true;  
 }  
   
 CIMMethod CIMClassRep::getMethod(Uint32 pos) CIMMethod CIMClassRep::getMethod(Uint32 pos)
 { {
     if (pos >= _methods.size())     if (pos >= _methods.size())
Line 197 
Line 189 
  
 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 212 
Line 204 
                 _reference.getClassName() + ", superclass = " +                 _reference.getClassName() + ", superclass = " +
                 _superClassName);                 _superClassName);
  
     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 250 
Line 242 
  
                         if (pos == PEG_NOT_FOUND)                         if (pos == PEG_NOT_FOUND)
                         {                         {
                                 property.resolve(context, nameSpace, false, true);                              Resolver::resolveProperty (property, context,
                                   nameSpace, false, true);
                         }                         }
                         else                         else
                         {                         {
                                 CIMConstProperty superClassProperty =                                 CIMConstProperty superClassProperty =
                                 superClass.getProperty(pos);                                 superClass.getProperty(pos);
                                 property.resolve(                              Resolver::resolveProperty (property, context,
                                         context, nameSpace, false, superClassProperty, true);                                  nameSpace, false, superClassProperty, true);
                         }                         }
                 }                 }
  
Line 316 
Line 309 
                                         Uint32 pos = PEG_NOT_FOUND;                                         Uint32 pos = 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 329 
Line 322 
                                                  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;                                                         pos = j;
                                                         break;                                                         break;
Line 362 
Line 354 
  
                         if (pos == PEG_NOT_FOUND)                         if (pos == PEG_NOT_FOUND)
                         {                         {
                                 method.resolve(context, nameSpace);                              Resolver::resolveMethod (method, context,
                                   nameSpace);
                         }                         }
                         else                         else
                         {                         {
                                 CIMConstMethod superClassMethod = superClass.getMethod(pos);                                 CIMConstMethod superClassMethod = superClass.getMethod(pos);
                                 method.resolve(context, nameSpace, superClassMethod);                              Resolver::resolveMethod (method, context,
                                   nameSpace, superClassMethod);
                         }                         }
                 }                 }
  
Line 435 
Line 429 
                 //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++)
                         _properties[i].resolve(context, nameSpace, false, true);                      Resolver::resolveProperty (_properties[i], context,
                           nameSpace, false, true);
  
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // Resolve each method:                 // Resolve each method:
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
  
                 for (Uint32 i = 0, n = _methods.size(); i < n; i++)                 for (Uint32 i = 0, n = _methods.size(); i < n; i++)
                         _methods[i].resolve(context, nameSpace);                      Resolver::resolveMethod (_methods[i], context, nameSpace);
  
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // Resolve the qualifiers:                 // Resolve the qualifiers:
Line 469 
Line 464 
     out << "<CLASS ";     out << "<CLASS ";
     out << " NAME=\"" << _reference.getClassName() << "\" ";     out << " NAME=\"" << _reference.getClassName() << "\" ";
  
     if (_superClassName.size())      if (!_superClassName.isNull())
         out << " SUPERCLASS=\"" << _superClassName << "\" ";         out << " SUPERCLASS=\"" << _superClassName << "\" ";
  
     out << ">\n";     out << ">\n";
Line 520 
Line 515 
     // output class statement     // output class statement
     out << "class " << _reference.getClassName();     out << "class " << _reference.getClassName();
  
     if (_superClassName.size())      if (!_superClassName.isNull())
         out << " : " << _superClassName;         out << " : " << _superClassName;
  
     out << "\n{";     out << "\n{";
Line 556 
Line 551 
     CIMObjectRep(x),     CIMObjectRep(x),
     _superClassName(x._superClassName)     _superClassName(x._superClassName)
 { {
     _methods.reserve(x._methods.size());      _methods.reserveCapacity(x._methods.size());
  
     for (Uint32 i = 0, n = x._methods.size(); i < n; i++)     for (Uint32 i = 0, n = x._methods.size(); i < n; i++)
         _methods.append(x._methods[i].clone());         _methods.append(x._methods[i].clone());
Line 604 
Line 599 
     return true;     return true;
 } }
  
 void CIMClassRep::getKeyNames(Array<String>& keyNames) const  void CIMClassRep::getKeyNames(Array<CIMName>& keyNames) const
 { {
     keyNames.clear();     keyNames.clear();
  

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