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

Diff for /pegasus/src/Pegasus/Common/CIMQualifierList.cpp between version 1.46.2.1 and 1.47

version 1.46.2.1, 2002/10/28 15:43:21 version 1.47, 2003/07/31 14:26:47
Line 38 
Line 38 
 #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
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 54 
Line 55 
  
 CIMQualifierList& CIMQualifierList::add(const CIMQualifier& qualifier) CIMQualifierList& CIMQualifierList::add(const CIMQualifier& qualifier)
 { {
     if (qualifier.isNull())      if (qualifier.isUninitialized())
         throw UninitializedHandle();          throw UninitializedObjectException();
  
     if (find(qualifier.getName()) != PEG_NOT_FOUND)      if (find(qualifier.getName()) != PEG_NOT_FOUND){
         throw AlreadyExists();          //l10n
                   //throw AlreadyExistsException
               //("qualifier \"" + qualifier.getName().getString () + "\"");
           MessageLoaderParms parms("Common.CIMQualifierList.QUALIFIER",
                                                            "qualifier \"$0\"",
                                                            qualifier.getName().getString());
           throw AlreadyExistsException(parms);
       }
  
     _qualifiers.append(qualifier);     _qualifiers.append(qualifier);
  
     return *this;     return *this;
 } }
 //ATTN: Why do we not do the outofbounds check here. KS 18 May 2k //ATTN: Why do we not do the outofbounds check here. KS 18 May 2k
 CIMQualifier& CIMQualifierList::getQualifier(Uint32 pos)  CIMQualifier& CIMQualifierList::getQualifier(Uint32 index)
 { {
     return _qualifiers[pos];      return _qualifiers[index];
 } }
  
 //ATTN: added ks 18 may 2001. Should we have outofbounds? //ATTN: added ks 18 may 2001. Should we have outofbounds?
 void CIMQualifierList::removeQualifier(Uint32 pos)  void CIMQualifierList::removeQualifier(Uint32 index)
 { {
     _qualifiers.remove(pos);      _qualifiers.remove(index);
 } }
  
 Uint32 CIMQualifierList::find(const String& name) const  Uint32 CIMQualifierList::find(const CIMName& name) const
 { {
     for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)     for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)
     {     {
         if (CIMName::equal(_qualifiers[i].getName(), name))          if (name.equal(_qualifiers[i].getName()))
             return i;             return i;
     }     }
  
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
 Boolean CIMQualifierList::isTrue(const String& name) const  Boolean CIMQualifierList::isTrue(const CIMName& name) const
 { {
     Uint32 pos = find(name);      Uint32 index = find(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;
Line 103 
Line 111 
     return flag;     return flag;
 } }
  
 Uint32 CIMQualifierList::findReverse(const String& name) const  Uint32 CIMQualifierList::findReverse(const CIMName& name) const
 { {
     for (Uint32 i = _qualifiers.size(); i; --i)     for (Uint32 i = _qualifiers.size(); i; --i)
     {     {
         if (CIMName::equal(_qualifiers[i - 1].getName(), name))          if (name.equal(_qualifiers[i-1].getName()))
             return i - 1;             return i - 1;
     }     }
  
Line 116 
Line 124 
  
 void CIMQualifierList::resolve( void CIMQualifierList::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const String& nameSpace,      const CIMNamespaceName & nameSpace,
     Uint32 scope,                        // Scope of the entity being resolved.      CIMScope scope,                      // Scope of the entity being resolved.
     Boolean isInstancePart,     Boolean isInstancePart,
     CIMQualifierList& inheritedQualifiers,     CIMQualifierList& inheritedQualifiers,
     Boolean propagateQualifiers)        // Apparently not used ks 24 mar 2002     Boolean propagateQualifiers)        // Apparently not used ks 24 mar 2002
Line 150 
Line 158 
                 CIMQualifierDecl qd = declContext->lookupQualifierDecl(                 CIMQualifierDecl qd = declContext->lookupQualifierDecl(
                         nameSpace, q.getName());                         nameSpace, q.getName());
  
                 if (qd.isNull())                  if (qd.isUninitialized())
                         throw UndeclaredQualifier(q.getName());                          throw UndeclaredQualifier(q.getName().getString ());
  
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // 2. Check the type and isArray.  Must be the same:                 // 2. Check the type and isArray.  Must be the same:
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
  
                 if (!(q.getType() == qd.getType() && q.isArray() == qd.isArray()))                 if (!(q.getType() == qd.getType() && q.isArray() == qd.isArray()))
                         throw BadQualifierType(q.getName());                          throw BadQualifierType(q.getName().getString ());
  
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // 3. Check the scope: Must be legal for this qualifier                 // 3. Check the scope: Must be legal for this qualifier
Line 168 
Line 176 
                         // a valid scope (such as Scope::ASSOCIATION) which is not Scope::CLASS                         // a valid scope (such as Scope::ASSOCIATION) which is not Scope::CLASS
                         // ks Mar 2002. Reinstalled 23 March 2002 to test.                         // ks Mar 2002. Reinstalled 23 March 2002 to test.
  
                 if (!(qd.getScope() & scope))                  if (!(qd.getScope().hasScope (scope)))
                         throw BadQualifierScope(qd.getName(), ScopeToString(scope));                          throw BadQualifierScope
                               (qd.getName().getString (), scope.toString ());
 //#endif //#endif
                 //----------------------------------------------------------------------                 //----------------------------------------------------------------------
                 // Resolve the qualifierflavor. Since Flavors are a combination of inheritance                 // Resolve the qualifierflavor. Since Flavors are a combination of inheritance
Line 199 
Line 208 
                 // of NULL or no values.  The implication is that we must move the value                 // of NULL or no values.  The implication is that we must move the value
                 // from the superclass or declaration.                 // from the superclass or declaration.
  
                 Uint32 pos = inheritedQualifiers.find(q.getName());                  Uint32 index = inheritedQualifiers.find(q.getName());
  
                 //cout << "KSTEST Qualifier resolve inherit test " << q.getName()                 //cout << "KSTEST Qualifier resolve inherit test " << q.getName()
                 //<< " Inherited From " << ((pos == PEG_NOT_FOUND) ? "Declaration" : "superclass")                  //<< " Inherited From " << ((index == PEG_NOT_FOUND) ? "Declaration" : "superclass")
                 //<< " Flavor " << q.getFlavor()                 //<< " Flavor " << q.getFlavor()
                 //<< " inherited Flavor ";                 //<< " inherited Flavor ";
  
                 if (pos == PEG_NOT_FOUND)                  if (index == PEG_NOT_FOUND)
                 {   // Qualifier does not exist in superclass                 {   // Qualifier does not exist in superclass
                         /* If from declaration, we can override the default value.                         /* If from declaration, we can override the default value.
                            However, we need some way to get the value if we have a Null.                            However, we need some way to get the value if we have a Null.
                         if (!qd.isFlavor(CIMFlavor::OVERRIDABLE) && qd.isFlavor(CIMFlavor::TOSUBCLASS))                          if (!(qd.getFlavor ().hasFlavor
                                  (CIMFlavor::OVERRIDABLE))
                               && qd.getFlavor ().hasFlavor
                                  (CIMFlavor::TOSUBCLASS))
                         {                         {
                                 if(!(q.getValue() == qd.getValue()))                                 if(!(q.getValue() == qd.getValue()))
                                         cout << "KSTEST QL err NSCL " << q.getName()                                         cout << "KSTEST QL err NSCL " << q.getName()
                                         << " decl flavor " << qd.getFlavor() << " Flavor " << q.getFlavor()                                         << " decl flavor " << qd.getFlavor() << " Flavor " << q.getFlavor()
                                         << " Not override " << !qd.isFlavor(CIMFlavor::OVERRIDABLE)                                          << " Not override "
                                         << " tosubclass " <<  qd.isFlavor(CIMFlavor::TOSUBCLASS) << endl;                                          << !(qd.getFlavor ().hasFlavor
                                              (CIMFlavor::OVERRIDABLE))
                                           << " tosubclass "
                                           <<  qd.getFlavor ().hasFlavor
                                               (CIMFlavor::TOSUBCLASS) << endl;
                                 XmlWriter::printQualifierDeclElement(qd);                                 XmlWriter::printQualifierDeclElement(qd);
                                 XmlWriter::printQualifierElement(q);                                 XmlWriter::printQualifierElement(q);
                                         //throw BadQualifierOverride(q.getName());                                         //throw BadQualifierOverride(q.getName());
                         }                         }
                         //cout <<  qd.getFlavor() << endl;*/                         //cout <<  qd.getFlavor() << endl;*/
                         // Do not allow change from disable override to enable override.                         // Do not allow change from disable override to enable override.
                         if(!qd.isFlavor(CIMFlavor::OVERRIDABLE) && q.isFlavor(CIMFlavor::OVERRIDABLE ))                          if ((!qd.getFlavor ().hasFlavor
                                 throw BadQualifierOverride(q.getName());                                 (CIMFlavor::OVERRIDABLE))
                              && (q.getFlavor ().hasFlavor
                                  (CIMFlavor::OVERRIDABLE)))
                                   throw BadQualifierOverride
                                       (q.getName().getString ());
  
                         Resolver::resolveQualifierFlavor (q, qd.getFlavor (),                          Resolver::resolveQualifierFlavor
                             false);                              (q, CIMFlavor (qd.getFlavor ()), false);
                         /*if(!(q.getValue() == qd.getValue()))                         /*if(!(q.getValue() == qd.getValue()))
                                 cout << "KSTEST Flavor resolved from decl. " << q.getName()                                 cout << "KSTEST Flavor resolved from decl. " << q.getName()
                                 << " decl flavor " << qd.getFlavor() << " Flavor " << q.getFlavor()                                  << " decl flavor " << qd.getFlavor().toString ()
                                 << " Not override " << !qd.isFlavor(CIMFlavor::OVERRIDABLE)                                  << " Flavor " << q.getFlavor().toString ()
                                 << " tosubclass " <<  qd.isFlavor(CIMFlavor::TOSUBCLASS) << endl;                                  << " Not override "
                                   << !(qd.getFlavor ().hasFlavor
                                          (CIMFlavor::OVERRIDABLE))
                                   << " tosubclass " <<  qd.getFlavor ().hasFlavor
                                          (CIMFlavor::TOSUBCLASS) << endl;
                          XmlWriter::printQualifierDeclElement(qd);                          XmlWriter::printQualifierDeclElement(qd);
                          XmlWriter::printQualifierElement(q); */                          XmlWriter::printQualifierElement(q); */
                 }                 }
                 else                    // qualifier exists in superclass                 else                    // qualifier exists in superclass
                 {       ////// Make Const again                 {       ////// Make Const again
                         CIMQualifier iq = inheritedQualifiers.getQualifier(pos);                          CIMQualifier iq = inheritedQualifiers.getQualifier(index);
                         // don't allow change override to notoverride.                         // don't allow change override to notoverride.
                         if(!iq.isFlavor(CIMFlavor::OVERRIDABLE) && q.isFlavor(CIMFlavor::OVERRIDABLE ))                          if (!(iq.getFlavor ().hasFlavor
                                 throw BadQualifierOverride(q.getName());                                 (CIMFlavor::OVERRIDABLE))
                              && q.getFlavor ().hasFlavor (CIMFlavor::OVERRIDABLE))
                         if (!iq.isFlavor(CIMFlavor::OVERRIDABLE) && iq.isFlavor(CIMFlavor::TOSUBCLASS))                                  throw BadQualifierOverride
                                       (q.getName().getString ());
   
                           if (!(iq.getFlavor ().hasFlavor
                                  (CIMFlavor::OVERRIDABLE))
                               && iq.getFlavor ().hasFlavor
                                  (CIMFlavor::TOSUBCLASS))
                         {                         {
                                 /*if(!(q.getValue() == iq.getvalue()))                                 /*if(!(q.getValue() == iq.getvalue()))
                                         cout << "KSTEST QL err inherit " << q.getName()                                         cout << "KSTEST QL err inherit " << q.getName()
                                         << " from superclass " << iq.getName()                                         << " from superclass " << iq.getName()
                                         << "   Superclass flavor " << iq.getFlavor()                                          << "   Superclass flavor " << iq.getFlavor().toString ()
                                         << " Flavor " << q.getFlavor()                                          << " Flavor " << q.getFlavor().toString ()
                                         << endl;                                         << endl;
                                 XmlWriter::printQualifierElement(iq);                                 XmlWriter::printQualifierElement(iq);
                                 XmlWriter::printQualifierElement(q); */                                 XmlWriter::printQualifierElement(q); */
Line 257 
Line 287 
                                 CIMValue qv = q.getValue();                                 CIMValue qv = q.getValue();
                                 CIMValue iqv = iq.getValue();                                 CIMValue iqv = iq.getValue();
                                 if(!(qv == iqv)) {                                 if(!(qv == iqv)) {
                                         throw BadQualifierOverride(q.getName());                                          throw BadQualifierOverride
                                               (q.getName().getString ());
                           }                           }
                         }                         }
                         //cout << iq.getFlavor()  << endl;                         //cout << iq.getFlavor()  << endl;
                         Resolver::resolveQualifierFlavor (q, iq.getFlavor (),                          Resolver::resolveQualifierFlavor
                             true);                              (q, CIMFlavor (iq.getFlavor ()), true);
                 }                 }
     }                                   // end of this objects qualifier loop     }                                   // end of this objects qualifier loop
  
Line 280 
Line 311 
  
                 if (isInstancePart)                 if (isInstancePart)
                 {                 {
                         if (!iq.isFlavor(CIMFlavor::TOINSTANCE))                          if (!(iq.getFlavor ().hasFlavor
                               (CIMFlavor::TOINSTANCE)))
                                 continue;                                 continue;
                 }                 }
                 else                 else
                 {                 {
                         if (!iq.isFlavor(CIMFlavor::TOSUBCLASS))                          if (!(iq.getFlavor ().hasFlavor
                               (CIMFlavor::TOSUBCLASS)))
                                 continue;                                 continue;
                 }                 }
  

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