CN1719784A - 多模式对话处理方法 - Google Patents

Abstract

本发明涉及了一种提供设备上的多模式对话的方法，其包含了以下步骤：提供多模式对话的描述；探测设备的模态能力以识别可用的模态；在可用模态和多模式对话之间建立模态绑定；根据模态绑定和多模式对话的描述交互地处理多模式对话的对话部分；还动态地建立和维护对话语境，该对话语境反映了来自应用或使用语境的所用话语和约束条件以及可用模态；并且根据对话语境动态地调整在可用模态和多模式对话的描述之间的模态绑定。本发明还涉及了一种相应设备、一种对话生成系统和一种计算机软件产品。

Description

多模式对话处理方法

技术领域

本发明涉及了提供设备上的多模式对话的方法。本发明也涉及了相应设备、对话生成系统和计算机软件产品。

本发明基于优先权申请EP04291715.3，该申请在此引入作为参考。

背景技术

使用浏览器浏览在如HTML(超文本标记语言)的标记语言中描述的Web浏览内容是目前普遍应用的技术。HTML是用于显示内容的标记语言。HTML有一种称为“表单”的机制，并且能够包含GUI(图形用户界面)部分，如按钮、文本框等等。利用这种语言、CGI(通用网关接口)、Java小服务程序或Web服务器的类似机制，不仅可浏览内容，而且能够在Web服务器和客户端之间交互地交换信息。Web服务器能够基于此信息执行任意的程序(应用)，而且该服务器能够以HTML格式将结果发送回客户端。在此意义上，浏览器提供了交互的用户界面。

这种机制不仅能够应用于Web浏览，而且能够应用于任何设备控制。更明确地，将要被控制的设备安装了类似Web服务器的装置，并且响应于来自作为客户端的控制设备的请求将类似HTML的文件发送到该控制设备，该类似HTML的文件包含了由用于控制其自身的GUI部分组成的表单。该控制设备在浏览器上显示此类似HTML的文件，而用户在该控制设备上操作GUI。该控制设备将用户的输入发送到将要被控制的设备(如Web服务器)。在将要被控制的设备中，CGI或Java小应用程序机制等将此输入传送到控制程序以获得相应于该输入的控制。

另一方面，近年来，信息设备的形式已经多样化，其可以是便携式终端，例如PDA(个人数字助理)、移动电话、汽车导航系统等等，并且与PC(个人计算机)不同，上述设备能够建立与因特网的连接。因此，诸如WML(站点元语言(website meta language))等的代替了HTML的标记语言已被开发并标准化。另外，随着语音识别/合成技术和计算机电话集成技术的发展，能够通过电话的语音输入实现对Web的访问，并因此如VoiceXML等的标记语言已被开发并标准化。如此，与设备形式相匹配的标记语言已被开发并标准化。

除了设备形式的多样化之外，UI(用户界面)模态也已多样化(如，用于PC和PDA的GUI、用于电话的语音和DTMF(双音多频)等等)。多模式用户界面通过有效地结合多样化的模态改进了可操作性。多模式用户界面的描述需要至少一个对话描述(该对话描述指出了用户输入与输出之间的一致性，以及这样的输入和输出的序列)，以及一个模态描述(该模态描述指出了UI部分以获得这样的输入/输出)。在W3C(万维网联盟)有关于多模式交互框架的活动，例如参见：http：//www.w3.org/TR/mmi-framework/standardizing a multimodal environment for the Internet。

模态描述很大程度上取决于客户端的形式。诸如PC等的通用设备，具有很多GUI，而由于语音识别/合成技术的发展，一些新近的设备包括了语音UI。另一方面，移动电话最适合使用语音。这是因为移动电话在小液晶屏幕上支持简单的GUI部分，但是由于没有可用的指示设备，这样的GUI部分不容易使用。考虑到设备控制，使用遥控器作为控制设备。通常使用物理按钮操作该遥控器。

对话描述可以清晰地指定对模态输入/输出形式的描述(如，给定的输入使用GUI按钮，而给定的输出使用语音)。

另一方面，对话和模态描述可以分开，并且以独立于模态的形式给出对话描述。对话描述作为将要被控制的给定设备的操作序列被以独立于模态的形式给出，并且依照与该对话描述无关的各个客户端给定模态描述，从而允许各客户端操作一个将要被控制的设备。

类似XML标记语言的表示可以以独立于模态的形式给出对话描述本身，并且该表示没有用于给出模态描述及其控制描述的模式。对话描述部分被转换为现有的标记语言，如HTML、WML、VoiceXML等等，以生成(可理解的)模态描述。或者通过由增强的浏览器直接执行XML标记语言，指定在其上运行浏览器的设备的模态，该模态是为浏览器所知的，而且由浏览器确定所述模态与对话描述中的输入/输出元素之间的对应关系。这意味着浏览器被视为用于处理任何种类的多模式对话的一般的多模式UI。

在未来的无PC时代，可期望每种设备具有CPU和通信功能并通过网络彼此连接，以提高用户的便利。对于这样的设备操作环境的实现，使用基于标记语言的Web机制是有效的。此外，对于独立于设备类型和位置的设备操作环境的实现，使用允许独立于模态的描述的标记语言是有效的。

如上所述，现有的标记语言是假定了某些控制设备形式的独立于模态的语言。出于此原因，将被控制的设备必须为符合假定的控制设备的多种标记语言作准备，以便允许来自各种设备的控制。诸如HTML、WML、VoiceXML的专门的表示语言不适合实现多模式用户界面，因为它们没有假定作为多个模态的组合的操作。

由美国专利申请公开2003/0158898 A1公开了一种独立于模态的标记语言，该标记语言适合通过依赖于设备的能力将其转换为现有的标记语言如HTML、WML、VoiceXML等等而实现多模式用户界面。

通过通信模块接收与控制设备的模态相关联的模态信息。另外，通过通信模块接收与将要被控制的设备的对话相关联的对话信息。绑定层推断模块生成了推断模态信息和对话信息之间的关系的绑定信息，并绑定了模态信息和对话信息。通过通信模块将该绑定信息和对话信息传送到控制设备。

一个剩下的问题是包括使用行为和使用语境，以便提高通信效率从而提高用户界面的人机工程学方面，也就是相对于对话语境的可应用模态的动态适应。

对话被认为是至少两方之间的会话，其试图产生双方间合意的共同理解。

在这种语境下，话语被看成是对发出的模态的使用，特别是用于(听觉的)通信的声音，如频繁发出的意见。

建立这样的多模式对话尤其是一个问题，该多模式对话可以利用组成的多模式对话元素的基于语境的产生和对话规则，来提供语音对话和图形对话的集成和同步。

通过在人机会话界面内的自适应的对话形式和模态将可以得到改良的通信。

此问题可以通过在设备上处理多模式对话的方法来进行解决，该方法包含下列步骤：提供多模式对话的描述；探测设备的模态能力以识别可用的模态；在可用模态和多模式对话的描述之间建立模态绑定；并且根据该模态绑定和多模式对话的描述交互地处理多模式对话的对话步骤；以及即时产生并动态维护对话语境，该对话语境反映了来自情景应用或使用语境的所话语和约束条件以及可用模态；并且根据对话语境动态地调整在可用模态和多模式对话的描述之间的模态绑定。

尤其通过带有对话界面的设备、对话生成系统和计算机软件产品来解决该问题。

换句话说，在对话内的可用模态基于用户的话语被翻译为语境敏感的。用于多模式的系统可能包含对话生成部分，以组建、更新和使用由用户和系统完成的话语内容的主要元素的表示；以计划作为对用户话语的回复的系统反应；并且以记住来自情景语境(所用设备的能力、用户偏爱等)的约束条件，因为这些约束条件由语境管理器提供，以便决定关于系统输出的可能模态。

对话生成系统可能包含信息状态(IS)，该信息状态是任务的当前状态以及对话的状态的表示，该对话包含了关于开放的通信契约(如开放的是/否问题)的信息和关于系统提供给用户进行处理的选项的信息。该系统还可能包含输入集成(II)部分，该部分接收作为输入的用户话语的内容的表示，并通过更新操作将这些表示与信息状态集成。动作计划器(AP)可能工作于更新的IS表示。它包含用于可能的对话步骤序列的规则(“对话语法”)，并且它基于给定的IS决定执行哪一个动作，即对话步骤。

可区分两种对话步骤规则：通用对话步骤规则定义了独立于应用的行为，应用对话步骤规则定义了依赖于应用的行为。

由于AP需要提供特定应用的数据，该AP与应用数据库交互。AP更新IS并以将适当的图形交互元素与话音对话元素相结合的多模式对话元素的形式产生系统反应的抽象表示。

输出管理器(OM)从AP接收输入。为决定将要产生的系统话语所使用的模态，OM记住特征编码语境约束条件。它产生系统话语的抽象的XML编码表示，例如结合的多模式对话元素。它将已由其完成的关于多模式对话元素打包的决定传送回IS模块。随后关于翻译的细节指定OM的输出。

翻译器将OM的输出翻译为为实际的表示格式。它确定屏幕上的层、“视觉与感觉”等等。然而，关于系统话语的选定模态以及关于将发出的信息的数量(“信息打包”)对其进行指定。根据作为前端的设备和浏览器的需要，各种不同的翻译被插入系统。

发明内容

因此，本发明的目的和优势是提供一种包含了对话生成部分的多模式对话生成系统，该对话生成部分执行了如下步骤：

-建立所用话语的内容的表示

-计划系统反应

-从情景语境得到约束条件

-维护内容的表示

-选择对话的模态

以提供灵活的多模式对话生成系统，例如用于移动设备的基于语境的对话服务。

本发明的另一个优势是改良的人机工程学的自然用户界面，其允许更好的机器交互。它将减少误解并支持最佳的应用交互。此外，避免了将模态方面集成到应用和使用语境中的任务。

本发明的进一步优势是提供了适合当前(变化的)应用环境的基于语境的对话模态。

而本发明的另一个优势是可适用于对手提式和移动市场有吸引力的特征，因为该方法是完全独立于设备的，并且该解决方案提供和推进了功能性和模态的独立性以及应用的独立性。

附图说明

对于本领域普通技术人员，通过参考部分1.a到g和图1以及随后的描述，能够很容易地理解本发明的这些目的和优势以及许多其他的目的和优势。

具体实施方式

本领域的一般技术人员将认识到本发明的以下描述仅仅是说明性的，并不试图以任何方式进行限制。也将从其中公开的检验中容易地将本发明的其他实施例建议给这些技术人员。

通过用于灵活的多模式对话系统的对话管理的示例性原型(体系结构)，以及利用用于类似新闻信息服务的示例性应用域的基于Java的实现，试图用所述的系统详细说明本发明。试图用体系结构下的概念同样支持其他应用。

对话管理器设计的主要目的之一是一般性和灵活性。重点在于模块设计和在表示级别上清晰定义的提取层次。

在一些情况下，此导向似乎会导致使用比一个应用所必须的更多的(或更庞大的)表示。可以期待本发明仍然支持额外的灵活性。

附录示出了用于实现依据本发明的方法的说明性的Java编码。它给出了该说明性的编码的继承和扩展树的概观。

图1概述了对话的框架。给出了系统体系结构及其组件清单的非正式草图，以及系统的主要任务的检索。也非正式地给出了通过系统的信息流。描述了对话管理器(DM)中使用的表示；焦点在IS上，因为这些对于DM部分是主要的。另外，描述了域数据和对话管理器模块的用户话语的表示。

对话系统的体系结构的草图：示例性的对话系统包含对话管理部分。该部分有如下任务，以建立、更新和使用由用户和系统完成的话语内容的主要元素的表示，并计划作为对用户话语的回复的系统反应。此外，它还须记住来自情景语境(所用设备的能力、用户偏好等等)的约束条件，因为这些约束条件是由(仿真的)语境管理器提供的，以便决定关于系统输出的可能模态。

对话管理器(部分1.d)，其本身使得以下几个模块协同工作：信息状态(IS)(部分1.c.c)、输入集成部分(II)(部分1.b.c)、动作计划器(AP)(部分1.c.d)、输出管理器(OM)(部分1.b.a)和翻译器。

信息状态是任务当前状态以及对话状态的表示，该对话包含了关于开放的通信契约的信息(如开放的是/否问题)和关于系统提供给用户进行处理的选项的信息。

通过更新操作接收作为输入的用户话语内容的表示并将它们与信息状态集成。

动作计划器作用于更新的IS表示。它包含了规则相关部分(部分1.a和1.b)，用于对话步骤(对话语法)的可能序列，并且该动作计划器在给定IS的基础上决定执行哪一个动作(即对话步骤)。区分两种对话步骤规则：通用对话步骤规则定义了独立于应用的行为，应用对话步骤规则定义了依赖于应用的行为。

由于AP需要提供特定应用的数据，它与应用数据库交互。AP更新IS并产生系统反应的抽象表示，这些抽象表示尚未被关于模态指定，在该模态中它们能够/应该被表示。

输出管理器(OM)接收来自AP的输入。为决定将要产生的系统话语所使用的模态，其记住特征编码语境的约束条件。它产生系统话语的抽象XML编码表示。它将其已完成的关于模态选择和信息打包的决定传送回IS模块。随后关于翻译的细节指定OM的输出。

翻译器将OM的输出翻译为实际的表示格式。它确定屏幕上的层、视觉与感觉等等。然而，关于系统话语的选定模态以及关于将发出的信息的数量(“信息打包”)对其进行指定。

根据设备和浏览器(用作前端)的要求，各种不同的翻译器可能被插入系统。

OM的输出以XML编码。它被给出到翻译器，该翻译器作为系统的单独部分，负责产生系统的可显示输出。翻译器接收该抽象XML数据并产生如HTML的，能够用于产生VoiceXML或其他表示的可选的其它翻译。翻译器将其输出供给用户设备；它提供了关于显示层、视觉和感觉等的灵活性。

系统中的信息流的草图：当对话发生时，能够观察到下列处理步骤：

语法：用户输入由诸如浏览器的前端进行处理。它采用了例如以XHTML(扩展HTML)文档作为参考的L&H语法。可能以这样的关于输出字符串的方式准备该语法，该输出字符串能够作为属性/值对被II模块分析。优选地具有标准L&H语法输出(以识别的输入的字符串的形式)。可以添加变换部分，用于将语法输出重定格式为所需的属性/值对的记法。此方法可以为模块化作出贡献；首先，因为任何其它语法工具无需改变就能够作为浏览器的部分使用；其次，因为在任何情况下应当利用来自域和任务模型的分类来充实语法输出。或者，优选地用词典部分代替整体系统的语法模块，该词典部分能够获得字符串输入并利用任务/域分类来充实这些字符串输入，并且其是与在浏览器中使用的实际语法和词典分开的。

有效性检验：可以对由语法产生的属性/值对进行有效性检验。由于ASR(自动语音识别)错误，识别器结果可能无法在系统内使用。如果用户话语是无效的，直接向输出管理器给出消息，以指示其发出邀请用户重复(或使用另一个输入模态)的系统话语。执行有效性检验的次数可以在简单的历史清单中计数。在语音输入/输出模态中，如果对话语境允许这样(将要在II模块中检验)，并且如果有其他输入模态可用(供予GM模块的信息)，可以发出使用另一个模态的邀请，而取代对用户再次连续重复其话语的请求。

如果发生无效的用户输入(不可被分析的)，则绕过II和AP部分。不过，由于OM返回给IS模块，关于需要重复(或一种“元对话”)的信息被保留在历史记录中。这可以避免用户输入的无限循环、识别错误、重复请求、用户输入等等。

输入集成：将包含在用户话语中的有效属性/值对集成在系统信息状态的表示中。利用规则执行该集成。所有的信息状态(或至少最后n个)保留在简单的历史清单中。这允许用户可以在任何时候回到用系统执行的对话步骤的历史中的前一个步骤。

动作计划：将用户话语集成在当前信息状态中的结果是特征结构(具有某些由用户输入所填入的属性)。动作计划器使用该特征结构以执行下列任务：

(a)匹配与对话步骤的通用规则相对照的信息状态表示(可能的对话步骤的语法)，并因此决定系统下面将要执行的步骤；

(b)如果必要，调用应用(数据收集)并在应用数据上执行操作。

(c)根据将被执行的对话行为的类型、涉及该对话行为的主题、当前任务状态、用于系统输出的新的选项等等，提供下一系统话语的一般表示。

输出管理：AP输出是特征结构，可能具有附带的动作；它是输出管理器的输入。从对话行为的类型和主题以及输出选项，OM产生了一组可能的系统话语。在这样做时，它记住了由语境管理器提供的约束条件。这些约束条件可能是特征。示例有：“无语音”；“使用大字体：用户是近视”；“窗口尺寸是：……”；等等。

结果，从理论上可能的输出模态中选择一个，并且从生成词典中选择系统话语(包括来自应用的预录文本加数据)以及显示形式(如，短的或长的新闻文本)。OM还提供了到涉及生成的系统话语的语音识别语法的链接。系统话语和链接以XML编码并移交到翻译器。特别地，它包含了诸如应用内容、系统话语文本、模态选择特征或语音识别语法的信息。OM提供了返回IS模块的信息状态的更新。

翻译：翻译器记住关于用户设备给定屏幕的层的细节的约束条件，以及关于服务提供者的视觉和感觉的偏好的约束条件。翻译器将引入的XML转换为能够被用户浏览器解释的格式。为了与浏览器通信，翻译器产生了如XHTML页面、ASR语法和手写词清单。

浏览器：它接收XHTML，并确保各话语由TTS合成并且/或者在屏幕上产生各自的显示。此外，它处理给定的ASR语法以处理语音输入。

信息状态是对话管理器的主要表示，因为它是唯一到AP的输入并且它由模块II、AP和OM操作。

信息状态被表示为特征结构(部分1.c)，其包含了下列类型的信息：任务状态的描述、由用户请求并由系统执行的动作的描述；符合任务模型中所描述动作的动作、系统在对话中建议给用户作为下一步骤的选择的描述；如果必要，也能够明确地表示实际的系统话语，但是由于它在给定的IS的随后更新(以任务结构的更新的形式)中被记住，这可能是冗余的，以及处理是/否问题(如：“应该消除书签吗？”)的特征描述。

任务状态描述(部分1.c.a.a)，其包含了属性，这些属性本身是从域模型接收的专门化层次(部分1.c.a)的元素(以渐增的专门化为顺序在这里列出，最通用的在最上面)：任务类型(如种类关键词)、任务名称(如，种类：政治、经济、体育……)、新闻项：该值是新闻项的标识符，从而是指向域模型的指针、以及新闻部分：该值是“标题、短文本、长文本、图片(图库)、视频”中的一个。

利用在用户话语中识别的值更新任务状态描述。由于特征是根据上述专门化层次组织的，在给定层次级别上的更新导致在所有更低级别上的变化。例如，如果用户提供了关于其希望看到的新的新闻项的信息，“新闻部分”(一个更低级别)的栏(slot)被设置回“未定义”，即便该栏以前被填入“视频”(但是“视频收看”仅仅适用于之前的新闻项)。因此，在由用户操作的任务模型中的快捷方式能够以简单的方式实现。假设用户已经通过关键词看过了经济新闻并然后说“政治里有什么？”。这意味着他/她想返回填入了“任务类型”和“任务名称”的栏的智能种类选择。所有其他栏的值保持为未定义。

通过II模块中的更新规则利用用户输入完成对IS的更新。这些规则使用了得自用户话语的属性/值对。

用户话语表示：通过导出一个或几个词，用于ASR的语法典型地对话语进行分析。

或者在语法内，或者在单独的映射模块中，将识别器的输出映射到用在域和任务模型中的属性/值对上。例如，可以是用于指示动作(“选择”、“显示”、“展示”等等)的词，以指示任务类型、任务名称、新闻项、关键词、新闻部分等等。用户话语的表示使用了与任务状态描述所使用的相同的栏。

域数据的表示：由于NewsML很可能比对话系统的目的所需的格式更复杂，可以使用另一种标准，RSS(丰富联合标准(Rich SyndicationStandard)；RDF站点摘要)。

在XML的示例中完成新闻项的RSS编码。这个XML编码的数据由动作计划器使用并被传递给输出管理器。

动作计划器的输出：以上描述了AP输出的内容。由于AP获得了作为输入的IS表示(特征结构)，它的输出仍然可以(部分地)表示为特征结构。不过这些特征结构可以包含指向动作的指针。

注意，AP输出优选地不包含任何系统话语的文本。它仅仅包含指向对话行为类型和主题的特征和值。输出管理器仅在其配置上具有系统话语模板的词典。取决于选定的输出模态和用户偏好，这可以允许选择较短的或较长的系统话语。

输出管理器的输出：OM产生XML编码的数据。如果OM输入被限制在抽象级别，则与之相反，OM输出将被完全指定为关于将被说出或显示的内容。不过，仍然没有采取关于消息的布置的决定。出于简单性原因固定了进入系统话语的资料的数量。

用户可以在对话中的任意点执行以下动作之一，这些动作用来使系统处理更容易：

-URL： http：//domain.name/directory/subdirectory/page.htm

-转到所执行的对话步骤的历史记录中的上一个步骤；

-要求系统再次说出它最后所说的(例如，如果噪声干扰，或者如果出于某种原因需要刷新屏幕输出)。

-从能够离开系统的地方转到主条目菜单。这些动作允许用户灵活地掌控系统。

通过域和任务模型的快捷方式能够在对话的大多数点转换到另一个动作或另一个任务类型。如上所述，

-改变动作(显示可用的选择选项、书签，删除书签；可能通过e-mail发送便条给某人)将不会改变任务状态；

-在任务状态中改变栏也将改变所有层次低于此栏的栏值。

这两个设备共同允许在任务模型内的导航中的灵活性。

在OM中完成输出模态的选择。它记住语境管理器的约束条件。由于系统话语的内容和将用于发出该系统话语的模态彼此保持分开，OM结合了这两类信息。

这允许取决于内容制定关于适当的(不适当的)模态使用的约束条件(例如，“不使用TTS告知用户的银行帐户余额，除非你在纯语音的模式下”)；次于这些通用规则，它也允许一组特定的约束条件，例如为了用户偏好，例如给定用户是近视，并且需要为其显示大字体；用户不想听到任何TTS(文本到语音)；等等。

尽管这里显示和描述了本发明的说明性的优选实施例和应用，但是许多保持了本发明的概念、范围和精神的改变和修改是可能的，并且在细读本申请后，这些修改对于本领域技术人员来说是十分清楚的。

例如，本发明提供了多模式自适应对话系统的面向对象体系结构，该系统使用了在Java内实现的特征结构并通过再用公有编程结构特别提供了统一应用接口，以便收集自适应和反应的行为的语境信息。备选技术和实现(语言)是十分明显的。

此实现特别具有再用结构的优点，如规则(部分1.a)用于界面规则(部分1.a.a)或应用规则(部分1.a.b)。类似地，将规则容器(部分1.b)再用于输出处理器(部分1.b.a)、应用计划器(部分1.b.b)和输入处理器(部分1.b.c)。

附录：示例应用的类树

部分1.a Rule

  部分1.a.a interfaceOMRule

  部分1.a.b ApplicationRule

  部分1.a.c InputRule

部分1.b RuleContainer

  部分1.b.a OutputProcessor

  部分1.b.b ApplicationPlanner

  部分1.b.c InputProcessor

部分1.c FeatureStructure

  部分1.c.a HierachicFeatureStructure

    部分1.c.a.a TaskState

  部分1.c.b ApplicationInformation

  部分1.c.c InformationState

  部分1.c.d SystemDialogAct

部分1.d DialogManager

部分1.e OutputManagerRules

部分1.f NewsApplication

部分1.g demo

　　import java.util.*；

　　public interface Rule

　　{

　　    /**

　　    *确定此Rule是否匹配给定的FeatureStructure。

　　    *如果此Rule匹配，则意味着

　　    *此Rule能够应用于给定的FeatureStructure。

　　    *在应用此Rule前应该总是调用此Rule。

　　    *

　　    *@param aFS将被检查的FeatureStructure。

　　    *@return  ＜code＞true＜/code＞如果此Rule能够应用于给定的FeatureStructure，或

　　    *         ＜code＞false＜/code＞如果此Rule不能应用于给定的FeatureStructure。

　　    */

　　    public boolean isApplicableTo(FeatureStructure aFS)；
        <!-- SIPO <DP n="14"> -->
        <dp n="d14"/>
　　} 

　　                                                               部分1.a

　　public interface OMRule extends Rule

　　{

　　   public Object process(SystemDialogueAct aDA，InformationState anIS)；

　　}

　　                                                               部分1.a.a
        <!-- SIPO <DP n="15"> -->
        <dp n="d15"/>
　　public interface ApplicationRule extends Rule

　　{

　　    //////////////////////////////////////////////////

　　    //处理方法

　　    //////////////////////////////////////////////////

　　    /**

　　    *对给定的ApplicationInformation应用此ApplicationRule。

　　    *它更新了InformationState的给定部分

　　    *并生成对话行为表示，

　　    *该对话行为表示是关于该任务的对话的当前状态的响应

　　    *

　　    *不论该Rule是否适用，

　　    *仅应该在测试之后调用它。

　　    *

　　    *此Rule修改了给定的参数。

　　    *

　　    *@param anApplicationInformation应用此Rule的FeatureStructure。

　　    *@return表示对话当前状态的系统响应的SystemDialougeAct，

　　    *       或当失败的时候＜code＞null＜/code＞。

　　    *

　　    */

　　  public SystemDialogueAct update(ApplicationInformation

　　                                 someApplicationInformation)；

　　}

　　                                                            部分1.a.b

　　public interface InputRule extends Rule

　　{

　　    abstract public boolean integrate(InputFS theInput，

　　                                   InformationState theInformationState)；

　　}

　　                                                            部分1.a.c

　　import java.util.*；

　　abstract public class RuleContainer

　　{

　　    /**

　　    *保留Rule的列表
        <!-- SIPO <DP n="16"> -->
        <dp n="d16"/>
　　 */

　　protected ArrayList processingRules＝null；

　　/**

　　 *指定能够储存在此容器内的规则的类。

　　 *该类必须是＜code＞Rule＜/code＞的一个子类。

　　 */

　　protected Class ruleClass＝null；

　　 /**

　　 *默认构造器。

　　 *产生用于储存Rule的新列表。

　　 */

　　public RuleContainer()

　　{

　　           this.processingRules＝new ArrayList()；

　　}

　　/**

　　 *指定了能够储存在此容器内的Rule的类的构造器。

　　 *该类必须是＜code＞Rule＜/code＞的子类。

　　 *

　　 *@param aClass储存在此容器内的Rule的类。

　　 */

　　public RuleContainer(Class aClass)

　　{

　　           this.processingRules＝new ArrayList()；

　　           if(Rule.class.isAssignableFrom(aClass))

　　                        {this.ruleClass＝aClass；}

　　           else

　　                        {this.ruleClass＝Rule.class；}

　　}
        <!-- SIPO <DP n="17"> -->
        <dp n="d17"/>
　　 /**

　　 *将指定Rule添加到包含Rule的列表的末端。

　　 *

　　 *@param aRule要追加的Rule

　　 *@return＜code＞true＜/code＞如果成功追加了指定的Rule，

　　 *       ＜code＞false＜/code＞如果失败。

　　 */

　　public boolean appendRule(Rule aRule)

　　{

　　           if(aRule＝＝null)

　　                         {return false；}

　　           else if(！this.ruleClass.isInstance(aRule))

　　                         {return false；}

　　           else

　　                         {return this.processingRules.add(aRule)；}

　　}

　　/**

　　 *返回储存的Rule上的Iterator。

　　 *

　　 *@return源自储存Rule的列表的Iterator。

　　 */

　　protected Iterator iterator()

　　{

　　           return this.processingRules.iterator()；

　　}

　　/**

　　 *返回此容器的大小。

　　 *

　　 *@return＜code＞int＜/code＞，即储存Rule的数量。

　　 */

　　protected int size()

　　{

　　          return this.processingRules.size()；

　　}

　　/**

　　 *返回能够应用于给定FeatureStructure的第一Rule。

　　 *从第一个元素到最后一个元素处理该列表。

　　 *

　　 *@param aFS将要被匹配的FeatureStructure。

　　 *@return匹配于给定的FeatureStructure的第一Rule。

　　 */

　　public Rule getFirstMatchingRule(FeatureStructure aFeatureStructure)

　　{

　　           Iterator iter＝this.iterator()；

　　           while(iter.hasNext())

　　           {

　　                Rule currentRule＝(Rule)iter.next()；

　　                if(currentRule.isApplicableTo(aFeatureStructure))

　　                   {return currentRule；}

　　           }

　　           return null；

　　}
        <!-- SIPO <DP n="18"> -->
        <dp n="d18"/>
　　}

　　                                               部分1.b
        <!-- SIPO <DP n="19"> -->
        <dp n="d19"/>
　　public class OutputProcessor extends RuleContainer

　　{

　　  public OutputProcessor()

　　  {

　　               super(OMRule.class)；

　　  }

　　  public Object process(SystemDialogueAct generatedOutput，InformationState anIS)

　　  {

　　               OMRule applicableRule＝(OMRule)

　　                                    getFirstMatchingRule(generatedOutput)；

　　               if(applicableRule＝＝null){return null；}

　　               return applicableRule.process(generatedOutput，anIS)；

　　  }

　　}

　　                                                                部分1.b.a

　　public class ApplicationActionPlanner extends RuleContainer

　　{

　　    public ApplicationActionPlanner()

　　    {

　　              super(ApplicationRule.class)；

　　    }

　　    public SystemDialogueAct process(ApplicationInformation

　　   someApplicationInformation)

　　    {

　　              ApplicationRule applicableRule＝(ApplicationRule)

　　   getFirstMatchingRule(someApplicationInformation)；

　　              return applicableRule.update(someApplicationInformation)；

　　    }

　　}

　　                                                               部分1.b.b

　　import java.util.*；

　　public class InputProcessor extends RuleContainer

　　{
        <!-- SIPO <DP n="20"> -->
        <dp n="d20"/>
　　  public InputProcessor(){super(InputRule.class)；}

　　  public boolean process(InputFS anInputFS，InformationState anIS)

　　  {

　　              InputRule applicableRule＝(InputRule)

　　                                      getFirstMatchingRule(anInputFS)；

　　              if(applicableRule＝＝null)

　　                           {return false；}

　　              else

　　                            return applicableRule.integrate(anInputFS，anIS)；

　　  }

　　}

　　                                                                   部分1.b.c
        <!-- SIPO <DP n="21"> -->
        <dp n="d21"/>
　　import java.util.*；

　　abstract public class FeatureStructure

　　{

　　    protected HashSet validFeatures＝null；

　　    /*

　　    *构造器。

　　    *

　　    *初始化：

　　    *构造器根据方法resetFeature(String)复位特征。

　　    *任何子类中进一步的初始化覆盖此初始化。

　　    */

　　    protected FeatureStructure(String[]theFeatures)

　　    {

　　              //读入theFeatures并将它们复位

　　              this.validFeatures＝new HashSet(theFeatures.length)；

　　              //复位所有特征

　　              for(int i＝0；i＜theFeatures.length；i++)

　　              {

　　                 this.validFeatures.add(theFeatures[i])；

　　                 if(！resetFeature(theFeatures[i]))

　　                    System.err.println(″WARNING：

　　                     FeatureStructure：：FeatureStructure″+

　　                          ″(String[])：Cannot initialise the feature：″+

　　                          theFeatutes[i])；

　　              }

　　              makeUnspecific()；

　　  }

　　  //返回特征的复制

　　  public HashSet getFeatures()

　　  {

　　             return new HashSet(validFeatures)；

　　  }

　　  protected boolean resetFeature(String aFeatureName)

　　  {

　　             return setFeature(aFeatureName，

　　                          getResetValueForFeature(aFeatureName))；

　　  }

　　  protected boolean unspecifyFeature(String aFeatureName)

　　  {

　　             return setFeature(aFeatureName，null)；

　　  }

　　  public boolean makeUnspecific()

　　  {

　　             boolean allMadeUnspecific＝true；

　　             Iterator iter＝iterator()；

　　             while(iter.hasNext())

　　          {

　　                  String currentFeature＝(String)iter.next()；

　　                  allMadeUnspecific＝unspecifyFeature(currentFeature)&&

　　                                allMadeUnspecific；

　　          }
        <!-- SIPO <DP n="22"> -->
        <dp n="d22"/>
　　           return allMadeUnspecific；

　　}

　　public boolean isValidFeature(Object aFeatureName)

　　{

　　           return this.validFeatures.contains(aFeatureName)；

　　}

　　public boolean isReset(String aFeatureName)

　　{

　　           Object value＝getFeature(aFeatureName)；

　　           Object reset＝getResetValueForFeature(aFeatureName)；

　　           if(null＝＝value)

　　             {if(null＝＝reset)return true；else return false；}

　　           else

　　             {return value.equals(reset)；}

　　}

　　public boolean isUnspecified(String aFeatureName)

　　{

　　           return getFeature(aFeatureName)＝＝null；

　　}

　　public Iterator iterator()

　　{

　　           return this.validFeatures.iterator()；

　　}

　　/*

　　*此FeatureStructure将另一个FeatureStructure FS归入，

　　*当且仅当

　　*-这是FS的超类的实例；以及

　　*-每个特征或者为空值或者等于FS的相应特征

　　*/

　　public boolean subsumes(FeatureStructure aFeatureStructure)

　　{

　　           if(null＝＝aFeatureStructure)

　　         {

　　              System.err.print(″WARNING

　　                        FeatureStructure：：subsumes(FeatureStructure)：″)；

　　              System.err.println(″Argument is null.″)；

　　              return false；

　　         }

　　           //类型检查

　　           else if(！this.getClass().isInstance(aFeatureStructure))

　　             {return false；}

　　         //检查每个特征

　　           else

　　           {

　　           //检查单个特征

　　               Iterator allFeatures＝iterator()；

　　               while(allFeatures.hasNext())

　　               {

　　                   String currentFeature＝(String)allFeatures.next()；

　　                 Object myVal＝this.getFeature(currentFeature)；

　　                   If(null＝＝myVal)continue；

　　                   Object otherVal＝aFeatureStructure.getFeature(

　　                                currentFeature)；

　　                   if(myVal.equals(otherVal))continue；
        <!-- SIPO <DP n="23"> -->
        <dp n="d23"/>
　　                else if(myVal.equals(″＜specified＞″)&&

　　                          null！＝otherVal)

　　                   {continue；}

　　        else if(myVal.equals(″＜non-empty＞″)&&

　　                         null！＝otherVal&&
　
　　                           (！aFeatureStructure.isReset(currentFeature)))

　　                       {continue；}

　　        else if((myVal instanceof FeatureStructure)&&

　　                              (otherVal instanceof FeatureStructure)&&
　　                              ((FeatureStructure)myVal).subsumes(

　　                                (FeatureStructure)otherVal))

　　                         continue；

　　        else return false；

　　               }

　　                 return true；

　　           }

　　}

　　public boolean overwriteWith(FeatureStructure aFeatureStructure)

　　{

　　           boolean OK＝true；

　　           Iterator iter＝iterator()；

　　           while(iter.hasNext())

　　         {

　　           String currentFeature＝(String)iter.next()；

　　           Object value＝aFeatureStructure.getFeature(currentFeature)；

　　           if(value！＝null)

　　             if(value instanceof FeatureStructure)

　　                       {

　　                          FeatureStructure my＝(FeatureStructure)

　　                                      getFeature(currentFeature)；

　　                          OK＝my.overwriteWith((FeatureStructure)value)

　　                             &&OK；

　　                        }

　　             else

　　                        {

　　                          OK＝setFeature(currentFeature，value)&&OK；

　　                        }

　　         }

　　           //尚未实现：true，如果已经发生了改变

　　           return OK；

　　  }

　　  public String toString()

　　  {

　　             return toString(″″)；

　　  }

　　  public String toString(String prefix)

　　  {

　　             StringBuffer resultString＝new StringBuffer()；

　　             Iterator allFeatures＝validFeatures.iterator()；

　　             while(allFeatures.hasNext())
　　            {

　　                 String currentFeature＝(String)allFeatures.next()；

　　                 Object currentValue＝this.getFeature(currentFeature)；

　　                 resultString.append(prefix)；
　　                 resultString.append(currentFeature +″：″)；

　　                 if(currentValue instanceof FeatureStructure)

　　                 {
        <!-- SIPO <DP n="24"> -->
        <dp n="d24"/>
　　                   resultString.append(″\n″+

　　                 ((FeatureStructure)currentValue).toString(prefix+

　　                   ″        ″))；

　　                }

　　                else

　　                   resultString.append(currentValue+″\n″)；

　　            }

　　            return resultString.toString()；
　　  }

　　  public FeatureStructure copy()

　　  {

　　            try

　　            {

　　               FeatureStructure clone＝(FeatureStructure)super.clone()；

　　               clone.validFeatures＝new HashSet(this.validFeatures)；

　　               return clone；

　　            }

　　            catch(CloneNotSupportedException e)

　　            {

　　               System.err.println(″FeatureStructure：：clone：″+e)；

　　               return null；

　　             }

　　  }

　　  abstract public boolean setFeature(String aFeatureName，Object aValue)；

　　  abstract public Object getFeature(String aFeatureName)；

　　  abstract public Object getResetValueForFeature(String aFeatureName)；

　　}

　　                                                                 部分1.c
        <!-- SIPO <DP n="25"> -->
        <dp n="d25"/>
　　import java.util.*；

　　/**

　　 *提供了用于定义具体TaskState的特征之间的层次的方法。

　　 *

　　 *预备性的，你能够在特征上指定一个严格单调的线性顺序。

　　 *对于每个特征，你能够指定它是否属于这个排序关系。
　　 */

　　public abstract class HierarchicFeatureStructure extends FeatureStructure

　　{

　　  protected ArrayList featureOrder＝null；

　　  public HierarchicFeatureStructure(String[]theFeatures，String[]theOrder)

　　  {

　　              super(theFeatures)；

　　              //读入theOrder并检查它是否是theFeatures的子集；

　　              //消除双重出现

　　              this.featureOrder＝new ArrayList()；

　　              for(int i＝0；i＜theOrder.length；i++){

　　                 if(！isValidFeature(theOrder[i]))

　　                   System.err.println(″WARNING：

　　                                 HierarchicFeatureStructure(″+

　　                                      ″Collection，List)：The given order″+

　　                                      ″contains the invalid feature：″+

　　                                      theOrder[i])；}

　　                 else if(this.featureOrder.contains(theOrder[i]))

　　                   System.err.println(″WARNING：

　　                                      HierarchicFeatureStructure(″+

　　                                      ″Collection，List)：Double occurence″+

　　                                         ″of feature″+theOrder[i])；}

　　               else

　　                   this.featureOrder.add(theOrder[i])；

　　  }

　　}

　　protected List getDependentFeatures(String aFeature)
　　{

　　             int position＝this.featureOrder.indexOf(aFeature)；
　　             if(-1＝＝position )

　　                         return null；

　　             List dependentFeatures＝new ArrayList()；

　　             for(int i＝position+l；i＜this.featureOrder.size()；i++)

　　                {

　　                           dependentFeatures.add(this.featureOrder.get(i))；

　　                }

　　             return dependentFeatures；

　　}

　　public boolean integrateFeature(String aFeature，Object theValue)

　　{

　　             if(null＝＝theValue)

　　                          return false；

　　             if(！isValidFeature(aFeature))

　　                          return false；

　　//获得依赖于给定特征的特征

　　             List dependentFeatures＝getDependentFeatures(aFeature)；

　　             if(null＝＝dependentFeatures)

　　                          return false；
        <!-- SIPO <DP n="26"> -->
        <dp n="d26"/>
                Iterator iter＝dependentFeatures.iterator()；
                while(iter.hasNext())
                {
                            String currentFeature＝(String)iter.next()；
                            if(！resetFeature(currentFeature)
                                    return false；
                }
                return setFeature(aFeature，theValue)；
    }
    public boolean integrateFeatureStructure(FeatureStructure aFS
    {
                boolean OK＝true；
                Iterator allFeaturesSorted＝
                        sortFeatures(aFS.getFeatures()).iterator()；
                while(allFeaturesSorted.hasNext())
                {
                             String currentFeature＝(String)
                                      allFeaturesSorted.next()；
                OK＝integrateFeature(currentFeature，
                                aFS.getFeature(currentFeature))&&OK；
                }
                return OK；
    }
    public List sortFeatures(Collection someFeatures)
    {
                ArrayList sortedFeatures＝new ArrayList()；
     //从层次中取得特征
                Iterator iter＝this.featureOrder.iterator()；
                while(iter.hasNext())
                {
                            String currentFeature＝(String)iter.next()；
                            If(someFeatures.contains(currentFeature))
                                     sortedFeatures.add(currentFeature)；
                }
                iter＝someFeatures.iterator()；
                while(iter.hasNext())
                {
                            String currentFeature＝(String)iter.next()；
                            if(！this.featureOrder.contains(currentFeature))
                                     sortedFeatures.add(currentFeature)；
                }
                return sortedFeatures；
      }
      public FeatureStructure copy()
      {
                HierarchicFeatureStructure clone＝(HierarchicFeatureStructure)
                                          super.copy()；
                clone.featureOrder＝new ArrayList(this.featureOrder)；
                return clone；
      }
    }
                                                                      部分1.c.a
        <!-- SIPO <DP n="27"> -->
        <dp n="d27"/>
　　import java.util.*；

　　public class TaskState extends HierarchicFeatureStructure

　　{

　　    static final String[]FEATURES＝new String[]{″TASKTYPE″，″TASKVALUE″，

　　                                             ″NEWSITEM″，″NEWSCOMPONENT″}；

　　    static final String[]ORDER＝new String[]{″TASKTYPE″，″TASKVALUE″，

　　                                             ″NEWSITEM″，″NEWSCOMPONENT″}；

　　//通过super()构造器完成初始化

　　  protected String type；

　　  protected String value；

　　  protected Object newsItem；

　　  protected Object newsComponent；

　　  public TaskState()

　　  {

　　             super(FEATURES，ORDER)；

　　  }

　　  protected boolean setTYPE(String aString)

　　             {this.type＝aString；return true；}

　　  protected boolean setVALUE(String aString)

　　             {this.value＝aString；return true；}

　　  protected boolean setNEWSITEM(Object anObject)

　　             {this.newsItem＝anObject；return true；}

　　  protected boolean setNEWSCOMPONENT(Object anObject)

　　             {this.newsComponent＝anObject；return true；}

　　  protected String getTYPE(){return this.type；}

　　  protected String getVALUE(){return this.value；}

　　  protected Object getNEWSITEM(){return this.newsItem；}

　　  protected Object getNEWSCOMPONENT(){return this.newsComponent；}

　　  public boolean setFeature(String aFeatureName，Object aValue)

　　  {

　　             if(aFeatureName＝＝″TASKTYPE″)

　　                          {return setTYPE((String)aValue)；}

　　             else if(aFeatureName＝＝″TASKVALUE″)

　　                          {return setVALUE((String)aValue)；}

　　             else if(aFeatureName＝＝″NEWSITEM″)

　　                          {return setNEWSITEM(aValue)；}

　　             else if(aFeatureName＝＝″NEWSCOMPONENT″)

　　                          {return setNEWSCOMPONENT(aValue)；}

　　             else{return false；}

　　}

　　public Object getFeature(String aFeatureName)

　　{

　　             if(aFeatureName＝＝″TASKTYPE″)

　　                          {return getTYPE()；}

　　             else if(aFeatureName＝＝″TASKVALUE″)
　　                          {return getVALUE()；}

　　             else if(aFeatureName＝＝″NEWSITEM″)

　　                          {return getNEWSITEM()；}
　　             else if(aFeatureName＝＝″NEWSCOMPONENT″)

　　                          {return getNEWSCOMPONENT()；}
        <!-- SIPO <DP n="28"> -->
        <dp n="d28"/>
　　             else {return null；}

　　  }

　　  public Object getResetValueForFeature(String aFeatureName)

　　  {

　　             if(aFeatureName＝＝″TASKTYPE″){return″″；}
　　             else if(aFeatureName＝＝″TASKVALUE″){return″″；}

　　             else if(aFeatureName＝＝″NEWSITEM″){return″″；}

　　             else if(aFeatureName＝＝″NEWSCOMPONENT″){return″″；}

　　             else

　　    {

　　             return null；

　　    }

　　  }

　　  public FeatureStructure copy()

　　  {

　　             TaskState clone＝(TaskState)super.copy()；

　　             clone.setNEWSITEM(this.getNEWSITEM())；

　　             clone.setNEWSCOMPONENT(this.getNEWSCOMPONENT())；

　　             return clone；

　　  }

　　}

　　                                                            部分1.c.a.a
        <!-- SIPO <DP n="29"> -->
        <dp n="d29"/>
　　public class ApplicationInformation extends FeatureStructure

　　{

　　   static final String[]FEATURES＝new String[]{″TASKSTATE″，″ACTION″}；

　　   //特征

　　   protected TaskState      taskState；

　　   protected String        action；

　　   public ApplicationInformation()

　　   {

　　              super(FEATURES}；

　　   }

　　   public ApplicationInformation(String[]moreFeatures)

　　   {

　　              super(moreFeatures)；

　　   }

　　   //访问

　　   public TaskState getTaskState(){return this.taskState；}

　　   public Object getFeature(String aFeatureName)

　　   {

　　              if(aFeatureName＝＝″TASKSTATE″)

　　                          {return this.taskState；}

　　              else if(aFeatureName＝＝″ACTION″)
　　                          {return this.action；}

　　              else{

　　            System.err.print(″WARNING InformationState：：getFeature(STRING)″)；

　　              System.err.println(″Feature name″+aFeatureName +

　　                                ″does not exist.″)；

　　                            return null；

　　              }

　　   }

　　   //设置

　　   public boolean setFeature(String aFeatureName，Object aValue)

　　   {
　　              if(aFeatureName＝＝″TASKSTATE″)

　　                           {taskState＝(TaskState)aValue；return true；}

　　              else if(aFeatureName＝＝″ACTION″)

　　                           {action＝(String)aValue；return true；}

　　              else{

　　              System.err.print(″InformationState：：setFeature(String)″)；

　　              System.err.println(″Feature name ″+aFeatureName+

　　                              ″does not exist.″)；

　　              return false；

　　     }

　　   }

　　   public Object getResetValueForFeature(String aFeatureName)

　　   {

　　              if(aFeatureName＝＝″TASKSTATE″)

　　                          {return new TaskState()；}

　　              else if(aFeatureName＝＝″ACTION″)

　　                          {return″″；}

　　              else{

　　              System.err.print(″InformationState：：getResetValueForFeature(

　　                                                                  String)″)；
        <!-- SIPO <DP n="30"> -->
        <dp n="d30"/>
　　              System.err.println(″Feature name″+aFeatureName+

　　                                ″does not exist.″)；

　　              return null；

　　    }

　　  }

　　  //覆盖顶端的方法。

　　  public boolean makeUnspecific()

　　  {

　　             if(super.makeUnspecific ())

　　             {

　　                          this.taskState＝new TaskState()；

　　                          return this.taskState.makeUnspecific()；

　　             }

　　             else{return false；}

　　  }

　　}

　　                                                             部分1.c.b
        <!-- SIPO <DP n="31"> -->
        <dp n="d31"/>
　　import java.lang.*；

　　import java.util.*；

　　public class InformationState extends ApplicationInformation

　　{

　　   static final String[]FEATURES＝new String[]

　　                               {″TASKSTATE″，″ACTION″，″SYS-UTT″，

　　                                      ″USER-APPROVAL″，″SYS-OPEN-REQ″}；

　　   //特征

　　   protected String        sysUtt；

　　   protected String        userApproval；

　　   protected String        sysOpenReq；

　　   public InformationState()

　　   {

　　             super(FEATURES)；

　　   }

　　   //访问

　　   public TaskState getTaskState(){return this.taskState；}

　　   public Object getFeature(String aFeatureName)

　　   {

　　              if(aFeatureName＝＝″TASKSTATE″)

　　                           {return this.taskState；}

　　              else if(aFeatureName＝＝″ACTION″)

　　                           {return this.action；}

　　              else if(aFeatureName＝＝″SYS-UTT″)

　　                           {return this.sysUtt；}

　　              else if(aFeatureName＝＝″USER-APPROVAL″)

　　                           {return this.userApproval；}

　　              else if{aFeatureName＝＝″SYS-OPEN-REQ″)

　　                           {return this.sysOpenReq；}

　　              else return null；

　　   }

　　   //设置

　　   public boolean setFeature(String aFeatureName，Object aValue)

　　   {

　　              if(aFeatureName＝＝″TASKSTATE″)

　　                           {taskState＝(TaskState)aValue；return true；}

　　              else if(aFeatureName＝＝″ACTION″)

　　                           {action＝(String)aValue；return true；}

　　              else if(aFeatureName＝＝″SYS-UTT″)

　　                           {sysUtt＝(String)aValue；return true；}

　　              else if(aFeatureName＝＝″USER-APPROVAL″)

　　                           {userApproval＝(String)aValue；return true；}

　　              else if(aFeatureName＝＝″SYS-OPEN-REQ″)

　　                           {sysOpenReq＝(String)aValue；return true；}

　　              else return false；

　　   }
        <!-- SIPO <DP n="32"> -->
        <dp n="d32"/>
　　public Object getResetValueForFeature(String aFeatureName)

　　{

　　           if(aFeatureName＝＝″TASKSTATE″){return new TaskState()；}

　　           else if(aFeatureName＝＝″ACTION″){return″″；}

　　           else if(aFeatureName＝＝″SYS-UTT″)

　　                        {return new String(″not-used″)；}

　　           else if(aFeatureName＝＝″USER-APPROVAL″){return″″；}

　　           else if(aFeatureName＝＝″SYS-OPEN-REQ″){return″″；}

　　           else return null；

　　}

　　//

　　//覆盖顶端的方法。

　　//

　　public boolean makeUnspecific()

　　{

　　          if(super.makeUnspecific ())

　　          {

　　                       this.taskState＝new TaskState()；
　　                       return this.taskState.makeUnspecific()；

　　          }

　　          else return false；

　　  }

　　}

　　                                                          部分1.c.c
        <!-- SIPO <DP n="33"> -->
        <dp n="d33"/>
　　import java.util.*；

　　public class SystemDialogueAct extends FeatureStructure

　　{

　　   static final String[]FEATURES＝new String[]{″DIALACT″，″OPTIONS″}；

　　   protected String dialAct；

　　   protected List options；

　　   public SystemDialogueAct()

　　   {

　　              super(FEATURES)；

　　   }

　　   public boolean setFeature(String aFeatureName，Object aValue)

　　   {

　　              if(aFeatureName.equals(″DIALACT″))

　　                           {dialAct＝(String)aValue；return true；}

　　              else if(aFeatureName.equals(″OPTIONS″))

　　                           {options＝(List)aValue；return true；}

　　              else

　　                           {return false；}

　　   }

　　   public Object getFeature(String aFeatureName)

　　   {
　　              if(aFeatureName.equals(″DIALACT″))

　　                           {return dialAct；}

　　              else if(aFeatureName.equals(″OPTIONS″))

　　                           {return options；}

　　              else

　　                           {return null；}

　　   }

　　   public Object getResetValueForFeature(String aFeatureName)

　　   {

　　              if(aFeatureName.equals(″DIALACT″))

　　                           {return″″；}

　　              else if(aFeatureName.equals(″OPTIONS″))

　　                           {return new ArrayList()；}

　　              else

　　                           {return null；}

　　   } 

　　}

　　                                                         部分1.c.d
        <!-- SIPO <DP n="34"> -->
        <dp n="d34"/>
　　import java.util.*；

　　public class DialogueManager

　　{

　　   /**标记该实例是否已初始化*/

　　   protected boolean                      initialized；

　　   /**InformationState*/

　　   protected InformationState             informationState；

　　   /**属于InputIntegration。有效性检查*/

　　   protected InputProcessor               validityChecker；

　　   /**属于InputIntegration。集成于信息状态*/

　　   protected InputProcessor               dialogueActIntegrator；

　　   /**属于Active Planner。一般对话行为*/

　　   //protected ISUpdator                  dialogueControl；

　　   /**属于Active Planner。应用指定行为和控制*/

　　   protected ApplicationActionPlanner taskControl；

　　   /**OutputManager*/

　　   protected OutputProcessor              outputManager；

　　   public DialogueManager()
　　　  {

　　              this.initialized          ＝false；

　　              this.informationState     ＝new InformationState()；

　　              this.validityChecker      ＝new InputProcessor()；

　　              this.dialogueActIntegrator＝new InputProcessor()； 

　　  //          this.dialogueControl      ＝new ISUpdator()；

　　              this.taskControl          ＝new ApplicationActionPlanner()；

　　              this.outputManager        ＝new OutputProcessor()；

　　  }
　　  public void init()

　　  {

　　              //对每个RuleProcessor加载Rule

　　              //loadValidityChecks(this.validityChecker)；

　　              loadDialogueIntegrationRules(this.dialogueActIntegrator)；

　　              //loadDialogueControlRules(this.dialogueControl)；

　　              NewsApplication.loadTaskControlRules(this.taskControl)；

　　              OutputManagerRules.loadOutputManagerRules(this.outputManager)；

　　              //设定标记，指示所有均已初始化

　　              this.initialized＝true；

　　  }

　　  public void loadValidityChecks(InputProcessor anInputProcessor)

　　  {

　　              System.err.println(Validity checks aren′t implemented yet.″)；

　　  }

　　  public void loadDialogueIntegrationRules(InputProcessor anInputProcessor)

　　  {

　　              InputRule rule；

　　              //总是匹配

　　              rule＝new InputRule()

　　              {
　　  public boolean isApplicableTo(FeatureStructure aFS){return true；}
        <!-- SIPO <DP n="35"> -->
        <dp n="d35"/>
　　  public boolean integrate(InputFS theInput，InformationState

　　             theInformationState)

　　              {

　　  theInformationState.getTaskState().integrateFeatureStructure(

　　                   theInput.getTaskState())；

　　             Object actionValue＝theInput.getFeature(″ACTION″)；

　　             if((actionValue！＝null)&&(actionValue！＝″″))

　　             {theInformationState.setFeature(″ACTION″，actionValue)；

　　             return true；

　　             }

　　             }；

　　             anInputProcessor.appendRule(rule)；
　　  }

　　//   public void loadDialogueControlRules(ISUpdator anISUpdator)

　　//   {

　　//            System.err.println(″not implemented yet.″)；

　　//   }

　　  public InformationState getInformationState()

　　  {

　　              return this.informationState；

　　  }

　　  public void process(InputFS anInput)

　　  {

　　              //输入集成

　　              this.dialogueActIntegrator.process(anInput，

　　                                              this.informationState)；

　　              //日志消息：转储信息状态

　　              System.out.println(″#[InformationState]″)；

　　              System.out.println(this.informationState.toString(″#″))；

　　              //动作计划器(应用独立的对话控制)

　　              SystemDialogueAct generatedOutput＝(SystemDialogueAct)

　　              this.taskControl.process(this.informationState)；

　　              //日志消息：对话行为

　　              System.out.println(″#[SystemDialogueAct]″)；

　　              if(generatedOutput＝＝null)

　　                           System.out.println(″#″+generatedOutput)；

　　              else

　　                           System.out.println(generatedOutput.toString(

　　                                                                ″#″))；

　　              //生成系统输出

　　              Object output＝this.outputManager.process(

　　                           generatedOutput，this.informationState)；

　　    }

　　}

　　                                                                 部分1.d
        <!-- SIPO <DP n="36"> -->
        <dp n="d36"/>
　　import java.util.*；

　　public class OutputManagerRules

　　{

　　   public static void loadOutputManagerRules(OutputProcessor anOutputProcessor)

     {

                OMRule rule；

                //Rule 1                     //匹配如果DIALACT＝offer-inform

                rule＝new OMRule()

                {

                   public boolean isApplicableTo(FeatureStructure aFS)

                   {

                      if((aFS！＝null)

                            &&(aFS instanceof SystemDialogueAct)

                            &&aFS.getFeature(″DIALACT″)＝＝″offer-inform″)

                            return true；

                      else

                            return false；

                   }

                   public Object process(SystemDialogueAct aDA，

                                        InformationState anIS)

　　             {

　　                    List options＝(List)aDA.getFeature(″OPTIONS″)；

　　                  StringBuffer xmlstring＝new StringBuffer()；

　　                    xmlstring.append(″＜SELECTION-LIST＞\n″)；

　　                    if(options！＝null)

　　                    {

　　                        Iterator iter＝options.iterator()；

　　                        while(iter.hasNext())

　　                      {

　　                             xmlstring.append(″＜ITEM＞\n″)；

　　                           xmlstring.append(″＜TEXT＞\″...blabla...\″+

　　                                         ″＜/TEXT＞\n″)；

　　                             xmlstring.append(″＜REF＞″+iter.next()+

　　                                         ″＜/REF＞\n″)；

　　                             xmlstring.append(″＜/ITEM＞\n″)；

　　                        }

　　                   }

　　                   xmlstring.append(″＜/SELECTION-LIST＞\n″)；

　　                   return xmlstring；

　　               }

　　    }；

　　    //添加Rule1到OutputManager

　　    anOutputProcessor.appendRule(rule)；

　　  }

　　}

　　                                                                   部分1.e
        <!-- SIPO <DP n="37"> -->
        <dp n="d37"/>
　　import java.util.*；

　　public class NewsApplication

　　{

　　  public static int loadTaskControlRules(ApplicationActionPlanner anApplAP)

　　    {

　　               ApplicationRule rule；

　　               //Rulel：

　　               //匹配，如果NEWSITEM！＝″″

　　               //TASKSTATE：

　　               //        NEWSCOMPONENT：

　　               //        NEWSITEM：＜non-empty＞

　　               //        TASKTYPE：

　　               //        TASKVALUE：

　　               //ACTION：

　　               rule＝new ApplicationRule()

　　               {

　　                  public boolean isApplicableTo(FeatureStructure aFS)

　　                  {

　　                     ApplicationInformation condition＝new

　　                                            ApplicationInformation()；

　　                     condition.getTaskState().setFeature(″NEWSITEM″，

　　                                                     ″＜non-empty＞″)；

　　                     return condition.subsumes(aFS)；

　　               }

　　                  public SystemDialogueAct update(ApplicationInformation aFS)

　　                  {

　　                     Object newsItem＝((FeatureStructure)

　　                       aFS.getFeature (″TASKSTATE″)).getFeature(″NEWS ITEM″)；

　　                     System.out.println(″newsItem：″+newsItem)；

　　                     System.out.print in(″[NewsApplication.java：L40]

　　                                         APPLICATION LINK.″)；

　　                     return null；

　　                  }

　　               }；

　　               anApplAP.appendRule(rule)；

　　                 //Rule2：

　　                 //匹配，如果TASKTYPE＝＝″category″

　　                 //TASKSTATE：

　　                 //        NEWSCOMPONENT：

　　                 //        NEWSITEM：

　　                 //        TASKTYPE：category

　　                 //        TASKVALUE：

　　                 //ACTION：

　　                 rule＝new ApplicationRule()

　　                 {

　　                     public boolean isApplicableTo(FeatureStructure aFS)

　　                     {

　　                       ApplicationInformation condition＝new

　　                                                   ApplicationInformation()；

　　                       condition.getTaskState().setFeature(″TASKTYPE″，

　　                                                     ″category″)；
        <!-- SIPO <DP n="38"> -->
        <dp n="d38"/>
　　       return condition.subsumes(aFS)；

　　    }

　　    public SystemDialogueAct update(ApplicationInformation aFS)

　　    {

　　       String taskValue＝(String)((FeatureStructure)

　　        aFS.getFeature(″TASKSTATE″)).getFeature(″TASKVALUE″)；

　　       System.out.println(″APPLICATION Database Access″)；

　　       System.out.println(″query(type：NEWSITEM，

　　                             (category：″+taskValue+″))″)；

　　       ArrayList dbQueryResult＝new ArrayList()；

　　              dbQueryResult.add(″＜-，-，NewsItem#123，-＞″)；

　　              dbQueryResult.add(″＜-，-，NewsItem#234，-＞″)；

　　              dbQueryResult.add(″＜-，-，NewsItem#345，-＞″)；

　　       System.out.println(″Query result：″+

　　           dbQueryResult.toString())；

　　       SystemDialogueAct sysDialAct＝new SystemDialogueAct()；

　　       sysDialAct.makeUnspecific()；

　　       sysDialAct.setFeature(″DIALACT″，″offer-inform″)；

　　       sysDialAct.setFeature(″OPTIONS″，dbQueryResult)；

　　       return sysDialAct；

　　     }

　　}；

　　anApplAP.appendRule(rule)；

　　//最后的Rule：初始化

　　//匹配，如果ACTION＝＝″！initialize″

　　//TASKSTATE：

　　//        NEWSCOMPONENT：

　　//        NEWSITEM：

　　//        TASKTYPE：

　　//        TASKVALUE：

　　//ACTION：！initialize

　　rule＝new ApplicationRule()

　　{

　　   public boolean isApplicableTo(FeatureStructure aFS)

　　   {

　　      ApplicationInformation condition＝new

　　                        ApplicationInformation()；

　　      condition.setFeature(″ACTION″，″！initialize″)；

　　      return condition.subsumes(aFS)；

　　   }

　　   public SystemDialogueAct update(ApplicationInformation aFS)

　　   {

　　      System.out .println(″-INITIALIZATION″)；

　　      aFS.resetFeature(″TASKSTATE″)；

　　      aFS.setFeature(″ACTION″，″present″)；

　　      ArrayList dbQueryResult＝new ArrayList()；

　　        dbQueryResult.add(″＜category，inland，-，-＞″)；

　　        dbQueryResult.add(″＜category，ausland，-，-＞″)；

　　        dbQueryResult.add(″＜category，politik，-，-＞″)；

　　        dbQueryResult.add(″＜category，wirtschaft，-，-＞″)；

　　        dbQueryResult.add(″＜bookmarks，-，-，-＞″)；

　　      SystemDialogueAct sysDialAct＝new SystemDialogueAct()；

　　      sysDialAct.setFeature(″DIALACT″，″offer-inform″)；

　　      sysDialAct.setFeature(″OPTIONS″，dbQueryResult)；

　　      return sysDialAct；

　　  }
        <!-- SIPO <DP n="39"> -->
        <dp n="d39"/>
　　            }；

　　             anApplAP.appendRule(rule)；

　　             return anApplAP.size()；

　　    }

　　}

　　                                                                   部分1.f

　　public class demo

　　{

　　   public demo1(){}

　　   public static void main(String[]ARGS)

　　   {

　　              System.out.println(″###START ####″)；

　　              DialogueManager dm＝new DialogueManager()；

　　              dm.init()；　

　　              System.out.println(″#Initialize #″)；

　　              InputFS in＝new InputFS()；

　　              in.setFeature(″ACTION″，″！initialize″)；

　　              dm.process(in)；

　　              System.out.println(″#[InformationState]″)；

　　              System.out.println(dm.getInformationState().toString(″#″))；

　　  System.out.println(″####################################################″)；

　　  System.out.println(″# Step 1 ###########################################″)；

　　  System.out.println(″# Process Input：＜category，inland，-，-＞###########″)；

　　  System.out.println(″####################################################″)；

　　              in＝new InputFS()；

　　              in.getTaskState().setFeature(″TASKTYPE″，″category″)；

　　              in.getTaskState().setFeature(″TASKVALUE″，″inland″)；

　　              System.out.println(″#User Input：″)；

　　              System.out.println(in.toString(″#″))；

　　              dm.process(in)；

　　              System.out.println(″#[InformationState]″)；

　　              System.out.println(dm.getInformationState().toString(″#″))；

　　  System.out.println(″####################################################″)；

　　  System.out.println(″# Step 2 ###########################################″)；

　　  System.out.println(″# Process Input ＜-，-，NewsItem#345，-＞#############″)；

　　  System.out.println(″# (NewsItem)########################################″)；

　　  System.out.println(″####################################################″)；

　　              in＝new InputFS()；

　　              in.getTaskState().setFeature(″NEWSITEM″，″NewsItem#345″)；

　　              System.out.println″#User Input：″)；

　　              System.out.println in.toString(″#″))；

　　              dm.process(in)；

　　              System.out.println″#[InformationState]″)；

　　              System.out.println(dm.getInformationState().toString(″#″))；

　　    }

　　}

　　                                                                   部分1.g

Claims (6)

1.一种处理设备上的多模式对话的方法，包含如下步骤：

—提供多模式对话的描述；

—探测所述设备的模态能力以识别可用的模态；

—在所述可用模态和所述多模式对话之间建立模态绑定；

—根据所述模态绑定和所述多模式对话的描述交互地处理所述多模式对话的对话部分；

其中所述方法还包含如下步骤：

—动态地建立和维护对话语境，该对话语境反映了来自应用或使用语境的所用话语和约束条件以及所述可用模态；并且

—根据所述对话语境动态地调整在所述可用模态和所述多模式对话的描述之间的所述模态绑定。

2.根据权利要求1的方法，其中，所述对话语境被表示为任务状态、信息状态或应用信息的特征结构。

3.根据权利要求1的方法，其中，根据应用、输入或界面的规则进行所述动态调整。

4.一种具有对话界面的设备，其中，所述设备包括了用于执行根据权利要求1的方法的对话控制装置。

5.一种对话生成系统，其包括了用于生成和交换多模式对话的对话描述的传输装置，其中，所述对话生成系统包括了用于控制和生成根据权利要求1的方法的多模式对话的对话控制和生成装置。

6.一种计算机软件产品，其中，所述计算机软件产品包括了适合于执行根据权利要求1的方法的对话控制装置。

Images