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

Diff for /pegasus/src/Pegasus/Common/SCMOXmlWriter.cpp between version 1.3.2.1 and 1.10

version 1.3.2.1, 2010/10/25 13:28:45 version 1.10, 2014/09/30 11:04:31
Line 27 
Line 27 
 // //
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 // //
   // This code implements part of PEP#348 - The CMPI infrastructure using SCMO
   // (Single Chunk Memory Objects).
   // The design document can be found on the OpenPegasus website openpegasus.org
   // at https://collaboration.opengroup.org/pegasus/pp/documents/21210/PEP_348.pdf
   //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
 #include <Pegasus/Common/SCMOXmlWriter.h> #include <Pegasus/Common/SCMOXmlWriter.h>
   #include "Tracer.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   void SCMOXmlWriter::buildPropertyFilterNodesArray(
        Array<Uint32> & nodes,
        const SCMOClass * classPtr,
        const CIMPropertyList & propertyList)
   {
       for (Uint32 i=0,k=propertyList.size(); i<k; i++)
       {
           Uint32 node = 0;
           const CIMName & name = propertyList[i];
           SCMO_RC rc =
               classPtr->_getPropertyNodeIndex(
                   node,
                   (const char *)name.getString().getCString());
           if(rc == SCMO_OK)
           {
               nodes.append(node);
           }
       }
   }
   
   const Array<Uint32> & SCMOXmlWriter::getFilteredNodesArray(
        Array<propertyFilterNodesArray_t> & propFilterNodesArrays,
        const SCMOInstance& scmoInstance,
        const CIMPropertyList & propertyList)
   {
       //First see if the class ptr is already stored in the propFilterNodesArrays
       const SCMOClass * classPtr = scmoInstance.inst.hdr->theClass.ptr;
       SCMBClass_Main * classPtrMemBlock = classPtr->cls.hdr;
       for (int i=0, k=propFilterNodesArrays.size(); i < k; i++)
       {
           if (classPtrMemBlock == propFilterNodesArrays[i].classPtrMemBlock)
           {
               return propFilterNodesArrays[i].nodes;
           }
       }
   
       // Could not find the class pointer of this SCMOInstance in the
       // property filter nodes array
       // --> need to create the new entry and return that
       propertyFilterNodesArray_t newEntry;
       newEntry.classPtrMemBlock = classPtrMemBlock;
       SCMOXmlWriter::buildPropertyFilterNodesArray(
           newEntry.nodes,
           classPtr,
           propertyList);
       propFilterNodesArrays.append(newEntry);
   
       // return the new nodes entry, but as a reference into the array
       return propFilterNodesArrays[propFilterNodesArrays.size()-1].nodes;
   }
   
   void SCMOXmlWriter::appendValueSCMOInstanceElements(
        Buffer& out,
        const Array<SCMOInstance> & _scmoInstances,
        const CIMPropertyList & propertyList)
   {
       if (propertyList.isNull())
       {
           Array<Uint32> emptyNodes;
           for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
           {
               SCMOXmlWriter::appendValueSCMOInstanceElement(
                   out,
                   _scmoInstances[i],
                   false,
                   emptyNodes);
           }
       }
       else
       {
           Array<propertyFilterNodesArray_t> propFilterNodesArrays;
   
           for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
           {
               // This searches for an already created array of nodes,
               // if not found, creates it inside propFilterNodesArrays
               const Array<Uint32> & nodes=
                   SCMOXmlWriter::getFilteredNodesArray(
                       propFilterNodesArrays,
                       _scmoInstances[i],
                       propertyList);
   
               SCMOXmlWriter::appendValueSCMOInstanceElement(
                   out,
                   _scmoInstances[i],
                   true,
                   nodes);
           }
       }
   }
   
   // EXP_PULL_BEGIN
   void SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(
        Buffer& out,
        const Array<SCMOInstance> & _scmoInstances,
        const CIMPropertyList & propertyList)
   {
       if (propertyList.isNull())
       {
           Array<Uint32> emptyNodes;
           for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
           {
               SCMOXmlWriter::appendValueInstanceWithPathElement(
                   out,
                   _scmoInstances[i],
                   false,
                   emptyNodes);
           }
       }
       else
       {
           Array<propertyFilterNodesArray_t> propFilterNodesArrays;
   
           for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
           {
               // This searches for an already created array of nodes,
               // if not found, creates it inside propFilterNodesArrays
               const Array<Uint32> & nodes=
                   SCMOXmlWriter::getFilteredNodesArray(
                       propFilterNodesArrays,
                       _scmoInstances[i],
                       propertyList);
   
               SCMOXmlWriter::appendValueInstanceWithPathElement(
                   out,
                   _scmoInstances[i],
                   true,
                   nodes);
           }
       }
   }
   //EXP_PULL_END
   
 void SCMOXmlWriter::appendValueSCMOInstanceElement( void SCMOXmlWriter::appendValueSCMOInstanceElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& scmoInstance)      const SCMOInstance& scmoInstance,
       bool filtered,
       const Array<Uint32> & nodes)
   
 { {
     out << STRLIT("<VALUE.NAMEDINSTANCE>\n");     out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
  
     appendInstanceNameElement(out, scmoInstance);     appendInstanceNameElement(out, scmoInstance);
     appendInstanceElement(out, scmoInstance);      appendInstanceElement(out, scmoInstance,filtered,nodes);
  
     out << STRLIT("</VALUE.NAMEDINSTANCE>\n");     out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
 } }
Line 82 
Line 224 
             if (SCMO_OK == smrc)             if (SCMO_OK == smrc)
             {             {
                 SCMOInstance * ref = kbValue->extRefPtr;                 SCMOInstance * ref = kbValue->extRefPtr;
                 appendValueReferenceElement(out, *ref, true);                  appendValueReferenceElement(out, *ref);
             }             }
         }         }
         else         else
Line 118 
Line 260 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 void SCMOXmlWriter::appendInstanceElement( void SCMOXmlWriter::appendInstanceElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& scmoInstance)      const SCMOInstance& scmoInstance,
       bool filtered,
       const Array<Uint32> & nodes)
 { {
     // Class opening element:     // Class opening element:
  
Line 145 
Line 289 
     }     }
  
     // Append Properties:     // Append Properties:
     // getPropertyCount() returns number of properties, only non-filtered ones      if(!filtered)
       {
     for (Uint32 i=0,k=scmoInstance.getPropertyCount();i<k;i++)     for (Uint32 i=0,k=scmoInstance.getPropertyCount();i<k;i++)
     {     {
         // function _getPropertyAt() used by appendPropertyElement  
         // translates the filter position of a property into the real one  
         // for us  
         SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);         SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);
     }     }
       }
       else
       {
           for (Uint32 i=0,k=nodes.size();i<k;i++)
           {
               SCMOXmlWriter::appendPropertyElement(out,scmoInstance,nodes[i]);
           }
       }
     // Instance closing element:     // Instance closing element:
     out << STRLIT("</INSTANCE>\n");     out << STRLIT("</INSTANCE>\n");
 } }
Line 239 
Line 389 
 //              %Propagated;> //              %Propagated;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
   
 void SCMOXmlWriter::appendPropertyElement( void SCMOXmlWriter::appendPropertyElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& scmoInstance,     const SCMOInstance& scmoInstance,
     Uint32 pos)     Uint32 pos)
 { {
     CIMType propertyType;  
  
     // This is an absolute pointer at a SCMBValue      // Absolute pointer to the property SCMBValue
     SCMBValue * propertyValue;     SCMBValue * propertyValue;
     const char * propertyValueBase;     const char * propertyValueBase;
     // This is an absolute pointer at a SCMBValue  
       // Absolute pointer at a SCMBValue
     SCMBClassProperty * propertyDef;     SCMBClassProperty * propertyDef;
     // This is the absolute pointer at which the class info for the given      // Absolute pointer to the the class info for the given
     // instance starts     // instance starts
     const char* clsbase = scmoInstance.inst.hdr->theClass.ptr->cls.base;     const char* clsbase = scmoInstance.inst.hdr->theClass.ptr->cls.base;
  
Line 261 
Line 412 
         &propertyValueBase,         &propertyValueBase,
         &propertyDef);         &propertyDef);
  
     propertyType = propertyValue->valueType;      bool noClassExists = scmoInstance.inst.hdr->flags.noClassForInstance;
       bool includeClassOrigin = scmoInstance.inst.hdr->flags.includeClassOrigin;
       bool includeQualifiers = scmoInstance.inst.hdr->flags.includeQualifiers;
       // This one either false or comes from class definition
       bool propagated = false;
   
       // Get property name and set any output parameter values
       const char * pName;
       Uint32 pLen;
       if (scmoInstance._isClassDefinedProperty(pos))
       {
           // Get name from class Definition
           pName = &(clsbase[propertyDef->name.start]);
           pLen = (propertyDef->name.size-1);
           propagated = propertyDef->flags.propagated;
       }
       else
       {
           // Get name from Instance
           SCMBUserPropertyElement* pElement =
               scmoInstance._getUserDefinedPropertyElementAt(pos);
   
           pName = _getCharString(pElement->name,scmoInstance.inst.base);
           pLen = pElement->name.size-1;
           includeQualifiers = false;
       }
       // KS_TODO clarify classOrigin acquisition.
       CIMType propertyType = propertyValue->valueType;
  
     if (propertyValue->flags.isArray)     if (propertyValue->flags.isArray)
     {     {
Line 269 
Line 447 
  
         out << STRLIT("<PROPERTY.ARRAY NAME=\"");         out << STRLIT("<PROPERTY.ARRAY NAME=\"");
  
         out.append(          out.append(pName, pLen);
             &(clsbase[propertyDef->name.start]),  
             (propertyDef->name.size-1));  
  
         out.append('"',' ');         out.append('"',' ');
         //out << STRLIT("\" ");         //out << STRLIT("\" ");
Line 307 
Line 483 
                               " EMBEDDEDOBJECT=\"instance\"");                               " EMBEDDEDOBJECT=\"instance\"");
             }             }
         }         }
           // Every CYMType but CIMOBject, CIMInstance
         else         else
         {         {
             out.append(' ');             out.append(' ');
Line 320 
Line 497 
             out.append('"');             out.append('"');
         }         }
  
           if (includeClassOrigin)
         if (scmoInstance.inst.hdr->flags.includeClassOrigin)  
         {         {
             if (propertyDef->originClassName.start != 0)             if (propertyDef->originClassName.start != 0)
             {             {
Line 332 
Line 508 
                 out.append('"');                 out.append('"');
             }             }
         }         }
         if (propertyDef->flags.propagated)  
           if (propagated)
         {         {
             out << STRLIT(" PROPAGATED=\"true\"");             out << STRLIT(" PROPAGATED=\"true\"");
         }         }
Line 341 
Line 518 
         //out << STRLIT(">\n");         //out << STRLIT(">\n");
  
         // Append Instance Qualifiers:         // Append Instance Qualifiers:
         if (scmoInstance.inst.hdr->flags.includeQualifiers)          if (includeQualifiers)
         {         {
             SCMBQualifier * theArray=             SCMBQualifier * theArray=
                 (SCMBQualifier*)                 (SCMBQualifier*)
Line 358 
Line 535 
         SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);         SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
         out << STRLIT("</PROPERTY.ARRAY>\n");         out << STRLIT("</PROPERTY.ARRAY>\n");
     }     }
   
       // else Not an array type
     else if (propertyType == CIMTYPE_REFERENCE)     else if (propertyType == CIMTYPE_REFERENCE)
     {     {
         out << STRLIT("<PROPERTY.REFERENCE NAME=\"");         out << STRLIT("<PROPERTY.REFERENCE NAME=\"");
         out.append(          out.append(pName, pLen);
             &(clsbase[propertyDef->name.start]),  
             (propertyDef->name.size-1));  
         out.append('"',' ');         out.append('"',' ');
         //out << STRLIT("\" ");         //out << STRLIT("\" ");
  
         if (0 != propertyDef->refClassName.start)          if ((!noClassExists) && (0 != propertyDef->refClassName.start))
         {         {
             out << STRLIT(" REFERENCECLASS=\"");             out << STRLIT(" REFERENCECLASS=\"");
             out.append(             out.append(
Line 376 
Line 553 
             out.append('"');             out.append('"');
         }         }
  
         if (scmoInstance.inst.hdr->flags.includeClassOrigin)          if (includeClassOrigin)
         {         {
             if (propertyDef->originClassName.start != 0)             if (propertyDef->originClassName.start != 0)
             {             {
Line 387 
Line 564 
                 out.append('"');                 out.append('"');
             }             }
         }         }
         if (propertyDef->flags.propagated)          if (propagated)
         {         {
             out << STRLIT(" PROPAGATED=\"true\"");             out << STRLIT(" PROPAGATED=\"true\"");
         }         }
         out.append('>','\n');         out.append('>','\n');
         //out << STRLIT(">\n");         //out << STRLIT(">\n");
   
         // Append Instance Qualifiers:         // Append Instance Qualifiers:
         if (scmoInstance.inst.hdr->flags.includeQualifiers)          if (includeQualifiers)
         {         {
             SCMBQualifier * theArray=             SCMBQualifier * theArray=
                 (SCMBQualifier*)                 (SCMBQualifier*)
Line 415 
Line 593 
     {     {
         out << STRLIT("<PROPERTY NAME=\"");         out << STRLIT("<PROPERTY NAME=\"");
  
         out.append(          out.append(pName, pLen);
             &(clsbase[propertyDef->name.start]),  
             (propertyDef->name.size-1));  
  
         out.append('"',' ');         out.append('"',' ');
         //out << STRLIT("\" ");         //out << STRLIT("\" ");
  
         if (scmoInstance.inst.hdr->flags.includeClassOrigin)          // User-defined properties will not includeClassOrigin
           if (includeClassOrigin)
         {         {
             if (propertyDef->originClassName.start != 0)             if (propertyDef->originClassName.start != 0)
             {             {
Line 433 
Line 610 
                 out.append('"');                 out.append('"');
             }             }
         }         }
         if (propertyDef->flags.propagated)          if (propagated)
         {         {
             out << STRLIT(" PROPAGATED=\"true\"");             out << STRLIT(" PROPAGATED=\"true\"");
         }         }
Line 469 
Line 646 
         //out << STRLIT(">\n");         //out << STRLIT(">\n");
  
         // Append Instance Qualifiers:         // Append Instance Qualifiers:
         if (scmoInstance.inst.hdr->flags.includeQualifiers)          if (includeQualifiers)
         {         {
             SCMBQualifier * theArray=             SCMBQualifier * theArray=
                 (SCMBQualifier*)                 (SCMBQualifier*)
                     &(clsbase[propertyDef->qualifierArray.start]);                     &(clsbase[propertyDef->qualifierArray.start]);
             // need to iterate              // Iterate through all qualifiers
             for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)             for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
             {             {
                 SCMOXmlWriter::appendQualifierElement(                 SCMOXmlWriter::appendQualifierElement(
Line 523 
Line 700 
         SCMOInstance * ref = value.value.extRefPtr;         SCMOInstance * ref = value.value.extRefPtr;
         if (ref)         if (ref)
         {         {
             appendValueReferenceElement(out, *ref, true);              appendValueReferenceElement(out, *ref);
         }         }
     }     }
     else     else
Line 548 
Line 725 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 void SCMOXmlWriter::appendValueReferenceElement( void SCMOXmlWriter::appendValueReferenceElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& ref,      const SCMOInstance& ref)
     Boolean putValueWrapper)  
 {  
     if (putValueWrapper)  
     {     {
         out << STRLIT("<VALUE.REFERENCE>\n");         out << STRLIT("<VALUE.REFERENCE>\n");
   
       appendClassOrInstancePathElement(out, ref);
   
       out << STRLIT("</VALUE.REFERENCE>\n");
     }     }
  
   // Append either a class or instance Path Element
   void SCMOXmlWriter::appendClassOrInstancePathElement(
       Buffer& out,
       const SCMOInstance& ref)
   {
     // See if it is a class or instance reference (instance references have     // See if it is a class or instance reference (instance references have
     // key-bindings; class references do not).     // key-bindings; class references do not).
  
Line 594 
Line 777 
             appendInstanceNameElement(out, ref);             appendInstanceNameElement(out, ref);
         }         }
     }     }
     if (putValueWrapper)  
     {  
         out << STRLIT("</VALUE.REFERENCE>\n");  
     }  
 } }
  
 // appendLocalInstancePathElement() // appendLocalInstancePathElement()
Line 632 
Line 811 
     out << STRLIT("</INSTANCEPATH>\n");     out << STRLIT("</INSTANCEPATH>\n");
 } }
  
   void SCMOXmlWriter::appendValueObjectWithPathElement(
       Buffer& out,
       const Array<SCMOInstance> & objectWithPath,
       const CIMPropertyList& propertyList)
   {
       if (propertyList.isNull())
       {
           Array<Uint32> emptyNodes;
           for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
           {
               SCMOXmlWriter::appendValueObjectWithPathElement(
                   out,
                   objectWithPath[i],
                   false,
                   emptyNodes);
           }
       }
       else
       {
           Array<propertyFilterNodesArray_t> propFilterNodesArrays;
           for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
           {
               // This searches for an already created array of nodes,
               // if not found, creates it inside propFilterNodesArrays
               const Array<Uint32> & nodes=
                   SCMOXmlWriter::getFilteredNodesArray(
                       propFilterNodesArrays,
                       objectWithPath[i],
                       propertyList);
               SCMOXmlWriter::appendValueObjectWithPathElement(
                   out,
                   objectWithPath[i],
                   true,
                   nodes);
   
           }
       }
   }
   
   //EXP_PULL_BEGIN
   //------------------------------------------------------------------------------
   //
   // appendValueInstanceWithPathElement()
   //
   //     <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)>
   //
   //------------------------------------------------------------------------------
   // EXP_PULL_TBD checkout the INSTANCEPATH vs NAMEDINSTANCE differences
   // Can we create something more common
   void SCMOXmlWriter::appendValueInstanceWithPathElement(
       Buffer& out,
       const SCMOInstance& namedInstance,
       bool filtered,
       const Array<Uint32> & nodes)
   {
       out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");
   
       appendInstancePathElement(out, namedInstance);
       appendInstanceElement(out, namedInstance, filtered, nodes);
   
       out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");
   }
   //EXP_PULL_END
   
 // appendValueObjectWithPathElement() // appendValueObjectWithPathElement()
 //     <!ELEMENT VALUE.OBJECTWITHPATH //     <!ELEMENT VALUE.OBJECTWITHPATH
 //         ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))> //         ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
 void SCMOXmlWriter::appendValueObjectWithPathElement( void SCMOXmlWriter::appendValueObjectWithPathElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& objectWithPath)      const SCMOInstance& objectWithPath,
       bool filtered,
       const Array<Uint32> & nodes)
 { {
     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
  
     appendValueReferenceElement(out, objectWithPath, false);      appendClassOrInstancePathElement(out, objectWithPath);
     appendObjectElement(out, objectWithPath);      appendObjectElement(out, objectWithPath,filtered,nodes);
  
     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
 } }
Line 651 
Line 896 
 // May refer to a CLASS or an INSTANCE // May refer to a CLASS or an INSTANCE
 void SCMOXmlWriter::appendObjectElement( void SCMOXmlWriter::appendObjectElement(
     Buffer& out,     Buffer& out,
     const SCMOInstance& object)      const SCMOInstance& object,
       bool filtered,
       const Array<Uint32> & nodes)
 { {
     if (object.inst.hdr->flags.isClassOnly)     if (object.inst.hdr->flags.isClassOnly)
     {     {
Line 659 
Line 906 
     }     }
     else     else
     {     {
         appendInstanceElement(out, object);          appendInstanceElement(out, object,filtered,nodes);
     }     }
 } }
  
Line 1151 
Line 1398 
                 SCMOInstance * ref = arr->extRefPtr;                 SCMOInstance * ref = arr->extRefPtr;
                 if (ref)                 if (ref)
                 {                 {
                     appendValueReferenceElement(out, *ref, true);                      appendValueReferenceElement(out, *ref);
                 }                 }
                 arr++;                 arr++;
             }             }
             out << STRLIT("</VALUE.REFARRAY>\n");             out << STRLIT("</VALUE.REFARRAY>\n");
               break;
         }         }
         case CIMTYPE_OBJECT:         case CIMTYPE_OBJECT:
         case CIMTYPE_INSTANCE:         case CIMTYPE_INSTANCE:

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