(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.58 and 1.64

version 1.58, 2006/11/07 21:38:14 version 1.64, 2008/02/29 18:55:06
Line 36 
Line 36 
 #include "Resolver.h" #include "Resolver.h"
 #include "CIMQualifierDecl.h" #include "CIMQualifierDecl.h"
 #include "CIMName.h" #include "CIMName.h"
 #include "Indentor.h"  
 #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 <Pegasus/Common/MessageLoader.h>
 #include "StrLit.h" #include "StrLit.h"
 #include "ArrayIterator.h" #include "ArrayIterator.h"
   #include "CIMQualifierRep.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 CIMQualifierList::CIMQualifierList()  static CIMName _KEY("Key");
   
   CIMQualifierList::CIMQualifierList() :
                       _keyIndex(PEGASUS_ORDEREDSET_INDEX_UNKNOWN)
 { {
  
 } }
Line 62 
Line 65 
     if (qualifier.isUninitialized())     if (qualifier.isUninitialized())
         throw UninitializedObjectException();         throw UninitializedObjectException();
  
     if (find(qualifier.getName()) != PEG_NOT_FOUND){      if (find(qualifier.getName()) != PEG_NOT_FOUND)
       {
         MessageLoaderParms parms("Common.CIMQualifierList.QUALIFIER",         MessageLoaderParms parms("Common.CIMQualifierList.QUALIFIER",
             "qualifier \"$0\"",             "qualifier \"$0\"",
             qualifier.getName().getString());             qualifier.getName().getString());
Line 71 
Line 75 
  
     _qualifiers.append(qualifier);     _qualifiers.append(qualifier);
  
       // Update key index:
       if (_keyIndex == PEGASUS_ORDEREDSET_INDEX_UNKNOWN &&
               qualifier._rep->_name == _KEY)
           _keyIndex = _qualifiers.size()-1;
   
     return *this;     return *this;
 } }
 //ATTN: Why do we not do the outofbounds check here. KS 18 May 2k  
 CIMQualifier& CIMQualifierList::getQualifier(Uint32 index) CIMQualifier& CIMQualifierList::getQualifier(Uint32 index)
 { {
     return _qualifiers[index];     return _qualifiers[index];
 } }
  
 //ATTN: added ks 18 may 2001. Should we have outofbounds?  
 void CIMQualifierList::removeQualifier(Uint32 index) void CIMQualifierList::removeQualifier(Uint32 index)
 { {
     _qualifiers.remove(index);     _qualifiers.remove(index);
       _keyIndex = PEGASUS_ORDEREDSET_INDEX_UNKNOWN;
 } }
  
 Uint32 CIMQualifierList::find(const CIMName& name) const  void CIMQualifierList::clear()
 { {
     ConstArrayIterator<CIMQualifier> qualifiers(_qualifiers);      _qualifiers.clear();
   }
  
     for (Uint32 i = 0, n = qualifiers.size(); i < n; i++)  Uint32 CIMQualifierList::find(const CIMName& name) const
     {     {
         if (name.equal(qualifiers[i].getName()))      return _qualifiers.find(name, generateCIMNameTag(name));
             return i;  
     }     }
  
     return PEG_NOT_FOUND;  
 }  
 Boolean CIMQualifierList::isTrue(const CIMName& name) const Boolean CIMQualifierList::isTrue(const CIMName& name) const
 { {
     Uint32 index = find(name);     Uint32 index = find(name);
Line 114 
Line 121 
     return flag;     return flag;
 } }
  
 Uint32 CIMQualifierList::findReverse(const CIMName& name) const  
 {  
     for (Uint32 i = _qualifiers.size(); i; --i)  
     {  
         if (name.equal(_qualifiers[i-1].getName()))  
             return i - 1;  
     }  
   
     return PEG_NOT_FOUND;  
 }  
   
 void CIMQualifierList::resolve( void CIMQualifierList::resolve(
     DeclContext* declContext,     DeclContext* declContext,
     const CIMNamespaceName & nameSpace,     const CIMNamespaceName & nameSpace,
Line 133 
Line 129 
     CIMQualifierList& inheritedQualifiers,     CIMQualifierList& inheritedQualifiers,
     Boolean propagateQualifiers)  // Apparently not used ks 24 mar 2002     Boolean propagateQualifiers)  // Apparently not used ks 24 mar 2002
 { {
       _keyIndex = PEGASUS_ORDEREDSET_INDEX_UNKNOWN;
   
     PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMQualifierList::resolve()");     PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMQualifierList::resolve()");
     // For each qualifier in the qualifiers array, the following     // For each qualifier in the qualifiers array, the following
     // is checked:     // is checked:
Line 162 
Line 160 
             nameSpace, q.getName());             nameSpace, q.getName());
  
         if (qd.isUninitialized())         if (qd.isUninitialized())
           {
               PEG_METHOD_EXIT();
             throw UndeclaredQualifier(q.getName().getString ());             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()))
           {
               PEG_METHOD_EXIT();
             throw BadQualifierType(q.getName().getString ());             throw BadQualifierType(q.getName().getString ());
           }
  
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
         //----------------------------------------------------------------------         //----------------------------------------------------------------------
Line 186 
Line 190 
             {             {
                 String embeddedInstType("EmbeddedInstance(\"");                 String embeddedInstType("EmbeddedInstance(\"");
                 embeddedInstType = embeddedInstType + className + "\")";                 embeddedInstType = embeddedInstType + className + "\")";
                   PEG_METHOD_EXIT();
                 throw BadQualifierType(embeddedInstType);                 throw BadQualifierType(embeddedInstType);
             }             }
         }         }
Line 199 
Line 204 
         // ks Mar 2002. Reinstalled 23 March 2002 to test.         // ks Mar 2002. Reinstalled 23 March 2002 to test.
  
         if (!(qd.getScope().hasScope (scope)))         if (!(qd.getScope().hasScope (scope)))
           {
               PEG_METHOD_EXIT();
             throw BadQualifierScope             throw BadQualifierScope
                 (qd.getName().getString (), scope.toString ());                 (qd.getName().getString (), scope.toString ());
           }
  
         //----------------------------------------------------------------------         //----------------------------------------------------------------------
         // Resolve the qualifierflavor. Since Flavors are a combination of         // Resolve the qualifierflavor. Since Flavors are a combination of
Line 249 
Line 257 
             // Do not allow change from disable override to enable override.             // Do not allow change from disable override to enable override.
             if ((!qd.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))             if ((!qd.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
                   && (q.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)))                   && (q.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)))
               {
                   PEG_METHOD_EXIT();
                 throw BadQualifierOverride(q.getName().getString ());                 throw BadQualifierOverride(q.getName().getString ());
               }
  
             Resolver::resolveQualifierFlavor(             Resolver::resolveQualifierFlavor(
                 q, CIMFlavor (qd.getFlavor ()), false);                 q, CIMFlavor (qd.getFlavor ()), false);
Line 260 
Line 271 
             // don't allow change override to notoverride.             // don't allow change override to notoverride.
             if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))             if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
                   && q.getFlavor ().hasFlavor (CIMFlavor::OVERRIDABLE))                   && q.getFlavor ().hasFlavor (CIMFlavor::OVERRIDABLE))
               {
                   PEG_METHOD_EXIT();
                 throw BadQualifierOverride(q.getName().getString ());                 throw BadQualifierOverride(q.getName().getString ());
               }
  
             if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))             if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
                   && iq.getFlavor ().hasFlavor(CIMFlavor::TOSUBCLASS))                   && iq.getFlavor ().hasFlavor(CIMFlavor::TOSUBCLASS))
Line 270 
Line 284 
                 CIMValue iqv = iq.getValue();                 CIMValue iqv = iq.getValue();
                 if (!(qv == iqv))                 if (!(qv == iqv))
                 {                 {
                       PEG_METHOD_EXIT();
                     throw BadQualifierOverride(q.getName().getString());                     throw BadQualifierOverride(q.getName().getString());
                 }                 }
             }             }
Line 311 
Line 326 
  
         CIMQualifier q = iq.clone();         CIMQualifier q = iq.clone();
         q.setPropagated(true);         q.setPropagated(true);
         _qualifiers.prepend(q);          _qualifiers.insert(0, q);
     }     }
       PEG_METHOD_EXIT();
 } }
  
 void CIMQualifierList::toXml(Buffer& out) const void CIMQualifierList::toXml(Buffer& out) const
Line 356 
Line 372 
 { {
     Buffer tmp;     Buffer tmp;
     toXml(tmp);     toXml(tmp);
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
Line 378 
Line 393 
  
 void CIMQualifierList::cloneTo(CIMQualifierList& x) const void CIMQualifierList::cloneTo(CIMQualifierList& x) const
 { {
       x._keyIndex = PEGASUS_ORDEREDSET_INDEX_UNKNOWN;
     x._qualifiers.clear();     x._qualifiers.clear();
     x._qualifiers.reserveCapacity(_qualifiers.size());     x._qualifiers.reserveCapacity(_qualifiers.size());
  
     for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)     for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)
         x._qualifiers.append(_qualifiers[i].clone());         x._qualifiers.append(_qualifiers[i].clone());
       x._keyIndex = _keyIndex;
   }
   
   Boolean CIMQualifierList::isKey() const
   {
       static Uint32 _KEY_TAG = generateCIMNameTag(_KEY);
   
       // Resolve key index if unresolved.
   
       if (_keyIndex == PEGASUS_ORDEREDSET_INDEX_UNKNOWN)
       {
           Uint32 pos = _qualifiers.find(_KEY, _KEY_TAG);
           ((CIMQualifierList*)this)->_keyIndex = int(pos);
       }
   
       // If no key qualifier in list, then return false (default key value).
   
       if (_keyIndex == PEGASUS_ORDEREDSET_INDEX_NOTFOUND)
           return false;
   
       // Obtain value of key qualifier.
   
       const CIMValue& value = _qualifiers[_keyIndex]._rep->_value;
       if (!value.isNull() &&
           value.getType() == CIMTYPE_BOOLEAN)
       {
           Boolean boolVal;
           value.get(boolVal);
           return boolVal;
       }
   
       return false;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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