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

Diff for /pegasus/src/Pegasus/Common/CIMResponseData.cpp between version 1.5.2.22 and 1.5.2.29

version 1.5.2.22, 2014/04/07 22:00:22 version 1.5.2.29, 2014/07/17 21:01:31
Line 52 
Line 52 
 // Defines debug code in CIMResponseData.  This under this // Defines debug code in CIMResponseData.  This under this
 // special compile flag so that it can be compiled independent of // special compile flag so that it can be compiled independent of
 // PEGASUS_DEBUG flags. // PEGASUS_DEBUG flags.
 #define CIMRESPONSEDATA_DEBUG  // #define CIMRESPONSEDATA_DEBUG
  
 #define LOCAL_MIN(a, b) ((a < b) ? a : b) #define LOCAL_MIN(a, b) ((a < b) ? a : b)
 // C++ objects interface handling  
   
 // KS_TODO Remove this completely when finished testing.  
 bool CIMResponseData::sizeValid()  
 {  
     PEGASUS_DEBUG_ASSERT(valid());  
 #ifdef CIMRESPONSEDATA_DEBUG  
     if (_size > 1000000)  
     {  
         cout << "CIMResponseData::TEST_SIZE_VALID _size too big "  
              << _size << endl;  
         PEG_TRACE((TRC_XML, Tracer::LEVEL4,  
                    "CIMResponseData::TEST_SIZE_VALID _size too big %u",_size ));  
         return false;  
     }  
 #endif  
 ////  KS TODO Remove this diagnostic completely  
 ////  PEG_TRACE((TRC_XML, Tracer::LEVEL4,  
 ////      "CIMResponseData Size _size=%u", _size));  
     return true;  
 }  
  
 /* /*
     Append an InstanceElement to the Buffer. This function accounts     Append an InstanceElement to the Buffer. This function accounts
Line 115 
Line 94 
 // Instance Names handling // Instance Names handling
 Array<CIMObjectPath>& CIMResponseData::getInstanceNames() Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
 { {
     TEST_SIZE_VALID;  
     PEGASUS_DEBUG_ASSERT(     PEGASUS_DEBUG_ASSERT(
     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
     _resolveToCIM();     _resolveToCIM();
Line 211 
Line 189 
 { {
  
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setSCMO");     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setSCMO");
     //// AutoMutex autoMut(testLock);  
     TEST_SIZE_VALID;  
     _scmoInstances=x;     _scmoInstances=x;
     _encoding |= RESP_ENC_SCMO;     _encoding |= RESP_ENC_SCMO;
     _size += x.size();     _size += x.size();
Line 419 
Line 395 
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::moveObjects");     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::moveObjects");
  
     //// AutoMutex autoMut(testLock);  
   
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,     PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::move(%u)", count));         "CIMResponseData::move(%u)", count));
  
Line 583 
Line 557 
     else     else
     {     {
         from._size = 0;         from._size = 0;
         //// KS_TODO Diagnostic since this should never occur  
         PEG_TRACE((TRC_XML, Tracer::LEVEL1,  
             "Size in from set to zero from= %u rtnSize= %u",  
                 from._size, rtnSize));  
     }     }
  
     //// KS_TODO diagnostic that we should be able to remove     //// KS_TODO diagnostic that we should be able to remove
Line 606 
Line 576 
 // Sets the _size variable based on the internal size counts. // Sets the _size variable based on the internal size counts.
 void CIMResponseData::setSize() void CIMResponseData::setSize()
 { {
     PEGASUS_DEBUG_ASSERT(valid());            //KS_TEMP KS_TODO      PEGASUS_DEBUG_ASSERT(valid());
  
     Uint32 rtnSize = 0;     Uint32 rtnSize = 0;
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
Line 657 
Line 627 
     }     }
     _size = rtnSize;     _size = rtnSize;
 } }
   
 // Return the number of CIM objects in the CIM Response data object  
 // //
 ////#define TEMPLOG PEG_TRACE((TRC_XML, Tracer::LEVEL4, \  // Return the number of CIM objects in the CIM Response data object by
 //// "rtnSize %u size %u line %u", rtnSize, _size, __LINE__))  // aggregating sizes of each of the encodings
 #define TEMPLOG  //
   
 Uint32 CIMResponseData::size() Uint32 CIMResponseData::size()
 { {
     AutoMutex autoMut(testLock);  
     PEG_METHOD_ENTER(TRC_XML,"CIMResponseData::size()");  
     TEST_SIZE_VALID;  
 // If debug mode, add up all the individual size components to // If debug mode, add up all the individual size components to
 // determine overall size of this object.  Then compare this with // determine overall size of this object.  Then compare this with
 // the _size variable.  this is a good check on the completeness of the  // the _size variable.  This is a check on the completeness of the
 // size computations.  We should be able to remove this at some point // size computations.  We should be able to remove this at some point
 // but there are many sources of size info and we need to be sure we // but there are many sources of size info and we need to be sure we
 // have covered them all. // have covered them all.
 #ifdef PEGASUS_DEBUG  #ifdef CIMRESPONSEDATA_DEBUG
     PEGASUS_DEBUG_ASSERT(valid());            //KS_TEMP KS_TODO      PEGASUS_DEBUG_ASSERT(valid());
  
     Uint32 rtnSize = 0;     Uint32 rtnSize = 0;
     TEMPLOG;  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
         TEMPLOG;  
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
Line 696 
Line 659 
                 rtnSize += _instanceData.size();                 rtnSize += _instanceData.size();
                 break;                 break;
         }         }
         TEST_SIZE_VALID;  
         TEMPLOG;  
     }     }
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         TEMPLOG;  
         // KS_PULL_TODO         // KS_PULL_TODO
         // Cannot resolve this one without actually processing         // Cannot resolve this one without actually processing
         // the data since it is a stream.         // the data since it is a stream.
         rtnSize += 0;         rtnSize += 0;
         //  KS_TODO flag on this one  
         //// PEGASUS_ASSERT(false);  
         TEMPLOG;  
     }     }
  
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
     {     {
         TEST_SIZE_VALID;  
         TEMPLOG;  
         rtnSize += _scmoInstances.size();         rtnSize += _scmoInstances.size();
         TEMPLOG;  
     }     }
  
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         TEST_SIZE_VALID;  
         TEMPLOG;  
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
Line 737 
Line 689 
                 rtnSize += _objects.size();                 rtnSize += _objects.size();
                 break;                 break;
         }         }
         TEST_SIZE_VALID;  
         TEMPLOG;  
     }     }
     // Test of actual count against _size variable. KS_TODO diagnostic     // Test of actual count against _size variable. KS_TODO diagnostic
     Uint32 lsize = _size;     Uint32 lsize = _size;
     if (rtnSize != lsize)     if (rtnSize != lsize)
     {     {
         TEMPLOG;  
         TEST_SIZE_VALID;  
         PEG_TRACE((TRC_XML, Tracer::LEVEL1,         PEG_TRACE((TRC_XML, Tracer::LEVEL1,
         "CIMResponseData::size ERROR. debug size mismatch."         "CIMResponseData::size ERROR. debug size mismatch."
             "Computed = %u. variable = %u inc binary %s",rtnSize, _size,             "Computed = %u. variable = %u inc binary %s",rtnSize, _size,
          boolToString(RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))          boolToString(RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
                               ));                               ));
         // KS_TEMP  
         cout << "Size err Computed(rtnsize)=" << rtnSize << " _size=" << lsize  
              << " diff=" << (rtnSize - lsize)  
               << " inc Binary= "  
              << boolToString(RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))  
              << endl;  
         TEMPLOG;  
     }     }
     PEG_TRACE((TRC_XML, Tracer::LEVEL1, "ReturnSize=%u", _size ));  
 #endif #endif
     PEG_METHOD_EXIT();  
     return _size;     return _size;
 } }
  
Line 773 
Line 712 
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::appendResponseData");         "CIMResponseData::appendResponseData");
     //// AutoMutex autoMut(testLock);  
       PEGASUS_DEBUG_ASSERT(valid());
   
     // Confirm that the CIMResponseData type matches the type     // Confirm that the CIMResponseData type matches the type
     // of the data being appended     // of the data being appended
       // A CIMResponseData must represent a single data content type.
       // ex. Cannot mix objects and instances.
  
     PEGASUS_DEBUG_ASSERT(valid());            // KS_TEMP  
     PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);     PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
     _encoding |= x._encoding;     _encoding |= x._encoding;
  
     // add all binary data     // add all binary data
     _binaryData.appendArray(x._binaryData);     _binaryData.appendArray(x._binaryData);
     // KS_TBD TODO PULL Add the counter incrementer for binary  
  
     // add all the C++ stuff     // add all the C++ stuff
     _instanceNames.appendArray(x._instanceNames);     _instanceNames.appendArray(x._instanceNames);
Line 797 
Line 738 
     _scmoInstances.appendArray(x._scmoInstances);     _scmoInstances.appendArray(x._scmoInstances);
     _size += x._scmoInstances.size();     _size += x._scmoInstances.size();
  
     // add Xml encodings  
     // KS_TODO these are temporary. delete before release  
     PEGASUS_ASSERT(x._referencesData.size() == x._instanceData.size());  
     PEGASUS_ASSERT(x._instanceData.size() == x._hostsData.size());  
     PEGASUS_ASSERT(x._instanceData.size() == x._nameSpacesData.size());  
   
     _referencesData.appendArray(x._referencesData);     _referencesData.appendArray(x._referencesData);
     _instanceData.appendArray(x._instanceData);     _instanceData.appendArray(x._instanceData);
     _hostsData.appendArray(x._hostsData);     _hostsData.appendArray(x._hostsData);
Line 821 
Line 756 
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::encodeBinaryResponse");         "CIMResponseData::encodeBinaryResponse");
  
     TEST_SIZE_VALID;  
   
     // Need to do a complete job here by transferring all contained data     // Need to do a complete job here by transferring all contained data
     // into binary format and handing it out in the CIMBuffer     // into binary format and handing it out in the CIMBuffer
     // KS_TODO     // KS_TODO
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         PEGASUS_ASSERT(false);   // KS_TEMP  
   
         // Binary does NOT need a marker as it consists of C++ and SCMO         // Binary does NOT need a marker as it consists of C++ and SCMO
         const Array<Uint8>& data = _binaryData;         const Array<Uint8>& data = _binaryData;
         out.putBytes(data.getData(), data.size());         out.putBytes(data.getData(), data.size());
Line 988 
Line 919 
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::completeHostNameAndNamespace");         "CIMResponseData::completeHostNameAndNamespace");
  
     PEGASUS_DEBUG_ASSERT(valid());            // KS_TEMP      PEGASUS_DEBUG_ASSERT(valid());
   
     Uint32 count = 0;      //// KS_TODO this counter is just diagnostic  
  
         PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,   // KS_TODO TEMP  ////  PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,   // KS_TODO TEMP
           "completeHostNameAndNamespace Setting hostName, etc "  ////    "completeHostNameAndNamespace Setting hostName, etc "
           "host %s ns %s set for dataType=%u encoding=%u isPull=%s",  ////    "host %s ns %s set for dataType=%u encoding=%u isPull=%s",
               (const char *)hn.getCString(),  ////        (const char *)hn.getCString(),
               (const char *)ns.getString().getCString(),  ////        (const char *)ns.getString().getCString(),
               _dataType, _encoding, boolToString(isPullOperation) ));  ////        _dataType, _encoding, boolToString(isPullOperation) ));
  
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
Line 1006 
Line 935 
         // -> usage: See resolveBinary()         // -> usage: See resolveBinary()
         _defaultNamespace=ns;         _defaultNamespace=ns;
         _defaultHostname=hn;         _defaultHostname=hn;
         count++;  
     }     }
     // InternalXml does not support objectPath calls     // InternalXml does not support objectPath calls
     if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&     if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&
Line 1017 
Line 945 
             if (0 == _hostsData[j].size())             if (0 == _hostsData[j].size())
             {             {
                 _hostsData[j]=hn;                 _hostsData[j]=hn;
                 count++;  
             }             }
             if (_nameSpacesData[j].isNull())             if (_nameSpacesData[j].isNull())
             {             {
Line 1033 
Line 960 
         {         {
             if (0 == _hostsData[j].size())             if (0 == _hostsData[j].size())
             {             {
                 count++;  
                 _hostsData[j]=hn;                 _hostsData[j]=hn;
             }             }
             if (_nameSpacesData[j].isNull())             if (_nameSpacesData[j].isNull())
Line 1066 
Line 992 
                         const_cast<CIMObjectPath&>(instance.getPath());                         const_cast<CIMObjectPath&>(instance.getPath());
                     if (p.getHost().size()==0)                     if (p.getHost().size()==0)
                     {                     {
                         count++;  
                         p.setHost(hn);                         p.setHost(hn);
                     }                     }
                     if (p.getNameSpace().isNull())                     if (p.getNameSpace().isNull())
Line 1083 
Line 1008 
                         const_cast<CIMObjectPath&>(object.getPath());                         const_cast<CIMObjectPath&>(object.getPath());
                     if (p.getHost().size()==0)                     if (p.getHost().size()==0)
                     {                     {
                         count++;  
                         p.setHost(hn);                         p.setHost(hn);
                     }                     }
                     if (p.getNameSpace().isNull())                     if (p.getNameSpace().isNull())
Line 1103 
Line 1027 
                     CIMObjectPath& p = _instanceNames[j];                     CIMObjectPath& p = _instanceNames[j];
                     if (p.getHost().size() == 0)                     if (p.getHost().size() == 0)
                     {                     {
                         count++;  
                         p.setHost(hn);                         p.setHost(hn);
                     }                     }
                     if (p.getNameSpace().isNull())                     if (p.getNameSpace().isNull())
Line 1138 
Line 1061 
             {             {
                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
                 {                 {
                     count++;  
                     SCMOInstance & scmoInst=_scmoInstances[j];                     SCMOInstance & scmoInst=_scmoInstances[j];
                     scmoInst.completeHostNameAndNamespace(                     scmoInst.completeHostNameAndNamespace(
                         hnChars,                         hnChars,
Line 1154 
Line 1076 
             }             }
         }         }
     }     }
     PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,   // KS_TODO TEMP  
       "completeHostNameAndNamespace Set hostName, etc count %u "  
       "host %s ns %s set for dataType=%u encoding=%u isPull=%s",  
           count,  
           (const char *)hn.getCString(),  
           (const char *)ns.getString().getCString(),  
           _dataType, _encoding, boolToString(isPullOperation) ));  
   
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
Line 1210 
Line 1123 
                 {                 {
                     if (isPullResponse)                     if (isPullResponse)
                     {                     {
                         // KS_TODO these are temporary. delete before release  
                         PEGASUS_ASSERT(a.size() == b.size());  
                         PEGASUS_ASSERT(a.size() == _hostsData.size());  
                         PEGASUS_ASSERT(a.size() == _nameSpacesData.size());  
   
                         out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");                         out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");
                         out << STRLIT("<INSTANCEPATH>\n");                         out << STRLIT("<INSTANCEPATH>\n");
                         XmlWriter::appendNameSpacePathElement(out,                         XmlWriter::appendNameSpacePathElement(out,
Line 1376 
Line 1284 
                     // If pull, map to instances                     // If pull, map to instances
                     if (isPullResponse)                     if (isPullResponse)
                     {                     {
   
                         CIMInstance x = (CIMInstance)_objects[i];                         CIMInstance x = (CIMInstance)_objects[i];
                           if (encodeInstanceOnly)
                           {
                               XmlWriter::appendInstanceElement(
                                   out,
                                   x,
                                   _includeQualifiers,
                                   _includeClassOrigin,
                                   _propertyList);
                           }
                           else
                           {
                         XmlWriter::appendValueInstanceWithPathElement(                         XmlWriter::appendValueInstanceWithPathElement(
                             out,                             out,
                             x,                             x,
Line 1384 
Line 1304 
                             _includeClassOrigin,                             _includeClassOrigin,
                             _propertyList);                             _propertyList);
                     }                     }
                       }
                     else                     else
                     {                     {
                         XmlWriter::appendValueObjectWithPathElement(                         XmlWriter::appendValueObjectWithPathElement(
Line 1468 
Line 1389 
                     // OpenQueryInstances and pullInstances                     // OpenQueryInstances and pullInstances
                     if (encodeInstanceOnly)                     if (encodeInstanceOnly)
                     {                     {
                           // KS_TODO move this to SCMOXmlWriter
                         for (Uint32 i = 0, n = _scmoInstances.size();i < n; i++)                         for (Uint32 i = 0, n = _scmoInstances.size();i < n; i++)
                         {                         {
                             _appendInstanceElement(out, _scmoInstances[i]);                             _appendInstanceElement(out, _scmoInstances[i]);
Line 1490 
Line 1412 
             {             {
                 if (isPullResponse)                 if (isPullResponse)
                 {                 {
                       // if encodeInstanceOnly flag, encode objects as instances
                       // Used by OpenQueryInstances and pullInstances.
                       if (encodeInstanceOnly)
                       {
                           for (Uint32 i = 0, n = _scmoInstances.size();i < n; i++)
                           {
                               _appendInstanceElement(out, _scmoInstances[i]);
                           }
                       }
                       else
                       {
                     SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(                     SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(
                         out,_scmoInstances, _propertyList);                         out,_scmoInstances, _propertyList);
                 }                 }
                   }
                 else                 else
                 {                 {
                     // KS_TODO why is this one named element rather than                     // KS_TODO why is this one named element rather than
Line 2266 
Line 2200 
     _isClassOperation = b;     _isClassOperation = b;
 } }
  
 //// KS_TODO Remove. Diagnostic Displays below before commit to head  // Clear all of the input encodings by clearing their arrays and
 void CIMResponseData::traceResponseData()  // unsetting the encoding flag.
 {  void CIMResponseData::clear()
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,  
         "%s", (const char*)toStringTraceResponseData().getCString() ));  
 }  
 String CIMResponseData::toStringTraceResponseData()  
 { {
     int rtnSize;      // Clear the xml data area
     char *p;      _referencesData.clear();
       _hostsData.clear();
       _nameSpacesData.clear();
       _instanceData.clear();
   
       // Clear the binary data area
       _binaryData.clear();
  
     int allocSize = 256;      // Clear the SCMO data
       _scmoInstances.clear();
   
       //Clear the C++ Data areaa
       _instanceNames.clear();
       _instances.clear();
       _objects.clear();
  
     if ((p = (char*)malloc(allocSize)) == NULL)      _encoding = 0;
       _size = 0;
   }
   
   // The following are debugging support only
   //// #ifdef PEGASUS_DEBUG
   void CIMResponseData::traceResponseData() const
     {     {
         return String();      PEG_TRACE((TRC_XML, Tracer::LEVEL3,
           "%s", (const char*)toStringTraceResponseData().getCString() ));
     }     }
  
     do  String CIMResponseData::toStringTraceResponseData() const
     {     {
         rtnSize = snprintf(p, allocSize,      String rtnStr;
       rtnStr.appendPrintf(
         "CIMResponseData::traceResponseData(encoding=%X,dataType=%X "         "CIMResponseData::traceResponseData(encoding=%X,dataType=%X "
         " size=%u C++instNamecount=%u c++Instances=%u c++Objects=%u "         " size=%u C++instNamecount=%u c++Instances=%u c++Objects=%u "
         "scomInstances=%u XMLInstData=%u binaryData=%u "         "scomInstances=%u XMLInstData=%u binaryData=%u "
Line 2297 
Line 2247 
         _referencesData.size(), _instanceData.size(), _hostsData.size(),         _referencesData.size(), _instanceData.size(), _hostsData.size(),
         _nameSpacesData.size());         _nameSpacesData.size());
  
         // return if successful if not negative and  
         // returns less than allocated size.  
         if (rtnSize > -1 && rtnSize < allocSize)  
         {  
             break;  
         }  
   
         // increment alloc size. Assumes that positive return is  
         // expected size and negative is error.  
         allocSize = (rtnSize > -1)? (rtnSize + 1) : allocSize * 2;  
   
     } while((p = (char*)peg_inln_realloc(p, allocSize)) != NULL);  
   
     // Free allocated memory and return formatted output in String  
     String rtnStr(p);  
     free(p);  
     return(rtnStr);     return(rtnStr);
 } }
   //// #endif
  
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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