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

Diff for /pegasus/src/Pegasus/Common/CIMResponseData.h between version 1.3.2.2 and 1.9

version 1.3.2.2, 2009/09/03 13:54:05 version 1.9, 2012/08/08 08:27:59
Line 48 
Line 48 
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
  
 //-----------------------------------------------------------------------------  class PEGASUS_COMMON_LINKAGE CIMResponseData
 //  
 //  CIMInstanceNamesResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMInstanceNamesResponseData  
 { {
 public: public:
  
     enum ResponseDataEncoding {     enum ResponseDataEncoding {
         RESP_ENC_CIM,          RESP_ENC_CIM = 1,
         RESP_ENC_BINARY,          RESP_ENC_BINARY = 2,
         RESP_ENC_XML,          RESP_ENC_XML = 4,
         RESP_ENC_SCMO          RESP_ENC_SCMO = 8
     };     };
  
     CIMInstanceNamesResponseData():      enum ResponseDataContent {
         _resolveCallback(0),          RESP_INSTNAMES = 1,
         _encoding(RESP_ENC_CIM)          RESP_INSTANCES = 2,
           RESP_INSTANCE = 3,
           RESP_OBJECTS = 4,
           RESP_OBJECTPATHS = 5
       };
       //includeClassOrigin & _includeQualifiers are set to true by default.
       //_propertyList is initialized to an empty propertylist to enable
       // sending all properties by default.
       CIMResponseData(ResponseDataContent content):
           _encoding(0),_dataType(content),_includeQualifiers(true),
           _includeClassOrigin(true),_propertyList(CIMPropertyList())
     {     {
     }     }
  
     Array<CIMObjectPath>& getInstanceNames()      CIMResponseData(const CIMResponseData & x):
           _encoding(x._encoding),
           _dataType(x._dataType),
           _referencesData(x._referencesData),
           _instanceData(x._instanceData),
           _hostsData(x._hostsData),
           _nameSpacesData(x._nameSpacesData),
           _binaryData(x._binaryData),
           _defaultNamespace(x._defaultNamespace),
           _defaultHostname(x._defaultHostname),
           _instanceNames(x._instanceNames),
           _instances(x._instances),
           _objects(x._objects),
           _scmoInstances(x._scmoInstances),
           _includeQualifiers(x._includeQualifiers),
           _includeClassOrigin(x._includeClassOrigin),
           _propertyList(x._propertyList)
     {     {
         _resolve();  
         return _instanceNames;  
     }     }
  
     /*const Array<CIMConstObjectPath>& getInstanceNames() const      ~CIMResponseData()
     {     {
         // Resolve the instances before returning them.  The resolve step      }
         // requires non-const access, but does not fundamentally change the  
         // message contents.  
         const_cast<CIMInstanceNamesResponseData*>(this)->_resolve();  
  
         // The Array<CIMInstance> is masqueraded as an Array<CIMConstInstance>      // C++ objects interface handling
         // for expedience, since the internal representations are the same.  
         return *((Array<CIMConstObjectPath>*)(void*)&_instanceNames);      // Instance Names handling
     }*/      Array<CIMObjectPath>& getInstanceNames();
  
     void setInstanceNames(const Array<CIMObjectPath>& x)     void setInstanceNames(const Array<CIMObjectPath>& x)
     {     {
         _resolveCallback = 0;  
         _instanceNames = x;         _instanceNames = x;
           _encoding |= RESP_ENC_CIM;
     }     }
  
     void appendInstanceName(const CIMObjectPath& x)      // Instance handling
     {      CIMInstance& getInstance();
         _resolveCallback = 0;  
         _instanceNames.append(x);  
     }  
  
     void setSCMOInstanceNames(const Array<SCMOInstance>& x)      void setInstance(const CIMInstance& x)
     {     {
         _resolveCallback = _resolveSCMOInstanceNames;          _instances.clear();
         fprintf(          _instances.append(x);
             stderr,          _encoding |= RESP_ENC_CIM;
             "CIMResponseData::setSCMOInstanceNames(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstanceNames = x;  
     }     }
  
     void appendSCMOInstanceName(const SCMOInstance& x)      // Instances handling
     {      Array<CIMInstance>& getInstances();
         _resolveCallback = _resolveSCMOInstanceNames;  
         fprintf(  
             stderr,  
             "CIMResponseData::appendSCMOInstanceName(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstanceNames.append(x);  
     }  
  
     Array<Uint8>& getBinaryCimInstanceNames()      void setInstances(const Array<CIMInstance>& x)
     {     {
         return _binaryData;          _instances=x;
           _encoding |= RESP_ENC_CIM;
     }     }
       void appendInstance(const CIMInstance& x)
     bool setBinaryCimInstanceNames(CIMBuffer& in, bool hasLen=true);  
     bool setXmlCimInstanceNames(CIMBuffer& in);  
   
     void encodeBinaryResponse(CIMBuffer& out);  
     void encodeXmlResponse(Buffer& out);  
   
 private:  
   
     CIMInstanceNamesResponseData(const CIMInstanceNamesResponseData&);  
     CIMInstanceNamesResponseData& operator=(  
         const CIMInstanceNamesResponseData&);  
   
     static Boolean _resolveXMLInstanceNames(  
         CIMInstanceNamesResponseData* data,  
         Array<CIMObjectPath>& instanceNames);  
   
     static Boolean _resolveBinaryInstanceNames(  
         CIMInstanceNamesResponseData* data,  
         Array<CIMObjectPath>& instanceNames);  
   
     static Boolean _resolveSCMOInstanceNames(  
         CIMInstanceNamesResponseData* data,  
         Array<CIMObjectPath>& instanceNames);  
   
     Boolean (*_resolveCallback)(  
         CIMInstanceNamesResponseData* data,  
         Array<CIMObjectPath>& cimInstance);  
   
     void _resolve()  
     {  
         if (_resolveCallback)  
         {         {
             (*_resolveCallback)(this, _instanceNames);          _instances.append(x);
             _resolveCallback = 0;          _encoding |= RESP_ENC_CIM;
         }  
     }     }
  
     ResponseDataEncoding _encoding;      // Objects handling
       Array<CIMObject>& getObjects();
     // For XML encoding.      void setObjects(const Array<CIMObject>& x)
     Array<ArraySint8> _referencesData;  
     Array<String> _hostsData;  
     Array<CIMNamespaceName> _nameSpacesData;  
   
     // For binary encoding.  
     Array<Uint8> _binaryData;  
   
     Array<CIMObjectPath> _instanceNames;  
     Array<SCMOInstance> _scmoInstanceNames;  
 };  
   
   
 //-----------------------------------------------------------------------------  
 //  
 //  CIMInstanceResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMInstanceResponseData  
 { {
 public:          _objects=x;
           _encoding |= RESP_ENC_CIM;
     CIMInstanceResponseData():  
         _resolveCallback(0),  
         _binaryEncoding(false)  
     {  
     }  
   
     CIMInstance& getCimInstance()  
     {  
         _resolve();  
         return _cimInstance;  
     }  
   
     const CIMConstInstance& getCimInstance() const  
     {  
         // Resolve the instance before returning it.  The resolve step requires  
         // non-const access, but does not fundamentally change the response  
         const_cast<CIMInstanceResponseData*>(this)->_resolve();  
   
         // The CIMInstance is masqueraded as a CIMConstInstance for expedience,  
         // since the internal representations are the same.  
         return *((CIMConstInstance*)(void*)&_cimInstance);  
     }     }
       void appendObject(const CIMObject& x)
     void setCimInstance(const CIMInstance& x)  
     {     {
         _resolveCallback = 0;          _objects.append(x);
         _cimInstance = x;          _encoding |= RESP_ENC_CIM;
     }     }
  
     Array<Uint8>& getBinaryCimInstance()      // SCMO representation, single instance stored as one element array
     {      // object paths are represented as SCMOInstance
         return _binaryData;      Array<SCMOInstance>& getSCMO();
     }  
   
     bool setBinaryCimInstance(CIMBuffer& in, bool hasLen=true);  
     bool setXmlCimInstance(CIMBuffer& in);  
   
     void encodeBinaryResponse(CIMBuffer& out) const;  
     void encodeXmlResponse(Buffer& out) const;  
   
 private:  
   
     CIMInstanceResponseData(const CIMInstanceResponseData&);  
     CIMInstanceResponseData& operator=(  
         const CIMInstanceResponseData&);  
   
     static Boolean _resolveXMLInstance(  
         CIMInstanceResponseData* data,  
         CIMInstance& instance);  
   
     static Boolean _resolveBinaryInstance(  
         CIMInstanceResponseData* data,  
         CIMInstance& instance);  
   
     Boolean (*_resolveCallback)(  
         CIMInstanceResponseData* msg,  
         CIMInstance& cimInstance);  
   
     void _resolve()  
     {  
         if (_resolveCallback)  
         {  
             (*_resolveCallback)(this, _cimInstance);  
             _resolveCallback = 0;  
         }  
     }  
   
     Boolean _binaryEncoding;  
   
     // For XML encoding:  
     Array<Sint8> _instanceData;  
     Array<Sint8> _referenceData;  
     CIMNamespaceName _nameSpaceData;  
     String _hostData;  
   
     // For Binary encoding:  
     Array<Uint8> _binaryData;  
   
     CIMInstance _cimInstance;  
   
 };  
   
   
 //-----------------------------------------------------------------------------  
 //  
 //  CIMInstancesResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMInstancesResponseData  
 {  
 public:  
   
     enum ResponseDataEncoding {  
         RESP_ENC_CIM,  
         RESP_ENC_BINARY,  
         RESP_ENC_XML,  
         RESP_ENC_SCMO  
     };  
  
     CIMInstancesResponseData():      void setSCMO(const Array<SCMOInstance>& x);
         _resolveCallback(0),  
         _encoding(RESP_ENC_CIM)  
     {  
     }  
  
     Array<CIMInstance>& getNamedInstances()      void appendSCMO(const Array<SCMOInstance>& x)
     {     {
         //_resolve();          _scmoInstances.appendArray(x);
         return _namedInstances;          _encoding |= RESP_ENC_SCMO;
     }     }
  
     const Array<CIMConstInstance>& getNamedInstances() const      Array<Uint8>& getBinary();
     {  
         // Resolve the instances before returning them.  The resolve step  
         // requires non-const access, but does not fundamentally change the  
         // message contents.  
         // const_cast<CIMInstancesResponseData*>(this)->_resolve();  
  
         // The Array<CIMInstance> is masqueraded as an Array<CIMConstInstance>      // Set the binary stream in the CIMBuffer into the CIMResponseData
         // for expedience, since the internal representations are the same.      bool setBinary(CIMBuffer& in);
         return *((Array<CIMConstInstance>*)(void*)&_namedInstances);  
     }  
  
     void setNamedInstances(const Array<CIMInstance>& x)      // Set any data from the CIMBuffer remaining after the current CIMBuffer
     {      // position pointer into the CIMResponseData Object.
         _resolveCallback = 0;      bool setRemainingBinaryData(CIMBuffer& in);
         _namedInstances = x;  
     }  
  
     void appendNamedInstance(const CIMInstance& x)      // Xml data is unformatted, no need to differentiate between instance
     {      // instances and object paths or objects
         _resolveCallback = 0;      bool setXml(CIMBuffer& in);
         _namedInstances.append(x);  
     }  
  
     void setSCMOInstances(const Array<SCMOInstance>& x)      // function used by OperationAggregator to aggregate response data in a
     {      // single ResponseData object
         _resolveCallback = _resolveSCMOInstances;      void appendResponseData(const CIMResponseData & x);
         fprintf(  
             stderr,  
             "CIMResponseData::setSCMOInstances(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstances = x;  
     }  
  
     void appendSCMOInstance(const SCMOInstance& x)      // Function used by CMPI layer to complete the namespace on all data held
     {      // Input (x) has to have a valid namespace
         _resolveCallback = _resolveSCMOInstances;      void completeNamespace(const SCMOInstance * x);
         fprintf(  
             stderr,  
             "CIMResponseData::appendSCMOInstance(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstances.append(x);  
     }  
  
     void appendResponseData(const CIMInstancesResponseData & x)      // Function primarily used by CIMOperationRequestDispatcher to complete
     {      // namespace and hostname on a,an,r and rn operations in the
         _namedInstances.appendArray(x._namedInstances);      // OperationAggregator
         _scmoInstances.appendArray(x._scmoInstances);      void completeHostNameAndNamespace(
     }          const String & hn,
           const CIMNamespaceName & ns);
     Array<Uint8>& getBinaryCimInstances()  
     {  
         return _binaryData;  
     }  
  
     bool setBinaryCimInstances(CIMBuffer& in, bool hasLen=true);      // Encoding responses
     bool setXmlCimInstances(CIMBuffer& in);  
  
       // binary format used with Provider Agents and OP Clients
     void encodeBinaryResponse(CIMBuffer& out);     void encodeBinaryResponse(CIMBuffer& out);
       // Xml format used with Provider Agents only
       void encodeInternalXmlResponse(CIMBuffer& out);
       // official Xml format(CIM over Http) used to communicate to clients
     void encodeXmlResponse(Buffer& out);     void encodeXmlResponse(Buffer& out);
  
 private:      //This function is called from buildResponce to set CIMResponcedata
       //with respective values of IncludeQualifiers,IncludeClassOrigin and
     CIMInstancesResponseData(const CIMInstancesResponseData&);      //propertyFilter.
     CIMInstancesResponseData& operator=(      void setRequestProperties(
         const CIMInstancesResponseData&);          const Boolean includeQualifiers,
           const Boolean includeClassOrigin,
     static Boolean _resolveXMLInstances(          const CIMPropertyList& propertyList);
         CIMInstancesResponseData* data,  
         Array<CIMInstance>& instances);  
   
     static Boolean _resolveBinaryInstances(  
         CIMInstancesResponseData* data,  
         Array<CIMInstance>& instances);  
   
     static Boolean _resolveSCMOInstances(  
         CIMInstancesResponseData* data,  
         Array<CIMInstance>& instances);  
  
     Boolean (*_resolveCallback)(      void setPropertyList(const CIMPropertyList& propertyList)
         CIMInstancesResponseData* data,  
         Array<CIMInstance>& cimInstance);  
   
     void _resolve()  
     {  
         if (_resolveCallback)  
         {         {
             (*_resolveCallback)(this, _namedInstances);          _propertyList = propertyList;
             _resolveCallback = 0;  
         }  
     }     }
       CIMPropertyList & getPropertyList()
     ResponseDataEncoding _encoding;  
   
     // For XML encoding.  
     Array<ArraySint8> _instancesData;  
     Array<ArraySint8> _referencesData;  
     Array<String> _hostsData;  
     Array<CIMNamespaceName> _nameSpacesData;  
   
     // For binary encoding.  
     Array<Uint8> _binaryData;  
   
     Array<CIMInstance> _namedInstances;  
     Array<SCMOInstance> _scmoInstances;  
 };  
   
   
 //-----------------------------------------------------------------------------  
 //  
 //  CIMObjectsResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMObjectsResponseData  
 {  
 public:  
   
     CIMObjectsResponseData():  
         _resolveCallback(0),  
         _binaryEncoding(false)  
     {  
     }  
   
     Array<CIMObject>& getCIMObjects()  
     {     {
         _resolve();          return _propertyList;
         return _cimObjects;  
     }     }
  
     const Array<CIMConstObject>& getCIMObjects() const  
     {  
         // Resolve the instances before returning them.  The resolve step  
         // requires non-const access, but does not fundamentally change the  
         // message contents.  
         const_cast<CIMObjectsResponseData*>(this)->_resolve();  
   
         // The Array<CIMInstance> is masqueraded as an Array<CIMConstInstance>  
         // for expedience, since the internal representations are the same.  
         return *((Array<CIMConstObject>*)(void*)&_cimObjects);  
     }  
   
     void setCIMObjects(const Array<CIMObject>& x)  
     {  
         _resolveCallback = 0;  
         _cimObjects = x;  
     }  
   
     Array<Uint8>& getBinaryCimObjects()  
     {  
         return _binaryData;  
     }  
   
     bool setBinaryCimObjects(CIMBuffer& in, bool hasLen=true);  
     bool setXmlCimObjects(CIMBuffer& in);  
   
     void encodeBinaryResponse(CIMBuffer& out) const;  
     void encodeXmlResponse(Buffer& out) const;  
   
 private: private:
  
     CIMObjectsResponseData(const CIMObjectsResponseData&);      // helper functions to transform different formats into one-another
     CIMObjectsResponseData& operator=(      // functions work on the internal data and calling of them should be
         const CIMObjectsResponseData&);      // avoided
   
     static Boolean _resolveXMLObjects(      void _resolveToCIM();
         CIMObjectsResponseData* data,      void _resolveToSCMO();
         Array<CIMObject>& objects);  
       void _resolveBinary();
     static Boolean _resolveBinaryObjects(  
         CIMObjectsResponseData* data,      void _resolveXmlToSCMO();
         Array<CIMObject>& objects);      void _resolveXmlToCIM();
   
     Boolean (*_resolveCallback)(      void _resolveSCMOToCIM();
         CIMObjectsResponseData* data,      void _resolveCIMToSCMO();
         Array<CIMObject>& cimObjects);  
       // Helper functions for this class only, do NOT externalize
     void _resolve()      SCMOInstance _getSCMOFromCIMInstance(const CIMInstance& cimInst);
     {      SCMOInstance _getSCMOFromCIMObject(const CIMObject& cimObj);
         if (_resolveCallback)      SCMOInstance _getSCMOFromCIMObjectPath(const CIMObjectPath& cimPath);
         {      SCMOClass* _getSCMOClass(const char* ns,const char* cls);
             (*_resolveCallback)(this, _cimObjects);      void _deserializeInstance(Uint32 idx,CIMInstance& cimInstance);
             _resolveCallback = 0;      void _deserializeObject(Uint32 idx,CIMObject& cimObject);
         }      Boolean _deserializeReference(Uint32 idx,CIMObjectPath& cimObjectPath);
     }      Boolean _deserializeInstanceName(Uint32 idx,CIMObjectPath& cimObjectPath);
   
     Boolean _binaryEncoding;      // Bitflags in this integer will reflect what data representation types
       // are currently stored in this CIMResponseData object
       Uint32 _encoding;
   
       // Storing type of data in this enumeration
       ResponseDataContent _dataType;
   
       // unused arrays are represented by ArrayRepBase _empty_rep
       // which is a 16 byte large static shared across all of them
       // so, even though this object looks large, it holds just
       // 2 integer and 9 pointers
  
     // For XML encoding.     // For XML encoding.
     // For XML encoding.  
     Array<ArraySint8> _cimObjectsData;  
     Array<ArraySint8> _referencesData;     Array<ArraySint8> _referencesData;
       Array<ArraySint8> _instanceData;
     Array<String> _hostsData;     Array<String> _hostsData;
     Array<CIMNamespaceName> _nameSpacesData;     Array<CIMNamespaceName> _nameSpacesData;
  
   
     // For binary encoding.     // For binary encoding.
     Array<Uint8> _binaryData;     Array<Uint8> _binaryData;
       CIMNamespaceName _defaultNamespace;
       String _defaultHostname;
   
       // Default C++ encoding
       Array<CIMObjectPath> _instanceNames;
       Array<CIMInstance> _instances;
       Array<CIMObject> _objects;
   
       // SCMO encoding
       Array<SCMOInstance> _scmoInstances;
       Boolean _includeQualifiers;
       Boolean _includeClassOrigin;
       CIMPropertyList _propertyList;
  
     Array<CIMObject> _cimObjects;  
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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