(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.4.2.11 and 1.5

version 1.4.2.11, 2014/05/15 20:52:48 version 1.5, 2011/01/25 11:24:24
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>
Line 132 
Line 127 
     }     }
 } }
  
 // 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,
Line 223 
Line 176 
             if (SCMO_OK == smrc)             if (SCMO_OK == smrc)
             {             {
                 SCMOInstance * ref = kbValue->extRefPtr;                 SCMOInstance * ref = kbValue->extRefPtr;
                 appendValueReferenceElement(out, *ref);                  appendValueReferenceElement(out, *ref, true);
             }             }
         }         }
         else         else
Line 672 
Line 625 
         SCMOInstance * ref = value.value.extRefPtr;         SCMOInstance * ref = value.value.extRefPtr;
         if (ref)         if (ref)
         {         {
             appendValueReferenceElement(out, *ref);              appendValueReferenceElement(out, *ref, true);
         }         }
     }     }
     else     else
Line 697 
Line 650 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 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 749 
Line 696 
             appendInstanceNameElement(out, ref);             appendInstanceNameElement(out, ref);
         }         }
     }     }
       if (putValueWrapper)
       {
           out << STRLIT("</VALUE.REFERENCE>\n");
       }
 } }
  
 // appendLocalInstancePathElement() // appendLocalInstancePathElement()
Line 782 
Line 733 
     appendInstanceNameElement(out, instancePath);     appendInstanceNameElement(out, instancePath);
     out << STRLIT("</INSTANCEPATH>\n");     out << STRLIT("</INSTANCEPATH>\n");
 } }
   
 void SCMOXmlWriter::appendValueObjectWithPathElement( void SCMOXmlWriter::appendValueObjectWithPathElement(
     Buffer& out,     Buffer& out,
     const Array<SCMOInstance> & objectWithPath,     const Array<SCMOInstance> & objectWithPath,
Line 822 
Line 772 
     }     }
 } }
  
 //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))>
Line 858 
Line 783 
 { {
     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
  
     appendClassOrInstancePathElement(out, objectWithPath);      appendValueReferenceElement(out, objectWithPath, false);
     appendObjectElement(out, objectWithPath,filtered,nodes);     appendObjectElement(out, objectWithPath,filtered,nodes);
  
     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
Line 1370 
Line 1295 
                 SCMOInstance * ref = arr->extRefPtr;                 SCMOInstance * ref = arr->extRefPtr;
                 if (ref)                 if (ref)
                 {                 {
                     appendValueReferenceElement(out, *ref);                      appendValueReferenceElement(out, *ref, true);
                 }                 }
                 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.4.2.11  
changed lines
  Added in v.1.5
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2