开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
VXI.hpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：12k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

VXI.hpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. #ifndef _VXI_H
  25. #define _VXI_H
  27. #include "VXIvalue.h"
  28. #include "CommonExceptions.hpp"
  29. #include "VXMLDocument.hpp"
  30. #include "InternalMutex.hpp"
  31. #include "TokenList.hpp"
  32. #include "VXItel.h"
  33. #include "ExecutableContentHandler.hpp"
  35. class AnswerInformation;
  36. class DocumentParser;
  37. class ExecutionContext;
  38. class JumpDoc;
  39. class PromptManager;
  40. class PropertyList;
  41. class RecognitionAnswer;
  42. class SimpleLogger;
  43. extern "C" struct VXIcacheInterface;
  44. extern "C" struct VXIinetInterface;
  45. extern "C" struct VXIjsiInterface;
  46. extern "C" struct VXIpromptInterface;
  47. extern "C" struct VXIrecInterface;
  48. extern "C" struct VXItelInterface;
  49. extern "C" struct VXIobjectInterface;
  50. extern "C" struct VXIrecRecognitionResult;
  51. extern "C" struct VXIrecRecordResult;
  52. extern "C" struct VXIrecTransferResult;
  54. class VXI : public ExecutableContentHandler {
  55. public:
  56.   VXI();  // May throw VXIException::OutOfMemory
  57.   ~VXI();
  59.   // Returns: -2 Fatal error
  60.   //          -1 Out of memory
  61.   //           0 Success
  62.   //           1 Infinite loop suspected.
  63.   //           2 Javascript error
  64.   //           3 Invalid startup documents
  65.   //           4 Stopped
  66.   int Run(const VXIchar * initialDocument, const VXIchar * sessionScript,
  67.           SimpleLogger * log, VXIinetInterface * inet,
  68.           VXIcacheInterface * cache, VXIjsiInterface * jsi,
  69.           VXIrecInterface * rec, VXIpromptInterface * prompt,
  70.           VXItelInterface * tel, VXIobjectInterface * object,
  71.           VXIValue ** result);
  73.   // This sets a flag which may be used to abort Run.
  74.   void DeclareStopRequest(bool doStop);
  76.   bool DeclareExternalEvent(const VXIchar * event, const VXIchar * message);
  77.   bool ClearExternalEventQueue(void);
  79.   enum PropertyID {
  80.     BeepURI,             /// URI to beep audio
  81.     PlatDefaultsURI,     /// URI to platform defaults script
  82. DefaultAccessControl /// non-zero to allow access when ?access-control? is missing, otherwise 0 to deny
  83.   };
  85.   // Returns: true  - Property set
  86.   //          false - Invalid parameter value
  87.   bool SetRuntimeProperty(PropertyID, const VXIValue * value);
  89. private:
  90.   // these getters expect the proper ID/type.  i.e. Passing 
  91.   // an ID that returns a string to the int overload will 
  92.   // result in the returned value being untouched.
  93.   void GetRuntimeProperty(PropertyID, vxistring &) const;
  94.   void GetRuntimeProperty(PropertyID, int &) const;
  96.   ////////////////////////////////////////////////////////////////////////////
  97.   // Document level functions
  98.   ////////////////////////////////////////////////////////////////////////////
  100.   int RunDocumentLoop(const vxistring & initialDocument,
  101.                       const vxistring & sessionScript,
  102.                       VXIValue ** result);
  104.   void PerformTransition(const VXMLElement & doc, const vxistring & url,
  105.                          VXIMap * submitData = NULL, bool isSubdialog = false, 
  106.                          bool isSubmitElement = false);
  108.   // Finds the named dialog in the document.  If the name is empty, the first
  109.   // item is returned.
  110.   VXMLElement FindDialog(const VXMLElement & doc, const vxistring & name);
  112.   ////////////////////////////////////////////////////////////////////////////
  113.   // Document level support functions
  114.   ////////////////////////////////////////////////////////////////////////////
  116.   // This is responsible for adding a next execution context for the initial
  117.   // document and for <subdialog> elements.  It also initializes the session
  118.   // and language-neutral platform defaults.
  119.   //
  120.   // Returns: true - success
  121.   //          false - failure (stack depth exceeded?)
  122.   bool PushExecutionContext(const vxistring & sessionScript);
  124.   // This undoes PushExecutionContext()
  125.   void PopExecutionContext();
  127.   void InstallDocument(JumpDoc &);
  129.   void ProcessRootScripts(VXMLElement & doc);
  131.   void AttemptDocumentLoad(const vxistring & rawURL,
  132.    const VXIMapHolder & urlProperties,
  133.    VXMLDocument & doc,
  134.    VXIMapHolder & docProperties,
  135.    bool isDefaults = false,
  136.    bool isRootApp = false);
  138.   // Recursively walks the document tree and assigns internal names as needed.
  139.   void PrepareDocumentTree(VXMLElement & doc);
  141. private:
  142.   ////////////////////////////////////////////////////////////////////////////
  143.   // Dialog level functions
  144.   ////////////////////////////////////////////////////////////////////////////
  145.   void RunInnerLoop();
  147.   // Either throws an event containing the next form item to execute or
  148.   // simply returns if none is found.
  149.   void DoInnerJump(const VXMLElement & elem, const vxistring & item);
  151.   ////////////////////////////////////////////////////////////////////////////
  152.   // Dialog level support functions
  153.   ////////////////////////////////////////////////////////////////////////////
  155.   // Perform initialization associated with property tags and form level
  156.   // variables.  Reset the event and prompts counts.
  157.   void FormInit(const VXMLElement & form, VXIMapHolder & params);
  159.   // Returns true iff this element is a 'form item'.
  160.   bool IsFormItemNode(const VXMLElement& doc);
  162.   // Returns true iff this element is an 'input item'.
  163.   bool IsInputItemNode(const VXMLElement& doc);
  164.  
  165. private:
  166.   ////////////////////////////////////////////////////////////////////////////
  167.   // Collect Phase and element related.
  168.   ////////////////////////////////////////////////////////////////////////////
  170.   void CollectPhase(const VXMLElement& form, const VXMLElement& item);
  172.   void ProcessReturn(const VXMLElement& form, const VXMLElement& item,
  173.                      VXIMapHolder & result);
  175.   void DoEvent(const VXMLElement & item,
  176.                const VXIException::InterpreterEvent & event);
  178.   // Returns: true - event handled successfully.
  179.   //          false - no handler available.
  180.   bool do_event(const VXMLElement & item,
  181.                 const VXIException::InterpreterEvent & event);
  183.   void DoRecognition(const VXMLElement & item,
  184.                  const vxistring & documentID,
  185.                      const vxistring & dialogName,
  186.                      const vxistring & fieldName,
  187.                      const PropertyList & properties,
  188.                      int timeout,
  189.                      bool isModal);
  190.   void do_recognition(VXIMapHolder &properties, const PropertyList & propertyList);
  192.   void ProcessRecognitionResult(VXIrecRecognitionResult *recResult, const PropertyList & propertyList);
  193.   void ProcessRecognitionResult(VXIrecRecordResult *recResult, const PropertyList & propertyList);
  194.   void ProcessRecognitionResult(VXIrecTransferResult *recResult, const PropertyList & propertyList);
  195.   void ProcessRecognitionResult(VXIContent * result, VXIContent * utterance, VXIunsigned utteranceDuration, 
  196.       VXIString *markname, VXIunsigned marktime,
  197.       const PropertyList & propertyList);
  199.   void HandleRemoteMatch(const VXMLElement & dialog,
  200.                          const VXMLElement & element);
  202.   void SetMarkVars(VXIString *markname, VXIunsigned marktime);
  203.   void SetFieldRecordUtterance(const VXMLElement & answerElement);
  204.   void SetFieldRecordUtterance(vxistring & fieldName);
  206.   void SetFieldMark(const VXMLElement & answerElement);
  207.   void SetFieldMark(vxistring & fieldName);
  209.   void ProcessFilledElements(const vxistring & filled,
  210.                              const VXMLElement & element);
  212.   void ProcessFilledElements(TokenList & filled,
  213.                              const VXMLElement & element);
  215. private:
  216.   void execute_content(const VXMLElement & doc,
  217.                        const VXIMapHolder & vars = VXIMapHolder(NULL),
  218.                        const VXMLElement & activeDialog = 0);
  219.   void executable_prompt(const VXMLElement& child);
  221. // executable content handler
  222. private:
  223.   void executable_element(const VXMLElement& child, const VXMLElement & activeDialog = 0);
  225.   void assign_element(const VXMLElement& elem);
  226.   void clear_element(const VXMLElement& elem);
  227.   void data_element(const VXMLElement & elem);
  228.   void disconnect_element(const VXMLElement& elem);
  229.   void goto_element(const VXMLElement& elem);
  230.   void exit_element(const VXMLElement& elem);
  231.   void if_element(const VXMLElement& elem);
  232.   void log_element(const VXMLElement& elem);
  233.   void reprompt_element(const VXMLElement& doc, const VXMLElement & activeDialog = 0);
  234.   void return_element(const VXMLElement& elem);
  235.   void script_element(const VXMLElement& elem);
  236.   void submit_element(const VXMLElement& elem);
  237.   void throw_element(const VXMLElement& doc, const VXMLElement& activeDialog = 0);
  238.   void var_element(const VXMLElement & elem);
  240. private:
  241.   // form item handlers
  242.   void block_element(const VXMLElement& doc);
  243.   void field_element(const VXMLElement& form, const VXMLElement& field);
  244.   void menu_element(const VXMLElement& doc);
  245.   void object_element(const VXMLElement& doc);
  246.   void record_element(const VXMLElement& form, const VXMLElement& doc);
  247.   void subdialog_element(const VXMLElement& doc);
  248.   void transfer_element(const VXMLElement & form, const VXMLElement& doc);
  250.   // misc handlers
  251.   void meta_element(const VXMLElement & doc);
  253.   // helpers
  254.   VXIMap * CollectParams(const VXMLElement & doc, bool isObject);
  255.   void CheckLineStatus(void);
  256.   void ThrowTransferEvent(VXItelResult telResult, const vxistring &type);
  258. private: // All prompt related.
  259.   void queue_prompts(const VXMLElement& doc);
  261. private:
  262.   DocumentParser     * parser;  // owned
  263.   SimpleLogger       * log;
  264.   VXIcacheInterface  * cache;
  265.   VXIinetInterface   * inet;
  266.   VXIrecInterface    * rec;
  267.   VXIjsiInterface    * jsi;
  268.   VXItelInterface    * tel;
  269.   VXIobjectInterface * object;
  270.   PromptManager      * pm;      // owned
  272.   VXIMap             * sdParams;
  273.   VXIMap             * sdResult;
  274.   VXIException::InterpreterEvent * sdEvent;
  276.   bool updateDefaultDoc;
  277.   VXMLDocument domDefaultDoc;
  279.   // Used by Get/Set Property
  280.   InternalMutex mutex;
  281.   vxistring uriPlatDefaults;
  282.   vxistring uriBeep;
  283.   bool      defAccessControl;  // for <data> missing ?access-control?
  285.   // Keep track of current URI
  286.   vxistring uriCurrent;
  288.   int stackDepth;
  289.   ExecutionContext * exe;
  291.   // Event related
  292.   bool lineHungUp;              // Tel. status to track hang-up event
  293.   bool stopRequested;           // Should the interpreter stop ASAP?
  294.   bool haveExternalEvents;      // Are there unprocessed external events?
  295.   TokenList externalEvents;     // Unprocessed external events
  296.   TokenList externalMessages;   // Unprocessed external events (messages)
  297. };
  299. #endif