(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.1 and 1.3.2.9

version 1.3.2.1, 2009/08/17 13:47:46 version 1.3.2.9, 2009/11/10 09:43:32
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
       };
  
     Array<CIMObjectPath>& getInstanceNames()      CIMResponseData(ResponseDataContent content):_encoding(0),_dataType(content)
     {      {};
         _resolve();  
         return _instanceNames;  
     }  
  
     /*const Array<CIMConstObjectPath>& getInstanceNames() const      // C++ objects interface handling
     {  
         // Resolve the instances before returning them.  The resolve step      // Instance Names handling
         // requires non-const access, but does not fundamentally change the      Array<CIMObjectPath>& getInstanceNames();
         // message contents.  
         const_cast<CIMInstanceNamesResponseData*>(this)->_resolve();  
   
         // The Array<CIMInstance> is masqueraded as an Array<CIMConstInstance>  
         // for expedience, since the internal representations are the same.  
         return *((Array<CIMConstObjectPath>*)(void*)&_instanceNames);  
     }*/  
  
     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)     void appendInstanceName(const CIMObjectPath& x)
     {     {
         _resolveCallback = 0;  
         _instanceNames.append(x);         _instanceNames.append(x);
           _encoding |= RESP_ENC_CIM;
     }     }
  
     void setSCMOInstanceNames(const Array<SCMOInstance>& x)      // Instance handling
     {      CIMInstance& getInstance();
         _resolveCallback = _resolveSCMOInstanceNames;  
         fprintf(  
             stderr,  
             "CIMResponseData::setSCMOInstanceNames(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstanceNames = x;  
     }  
   
     void appendSCMOInstanceName(const SCMOInstance& x)  
     {  
         _resolveCallback = _resolveSCMOInstanceNames;  
         fprintf(  
             stderr,  
             "CIMResponseData::appendSCMOInstanceName(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstanceNames.append(x);  
     }  
   
     Array<Uint8>& getBinaryCimInstanceNames()  
     {  
         return _binaryData;  
     }  
   
     bool setBinaryCimInstanceNames(CIMBuffer& in, bool hasLen=true);  
     bool setXmlCimInstanceNames(CIMBuffer& in);  
  
     void encodeBinaryResponse(CIMBuffer& out);      void setInstance(const CIMInstance& x)
     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)          _instances.clear();
         {          _instances.append(x);
             (*_resolveCallback)(this, _instanceNames);          _encoding |= RESP_ENC_CIM;
             _resolveCallback = 0;  
         }  
     }     }
  
     ResponseDataEncoding _encoding;      // Instances handling
       Array<CIMInstance>& getInstances();
     // For XML encoding.  
     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      void setInstances(const Array<CIMInstance>& x)
 {  
 public:  
   
     CIMInstanceResponseData():  
         _resolveCallback(0),  
         _binaryEncoding(false)  
     {     {
           _instances=x;
           _encoding |= RESP_ENC_CIM;
     }     }
       void appendInstance(const CIMInstance& x)
     CIMInstance& getCimInstance()  
     {     {
         _resolve();          _instances.append(x);
         return _cimInstance;          _encoding |= RESP_ENC_CIM;
     }     }
  
     const CIMConstInstance& getCimInstance() const      // Objects handling
       Array<CIMObject>& getObjects();
       void setObjects(const Array<CIMObject>& x)
     {     {
         // Resolve the instance before returning it.  The resolve step requires          _objects=x;
         // non-const access, but does not fundamentally change the response          _encoding |= RESP_ENC_CIM;
         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;  
         _cimInstance = x;  
     }  
   
     Array<Uint8>& getBinaryCimInstance()  
     {     {
         return _binaryData;          _objects.append(x);
           _encoding |= RESP_ENC_CIM;
     }     }
  
     bool setBinaryCimInstance(CIMBuffer& in, bool hasLen=true);      // SCMO representation, single instance stored as one element array
     bool setXmlCimInstance(CIMBuffer& in);      // object paths are represented as SCMOInstance
       Array<SCMOInstance>& getSCMO();
  
     void encodeBinaryResponse(CIMBuffer& out) const;      void setSCMO(const Array<SCMOInstance>& x);
     void encodeXmlResponse(Buffer& out) const;  
  
 private:      void appendSCMO(const Array<SCMOInstance>& x)
   
     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);          _scmoInstances.appendArray(x);
             _resolveCallback = 0;          _encoding |= RESP_ENC_SCMO;
         }  
     }     }
  
     Boolean _binaryEncoding;      // Binary data is just a data stream
       Array<Uint8>& getBinary();
       bool setBinary(CIMBuffer& in, bool hasLen=true);
  
     // For XML encoding:      // Xml data is unformatted, no need to differentiate between instance
     Array<Sint8> _instanceData;      // instances and object paths or objects
     Array<Sint8> _referenceData;      bool setXml(CIMBuffer& in);
     CIMNamespaceName _nameSpaceData;  
     String _hostData;  
  
     // For Binary encoding:      // function used by OperationAggregator to aggregate response data in a
     Array<Uint8> _binaryData;      // single ResponseData object
       void appendResponseData(const CIMResponseData & x);
  
     CIMInstance _cimInstance;      // Function used by CMPI layer to complete the namespace on all data held
       // Input (x) has to have a valid namespace
       void completeNamespace(const SCMOInstance * x);
  
 };      // Function primarily used by CIMOperationRequestDispatcher to complete
       // namespace and hostname on a,an,r and rn operations in the
       // OperationAggregator
       void completeHostNameAndNamespace(
           const String & hn,
           const CIMNamespaceName & ns);
  
       // Encoding responses
  
 //-----------------------------------------------------------------------------      // binary format used with Provider Agents and OP Clients
 //  
 //  CIMInstancesResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMInstancesResponseData  
 {  
 public:  
   
     enum ResponseDataEncoding {  
         RESP_ENC_CIM,  
         RESP_ENC_BINARY,  
         RESP_ENC_XML,  
         RESP_ENC_SCMO  
     };  
   
     CIMInstancesResponseData():  
         _resolveCallback(0),  
         _encoding(RESP_ENC_CIM)  
     {  
     }  
   
     Array<CIMInstance>& getNamedInstances()  
     {  
         _resolve();  
         return _namedInstances;  
     }  
   
     const Array<CIMConstInstance>& getNamedInstances() const  
     {  
         // 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>  
         // for expedience, since the internal representations are the same.  
         return *((Array<CIMConstInstance>*)(void*)&_namedInstances);  
     }  
   
     void setNamedInstances(const Array<CIMInstance>& x)  
     {  
         _resolveCallback = 0;  
         _namedInstances = x;  
     }  
   
     void appendNamedInstance(const CIMInstance& x)  
     {  
         _resolveCallback = 0;  
         _namedInstances.append(x);  
     }  
   
     void setSCMOInstances(const Array<SCMOInstance>& x)  
     {  
         _resolveCallback = _resolveSCMOInstances;  
         fprintf(  
             stderr,  
             "CIMResponseData::setSCMOInstances(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstances = x;  
     }  
   
     void appendSCMOInstance(const SCMOInstance& x)  
     {  
         _resolveCallback = _resolveSCMOInstances;  
         fprintf(  
             stderr,  
             "CIMResponseData::appendSCMOInstance(cb=%p)\n",  
             _resolveCallback);  
         _scmoInstances.append(x);  
     }  
   
     Array<Uint8>& getBinaryCimInstances()  
     {  
         return _binaryData;  
     }  
   
     bool setBinaryCimInstances(CIMBuffer& in, bool hasLen=true);  
     bool setXmlCimInstances(CIMBuffer& in);  
   
     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: private:
  
     CIMInstancesResponseData(const CIMInstancesResponseData&);      // helper functions to transform different formats into one-another
     CIMInstancesResponseData& operator=(      // functions work on the internal data and calling of them should be
         const CIMInstancesResponseData&);      // avoided
   
     static Boolean _resolveXMLInstances(      void _resolveToCIM();
         CIMInstancesResponseData* data,      void _resolveToSCMO();
         Array<CIMInstance>& instances);  
       void _resolveBinary();
     static Boolean _resolveBinaryInstances(  
         CIMInstancesResponseData* data,      void _resolveXmlToSCMO();
         Array<CIMInstance>& instances);      void _resolveXmlToCIM();
   
     static Boolean _resolveSCMOInstances(      void _resolveSCMOToCIM();
         CIMInstancesResponseData* data,      void _resolveCIMToSCMO();
         Array<CIMInstance>& instances);  
       // Helper functions for this class only, do NOT externalize
     Boolean (*_resolveCallback)(      SCMOInstance _getSCMOFromCIMInstance(const CIMInstance& cimInst);
         CIMInstancesResponseData* data,      SCMOInstance _getSCMOFromCIMObject(const CIMObject& cimObj);
         Array<CIMInstance>& cimInstance);      SCMOInstance _getSCMOFromCIMObjectPath(const CIMObjectPath& cimPath);
       SCMOClass* _getSCMOClass(const char* ns,const char* cls);
     void _resolve()  
     {      // Bitflags in this integer will reflect what data representation types
         if (_resolveCallback)      // are currently stored in this CIMResponseData object
         {      Uint32 _encoding;
             (*_resolveCallback)(this, _namedInstances);  
             _resolveCallback = 0;      // Storing type of data in this enumeration
         }      ResponseDataContent _dataType;
     }  
       // unused arrays are represented by ArrayRepBase _empty_rep
     ResponseDataEncoding _encoding;      // 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.
     Array<ArraySint8> _instancesData;  
     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;
  
     Array<CIMInstance> _namedInstances;      // Default C++ encoding
     Array<SCMOInstance> _scmoInstances;      Array<CIMObjectPath> _instanceNames;
 };      Array<CIMInstance> _instances;
       Array<CIMObject> _objects;
   
 //-----------------------------------------------------------------------------  
 //  
 //  CIMObjectsResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 class PEGASUS_COMMON_LINKAGE CIMObjectsResponseData  
 {  
 public:  
   
     CIMObjectsResponseData():  
         _resolveCallback(0),  
         _binaryEncoding(false)  
     {  
     }  
   
     Array<CIMObject>& getCIMObjects()  
     {  
         _resolve();  
         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:  
   
     CIMObjectsResponseData(const CIMObjectsResponseData&);  
     CIMObjectsResponseData& operator=(  
         const CIMObjectsResponseData&);  
   
     static Boolean _resolveXMLObjects(  
         CIMObjectsResponseData* data,  
         Array<CIMObject>& objects);  
   
     static Boolean _resolveBinaryObjects(  
         CIMObjectsResponseData* data,  
         Array<CIMObject>& objects);  
   
     Boolean (*_resolveCallback)(  
         CIMObjectsResponseData* data,  
         Array<CIMObject>& cimObjects);  
   
     void _resolve()  
     {  
         if (_resolveCallback)  
         {  
             (*_resolveCallback)(this, _cimObjects);  
             _resolveCallback = 0;  
         }  
     }  
   
     Boolean _binaryEncoding;  
   
     // For XML encoding.  
     // For XML encoding.  
     Array<ArraySint8> _cimObjectsData;  
     Array<ArraySint8> _referencesData;  
     Array<String> _hostsData;  
     Array<CIMNamespaceName> _nameSpacesData;  
  
     // For binary encoding.      // SCMO encoding
     Array<Uint8> _binaryData;      Array<SCMOInstance> _scmoInstances;
  
     Array<CIMObject> _cimObjects;  
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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