mi32/soapserver.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file mi32/soapserver.h
 * \brief SOAP - Simple Object Access Protocol - Server-Side stuff
 *
 * \if NODOC
 * $Log: soapserver.h_v $
 * Revision 1.3  2004/10/20 15:59:30  dwilliss
 * WSDL mostly implemented now
 * Made destructors virtual
 *
 * Revision 1.2  2004/10/20 14:54:00  dwilliss
 * Started adding WSDL support
 *
 * Revision 1.1  2004/01/08 16:39:54  dwilliss
 * Initial revision
 *
 * \endif
 *
 *****************************************************************************/

#ifndef INC_MI32_SOAPSERVER_H
#define INC_MI32_SOAPSERVER_H


#ifndef INC_MI32_SOAP_H
#include <mi32/soap.h>
#endif

#ifndef INC_MI32_HTTPSERVER_H
#include <mi32/httpserver.h>
#endif

namespace SOAP {

class OBJECT_DEFINITION;
class SERVER;
class METHOD;


class OBJECT_DEFINITION {
   public:

      OBJECT_DEFINITION (
         const char* name     
         );

      virtual ~OBJECT_DEFINITION (
         );

      HTTPCLIENT::INSTANCEDATA* AllocateInstance (
         HTTPSERVER::CLIENT* client
         );

      METHOD* FindMethod (
         const char* name
         ) const;

      const char* GetName (
         ) const;

      const XMLDOC& GetWSDL (
         ) const;

   private:

      // Method to allocate a server-side instance of the object.
      // If the object is interface-only, you do not need to override this.
      virtual HTTPCLIENT::INSTANCEDATA* v_AllocateInstance (
         HTTPSERVER::CLIENT* client
         );

      friend class METHOD;  // only METHOD's ctor can call AddMethod

      void AddMethod (
         METHOD* method
         );

      const char* m_name;
      SIMPLE_ARRAY<SOAP::METHOD*> m_Methods;
      mutable XMLDOC* m_wsdl;
      
   };

class METHOD {
   public:

      // Types for parameters and return values
      enum TYPE {
         TYPE_String,
         TYPE_Double,
         TYPE_Integer,
         TYPE_XML       
         };

      virtual ~METHOD (
         );

      const char* GetName (
         ) const;

      ERRVALUE ProcessRequest (
         HTTPCLIENT::INSTANCEDATA* This,  
         const VALUES& parms,       
         VALUES& retval             
         );

   protected:

      METHOD (
         OBJECT_DEFINITION* obj, 
         const char* name     
         );

      ERRVALUE AddParameter (
         const char* name,    
         VALUES::TYPE type,
         bool bIsOptional
         );

      ERRVALUE AddRetVal (
         const char* name,    
         VALUES::TYPE type,
         bool bIsOptional
         );

   private:
      struct PARM {
         const char* m_name;
         VALUES::TYPE m_type;
         bool m_bIsOptional;

         void AddWSDLNode(XMLNODE* parent) const;
         };

      const char* m_name;
      SIMPLE_ARRAY<PARM> m_Parms;
      SIMPLE_ARRAY<PARM> m_OutReply;

      virtual ERRVALUE v_ProcessRequest (
         HTTPCLIENT::INSTANCEDATA* This,  
         const VALUES& parms,       
         VALUES& retval             
         ) = 0;

      void CreateWSDLMessageNodes (
         XMLNODE* definitionsNode
         ) const;

      void CreateWSDLPortTypeOperationNode (
         XMLNODE* portTypeNode
         ) const;

      void CreateWSDLBindingOperationNode (
         const char* ObjectName,
         XMLNODE* bindingNode
         ) const;

      friend class OBJECT_DEFINITION;
   };


template <class _CT> class METHOD_T : public METHOD {
   public:
      METHOD_T (
         OBJECT_DEFINITION* obj, 
         const char* name     
         ) :
         METHOD(obj, name)
         {
         }

   private:
      virtual ERRVALUE v_ProcessRequest (
         _CT* This,  
         const VALUES& parms,       
         VALUES& retval             
         ) = 0;

#ifndef GENERATING_DOXYGEN_OUTPUT
      ERRVALUE v_ProcessRequest (
         HTTPCLIENT::INSTANCEDATA* This,  
         const VALUES& parms,       
         VALUES& retval             
         ) {
         return (v_ProcessRequest(static_cast<_CT*>(This), parms, retval));
         }
#endif
   };



class HANDLER : public HTTPSERVER::HANDLER {
   public:
      HANDLER (
         HTTPSERVER& server
         );

      virtual ~HANDLER (
         );

      ERRVALUE AddObjectDefinition (
         OBJECT_DEFINITION* obj
         );

   private:
      virtual bool v_CanHandleMethod (
         HTTPMESSAGE::METHOD method
         ) const;

      virtual int v_Matches (
         const HTTPMESSAGE& message
         ) const;

      virtual bool v_ProcessRequest (
         HTTPSERVER::CLIENT* client,
         const HTTPMESSAGE& message
         );

      OBJECT_DEFINITION* FindObjectDef (
         const HTTPMESSAGE& message
         ) const;

   private:
      SIMPLE_ARRAY<OBJECT_DEFINITION*> m_ObjectTypes;
   };

} // End of SOAP namespace

#endif // INC_MI32_SOAPSERVER_H

---