[jboss-svn-commits] JBL Code SVN: r34096 - in labs/jbossrules/trunk/drools-docs: drools-docs-expert/src/main/docbook/en-US/Chapter-Authoring and 6 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Wed Jul 21 09:45:38 EDT 2010
Author: ge0ffrey
Date: 2010-07-21 09:45:37 -0400 (Wed, 21 Jul 2010)
New Revision: 34096
Modified:
labs/jbossrules/trunk/drools-docs/doc-authoring-guideline-and-cheatsheet.txt
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Authoring/Section-Templates.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-BankingExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-ConwaysGameOfLifeExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-FibonacciExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HelloWorldExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HonestPoliticianExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-MannersExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-NumberGuessExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-PetStoreExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-SodukiExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-StateExample.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-ErrorMessages.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Function.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Keywords.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Package.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Rule.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-TypeDeclaration.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Quick_Start/Section-The_Basics.xml
labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-User_Guide/Section-Running.xml
labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-Flow/Chapter-RuleFlow.xml
labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-RulesAndProcesses/Chapter-RulesAndProcesses.xml
Log:
JBRULES-2581 Replace all <kw> (not supported in standard docbook) with <literal>
Modified: labs/jbossrules/trunk/drools-docs/doc-authoring-guideline-and-cheatsheet.txt
===================================================================
--- labs/jbossrules/trunk/drools-docs/doc-authoring-guideline-and-cheatsheet.txt 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/doc-authoring-guideline-and-cheatsheet.txt 2010-07-21 13:45:37 UTC (rev 34096)
@@ -1,62 +1,63 @@
Drools Documentation Authoring Guideline and Cheat Sheet
========================================================
-Guideline
-=========
-* Please markup all package names, class names, method names, etc. with
- <code></code>.
-
- example:
- <para>The <code>JavaDialectConfiguration</code> allows the compiler
- and language levels to be supported. You can override by setting the
- <code>drools.dialect.java.compiler</code> property in a
- <code>packagebuilder.conf</code> file that the
- <code>ChainedProperties</code> instance will find, or you can do it
- at runtime as shown below.</para>
+External documentation
+----------------------
+JDocBook plugin: http://docs.jboss.org/docbook/userguide/html_single/index.html
+DocBook: http://www.docbook.org/tdg5/en/html/docbook.html
+ http://www.sagehill.net/docbookxsl/
-* Keywords may be enclosed in <kw></kw>, rendered in boldface Courier
+Word styles
+-----------
-* Use <literal> for class names, method names, ...: <literal>Serializable</literal>
+* Use <code> for package names, class names, method names, ...:
+ - the class <code>JavaDialectConfiguration</code>
+ - the package <code>drools.dialect.java.compiler</code>
+ - the method <code>toString()</code>
-* Use <filename> for directories and filenames: <filename>pom.xml</filename>
+* Use <filename> for directories and files:
+ - the directory <filename>drools-docs/target/</filename>
+ - the file <filename>pom.xml</filename>
-* Use <command> for commands: <command>mvn clean install</command>
+* Use <command> for commands:
+ - run the command <command>mvn clean install</command>
+* Use <literal> for literals and keywords:
+ - the value <literal>null</literal>
+ - the keyword <literal>not</literal>
+
+* Use <emphasis> to emphasis something (turns bold).
+ Note that you can use <emphasis> on <literal>, etc:
+ - <emphasis><literal>null</literal></emphasis>
+
+Paragraph styles
+----------------
+
+* <caution><para></para></caution>
+* <important><para></para></important>
+* <note><para></para></note>
+* <tip><para></para></tip>
+* <warning><para></para></warning>
+
+Images
+------
+
* Please link svg image files instead of png bitmaps in the text whenever
possible.
* Please avoid using .bmp bitmaps, since it will bloat size of the end
- doc. Use any image processing program such as GIMP to convert your bmp
- images to png images first. Better yet, use any vector graphic program
- such as InkScape to scan your bmp image and make a true svg image out
- of it. But this approach may take time and effort, recommended for
- processing diagrams but not for screenshots.
+ doc. To convert your bmp to a png images, use the GIMP, paint or the command "ffmpeg -i x.bmp x.png".
+ Better yet, use a vector graphic program such as InkScape to make a true svg image.
+ But this approach may take time and effort, recommended for processing diagrams but not for screenshots.
* At the head of a docbook file, the xml:base property should be set to
the relative path to the translation base directory ("en-US").
- For example: a file under en-US/Chapter-Introduction/ has xml:base="../"
- while a file under en-US/Chapter-Introduction/Section-WhatIs/ has xml:base="../../"
+ For example: a file under "en-US/Chapter-Introduction/" has xml:base="../"
+ while a file under "en-US/Chapter-Introduction/Section-WhatIs/" has xml:base="../../"
If it is not set correctly, the images won't show up in a visual docbook editor like XmlMind.
- There is one exception: files that use xinclude to include other files usually have xml:base="./"
- and they should not contain images.
+ There is one exception: any file that use xinclude to include other files usually have a xml:base="./"
+ and it should not contain images.
-Cheat Sheet
-===========
-
-External documentation
-----------------------
-JDocBook plugin: http://docs.jboss.org/docbook/userguide/html_single/index.html
-DocBook: http://www.docbook.org/tdg5/en/html/docbook.html
- http://www.sagehill.net/docbookxsl/
-
-Text boxes implemented in the jboss docbook styles:
----------------------------------------------------
-* <caution><para></para></caution>
-* <important><para></para></important>
-* <note><para></para></note>
-* <tip><para></para></tip>
-* <warning><para></para></warning>
-
Linking syntax in DocBook 5.0+:
-------------------------------
http://www.sagehill.net/docbookxsl/Db5Tools.html#Db5UnivLinking
@@ -80,7 +81,7 @@
* Simple (not as Example):
- <programlisting ><![CDATA[ your code here... ]]></programlisting>
+ <programlisting><![CDATA[ your code here... ]]></programlisting>
Link image files:
@@ -107,7 +108,6 @@
TODO
-
Lists
-----
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Authoring/Section-Templates.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Authoring/Section-Templates.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Authoring/Section-Templates.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -32,7 +32,7 @@
<para>A rule template file begins with a header defining the
placeholders, or <emphasis>formal template parameters</emphasis>
for the strings that are to be inserted during instantiation.
- After the first line, which invariably contains <kw>template header</kw>,
+ After the first line, which invariably contains <literal>template header</literal>,
you should write a number of lines, each of which contains a single
parameter name.</para>
@@ -49,11 +49,11 @@
<para>The template header is followed by the text that is to
be replicated and interpolated with the actual parameters. It
- may begin with a <kw>package</kw> statement, followed by some
+ may begin with a <literal>package</literal> statement, followed by some
additional lines. These
may be sectioned into one or more templates, each of them
- between a pair of matching <kw>template</kw> and
- <kw>end template</kw> statements. The <kw>template</kw> takes
+ between a pair of matching <literal>template</literal> and
+ <literal>end template</literal> statements. The <literal>template</literal> takes
an argument, which puts a name to the template. The name
can be a simple unquoted name or an arbitrary string enclosed
in double quotes. The template text between these lines may
@@ -86,8 +86,8 @@
the generator iterates over the sections and then over the
set of actual parameters.</para>
- <para>Any interpolation takes place between a pair of <kw>template</kw>
- and <kw>end template</kw> statements, when this template is
+ <para>Any interpolation takes place between a pair of <literal>template</literal>
+ and <literal>end template</literal> statements, when this template is
expanded. The template text is scanned for occurrences of
<emphasis>parameter expansions</emphasis> written according to:
<programlisting>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-BankingExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-BankingExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-BankingExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -77,7 +77,7 @@
}</programlisting>
</example>
- <para>The first simple rule to execute has a single <kw>eval</kw>
+ <para>The first simple rule to execute has a single <literal>eval</literal>
condition that will alway be true, so that this rule will match and
fire, once, after the start.</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-ConwaysGameOfLifeExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-ConwaysGameOfLifeExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-ConwaysGameOfLifeExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -118,7 +118,7 @@
use.</para>
<para>All the <code>Cell</code> objects are inserted into the Session
- and the rules in the <kw>ruleflow-group</kw> "register neighbor" are
+ and the rules in the <literal>ruleflow-group</literal> "register neighbor" are
allowed to execute by the Rule Flow process. This group of four rules
creates <code>Neighbor</code> relations between some cell and its
northeastern, northern, northwestern and western neighbors. This
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-FibonacciExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-FibonacciExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-FibonacciExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -11,7 +11,7 @@
<emphasis role="bold">Type:</emphasis> Java application
<emphasis role="bold">Rules file:</emphasis> Fibonacci.drl
<emphasis role="bold">Objective:</emphasis> Demonstrates Recursion,
- the CE <kw>not</kw> and cross product matching</screen>
+ the CE <literal>not</literal> and cross product matching</screen>
<para>The Fibonacci Numbers (see <ulink url="http://en.wikipedia.org/wiki/Fibonacci_number">http://en.wikipedia.org/wiki/Fibonacci_number</ulink>)
discovered by Leonardo of Pisa (see <ulink url="http://en.wikipedia.org/wiki/Fibonacci">http://en.wikipedia.org/wiki/Fibonacci</ulink>) is a sequence
@@ -91,7 +91,7 @@
to insert the other 49 <code>Fibonacci</code> objects. This example
doesn't use
<code>PropertyChangeSupport</code>. It uses the MVEL dialect, which
- means we can use the <kw>modify</kw> keyword, which allows a block
+ means we can use the <literal>modify</literal> keyword, which allows a block
setter action which also notifies the engine of changes.</para>
<example>
@@ -107,7 +107,7 @@
one less than the currently matched object. Each time a Fibonacci
object is added while the one with a sequence field equal to 1
does not exist, the rule re-matches and fires again. The
- <kw>not</kw> conditional element is used to stop the rule's matching
+ <literal>not</literal> conditional element is used to stop the rule's matching
once we have all 50 Fibonacci objects in memory. The rule also has a
salience value, because we need to have all 50 <code>Fibonacci</code>
objects asserted before we execute the Bootstrap rule.</para>
@@ -177,7 +177,7 @@
<para>When a <code>Fibonacci</code> object with a sequence of 1 is
asserted the Bootstrap rule is matched again, causing two activations
for this rule. Note that the "Recurse" rule does not match and activate
- because the <kw>not</kw> conditional element stops the rule's matching
+ because the <literal>not</literal> conditional element stops the rule's matching
as soon as a <code>Fibonacci</code> object with a sequence of 1
exists.</para>
@@ -235,7 +235,7 @@
</programlisting>
</example>
- <para>The <kw>modify</kw> statement updated the value of the
+ <para>The <literal>modify</literal> statement updated the value of the
<code>Fibonacci</code> object bound to <code>f3</code>. This means
we now have another new Fibonacci object with a value not equal to -1,
which allows the "Calculate" rule to rematch and calculate the next
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HelloWorldExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HelloWorldExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HelloWorldExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -189,20 +189,20 @@
[AfterActivationFired(4): rule=Good Bye] </programlisting>
</example>
- <para>The LHS (after <kw>when</kw>) section of the rule states that it will be
+ <para>The LHS (after <literal>when</literal>) section of the rule states that it will be
activated for each <code>Message</code> object inserted into the Working
Memory whose status is <code>Message.HELLO</code>. Besides that, two
variable bindings are created: the variable <code>message</code> is bound
to the <code>message</code> attribute and the variable <code>m</code>
is bound to the matched <code>Message</code> object itself.</para>
- <para>The RHS (after <kw>then</kw>) or consequence part of the rule is
+ <para>The RHS (after <literal>then</literal>) or consequence part of the rule is
written using the MVEL expression language, as declared by
the rule's attribute <code>dialect</code>. After printing the content of
the bound variable <code>message</code> to <code>System.out</code>,
the rule changes the values of the <code>message</code> and
<code>status</code> attributes of the <code>Message</code> object
- bound to <code>m</code>. This is done MVEL's <kw>modify</kw> statement,
+ bound to <code>m</code>. This is done MVEL's <literal>modify</literal> statement,
which allows you to apply a block of assignments in one statement, with the
engine being automatically notified of the changes at the end of the
block.</para>
@@ -221,7 +221,7 @@
end</programlisting>
</example>
- <para>We can set a breakpoint into the DRL, on the <kw>modify</kw>
+ <para>We can set a breakpoint into the DRL, on the <literal>modify</literal>
call, and inspect the Agenda view again during the execution of the
rule's consequence. This time we start the execution via "Debug As"
and "Drools application" and not by running a "Java application":</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HonestPoliticianExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HonestPoliticianExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-HonestPoliticianExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -119,7 +119,7 @@
</example>
<para>With the <code>Hope</code> object being automatically retracted,
- via the truth maintenance system, the conditional element <kw>not</kw>
+ via the truth maintenance system, the conditional element <literal>not</literal>
applied to <code>Hope</code> is no longer true so that the following
rule will match and fire.</para>
@@ -149,7 +149,7 @@
<para>The moment we insert the first politician we have two activations.
The rule "We have an honest Politician" is activated only once for the first
- inserted politician because it uses an <kw>exists</kw> conditional
+ inserted politician because it uses an <literal>exists</literal> conditional
element, which matches once for any number. The rule "Hope is Dead" is
also activated at this stage, because we have not yet inserted the
<code>Hope</code> object. Rule "We have an honest Politician" fires first,
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-MannersExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-MannersExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-MannersExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -177,7 +177,7 @@
</listitem>
<listitem>
- <para>It's possible to change the <kw>not</kw> Conditional
+ <para>It's possible to change the <literal>not</literal> Conditional
Element so that the test algorithm only uses the
"first-best-match", which is, basically, transforming
the test algorithm to backward chaining. The results are only
@@ -198,7 +198,7 @@
<listitem>
<para>If no facts are retracted in the reasoning cycle, as a
- result of the <kw>not</kw> CE, the port is incorrect.</para>
+ result of the <literal>not</literal> CE, the port is incorrect.</para>
</listitem>
</itemizedlist>
</section>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-NumberGuessExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-NumberGuessExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-NumberGuessExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -143,7 +143,7 @@
a Rule Flow Groups defined in our rules (DRL) file that we will
look at later. For example, when the flow reaches the Rule Flow Group
"Too High", only those rules marked with an attribute of
- <kw>ruleflow-group</kw> <code>"Too High"</code> can potentially fire.</para>
+ <literal>ruleflow-group</literal> <code>"Too High"</code> can potentially fire.</para>
</listitem>
<listitem>
@@ -168,7 +168,7 @@
<para>The various nodes in combination with the rules make the
Number Guess game work. For example, the "Guess" Rule Flow Group
allows only the rule "Get user Guess" to fire, because only that rule
- has a matching attribute of <kw>ruleflow-group</kw> <code>"Guess"</code>.</para>
+ has a matching attribute of <literal>ruleflow-group</literal> <code>"Guess"</code>.</para>
<example>
<title>A Rule firing only at a specific point in the Rule Flow:
@@ -195,13 +195,13 @@
</example>
<para>The rest of this rule is fairly standard. The LHS section
- (after <kw>when</kw>) of the rule states that it will be activated
+ (after <literal>when</literal>) of the rule states that it will be activated
for each <code>RandomNumber</code> object inserted into the Working
Memory where <code>guessCount</code> is less than
<code>allowedGuesses</code> from the <code>GameRules</code> object
and where the user has not guessed the correct number.</para>
- <para>The RHS section (or consequence, after <kw>then</kw>) prints a
+ <para>The RHS section (or consequence, after <literal>then</literal>) prints a
message to the user and then awaits user input from
<code>System.in</code>. After obtaining this input (the
<code>readLine()</code> method call blocks until the return key is
@@ -237,7 +237,7 @@
</orderedlist>
<para>One point of integration between the standard Rules and
- the RuleFlow is via the <kw>ruleflow-group</kw> attribute on the
+ the RuleFlow is via the <literal>ruleflow-group</literal> attribute on the
rules, as dicussed above. A
<emphasis>second point of integration between the rules (.drl) file
and the Rules Flow .rf files</emphasis> is
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-PetStoreExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-PetStoreExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-PetStoreExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -291,7 +291,7 @@
<para>We'll see the rules that call these functions later on. The
next set of examples are from the Pet Store rules themselves. The
first extract is the one that happens to fire first, partly because
- it has the <kw>auto-focus</kw> attribute set to true.</para>
+ it has the <literal>auto-focus</literal> attribute set to true.</para>
<example>
<title>Putting items into working memory: extract from PetStore.drl</title>
@@ -322,15 +322,15 @@
<itemizedlist>
<listitem>
- <para><kw>agenda-group</kw> <code>"init"</code> defines the name
+ <para><literal>agenda-group</literal> <code>"init"</code> defines the name
of the agenda group. In this case, there is only one rule in the
group. However, neither the Java code nor a rule consequence sets
the focus to this group, and therefore it relies on the next
- attibute for its chance to fire.</para>
+ attribute for its chance to fire.</para>
</listitem>
<listitem>
- <para><kw>auto-focus</kw> <code>true</code> ensures that this rule,
+ <para><literal>auto-focus</literal> <code>true</code> ensures that this rule,
while being the only rule in the agenda group, gets a chance to fire
when <code>fireAllRules()</code> is called from the Java code.</para>
</listitem>
@@ -620,7 +620,7 @@
<listitem>
<para>The <code>"Explode Cart"</code> rule is the first to fire,
- given that it has <kw>auto-focus</kw> set to true. It loops through
+ given that it has <literal>auto-focus</literal> set to true. It loops through
all the products in the cart, ensures that the products are in the
Working Memory, and then gives the <code>"Show Items"</code> and
<code>Evaluation</code> agenda groups a chance to fire. The rules
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-SodukiExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-SodukiExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-SodukiExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -316,9 +316,9 @@
this case so that the GUI can display the new state of the grid.</para>
<para>Rule #2 identifies cells in the grid which have only one possible
- value. The first line of the <kw>when</kw> clause matches all of the
+ value. The first line of the <literal>when</literal> clause matches all of the
<code>PossibleCellValue</code> objects in the Working Memory. The
- second line demonstrates a use of the <kw>not</kw> keyword. This rule
+ second line demonstrates a use of the <literal>not</literal> keyword. This rule
will only fire if no other <code>PossibleCellValue</code> objects
exist in the Working Memory at the same
row and column but with a different value. When the rule fires, the
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-StateExample.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-StateExample.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Examples/Section-StateExample.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -246,11 +246,11 @@
documentation, in order for the engine to see and react to changes of
fact properties, the application must tell the engine that changes
occurred. This can be done explicitly in the rules by using the
- <kw>modify</kw> statement, or implicitly by letting the engine know
+ <literal>modify</literal> statement, or implicitly by letting the engine know
that the facts implement <code>PropertyChangeSupport</code> as defined
by the <emphasis>JavaBeans specification</emphasis>. This example
demonstrates how to use <code>PropertyChangeSupport</code> to avoid
- the need for explicit <kw>modify</kw> statements in the rules. To
+ the need for explicit <literal>modify</literal> statements in the rules. To
make use of this feature, ensure that your facts implement
<code>PropertyChangeSupport</code>, the same way the class
<code>org.drools.example.State</code> does, and use the following
@@ -300,7 +300,7 @@
a Working Memory has its focus on the Agenda group "MAIN". A group's
rules will only fire when the group receives the focus. This can be
achieved either ny using the method by <code>setFocus()</code> or the
- rule attribute <kw>auto-focus</kw>. "auto-focus" means that the rule
+ rule attribute <literal>auto-focus</literal>. "auto-focus" means that the rule
automatically sets the focus to its agenda group when the rule is
matched and activated. It is this "auto-focus" that enables rule
"B to C" to fire before "B to D".</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-ErrorMessages.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-ErrorMessages.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-ErrorMessages.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -247,7 +247,7 @@
</itemizedlist>
<para>The <emphasis role="bold">fdsfdsfds</emphasis> text is invalid and
- the parser couldn’t identify it as the soft keyword <kw>rule</kw>.</para>
+ the parser couldn’t identify it as the soft keyword <literal>rule</literal>.</para>
<tip>
<para>This error is very similar to 102: Mismatched input, but usually
@@ -258,7 +258,7 @@
<section>
<title>104: Trailing semi-colon not allowed</title>
- <para>This error is associated with the <kw>eval</kw> clause, where its
+ <para>This error is associated with the <literal>eval</literal> clause, where its
expression may not be terminated with a semicolon. Check this
example:</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Function.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Function.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Function.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -22,7 +22,7 @@
for you behind the scenes.) The main advantage of using functions in a rule
is that you can keep the logic all in one place, and you can change the
functions as needed (which can be a good or a bad thing). Functions are most
- useful for invoking actions on the consequence (<kw>then</kw>) part of a rule,
+ useful for invoking actions on the consequence (<literal>then</literal>) part of a rule,
especially if that particular action is used over and over again, perhaps
with only differing parameters for each rule.</para>
@@ -33,7 +33,7 @@
}
</programlisting>
- <para>Note that the <kw>function</kw> keyword is used, even though its not really
+ <para>Note that the <literal>function</literal> keyword is used, even though its not really
part of Java. Parameters to the function are defined as for a method, and
you don't have to have parameters if they are not needed. The return type
is defined just like in a regular method.</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Keywords.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Keywords.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Keywords.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -24,39 +24,39 @@
<itemizedlist>
<listitem>
- <para><kw>true</kw></para>
+ <para><literal>true</literal></para>
</listitem>
<listitem>
- <para><kw>false</kw></para>
+ <para><literal>false</literal></para>
</listitem>
<listitem>
- <para><kw>accumulate</kw></para>
+ <para><literal>accumulate</literal></para>
</listitem>
<listitem>
- <para><kw>collect</kw></para>
+ <para><literal>collect</literal></para>
</listitem>
<listitem>
- <para><kw>from</kw></para>
+ <para><literal>from</literal></para>
</listitem>
<listitem>
- <para><kw>null</kw></para>
+ <para><literal>null</literal></para>
</listitem>
<listitem>
- <para><kw>over</kw></para>
+ <para><literal>over</literal></para>
</listitem>
<listitem>
- <para><kw>then</kw></para>
+ <para><literal>then</literal></para>
</listitem>
<listitem>
- <para><kw>when</kw></para>
+ <para><literal>when</literal></para>
</listitem>
</itemizedlist>
@@ -66,143 +66,143 @@
<itemizedlist>
<listitem>
- <para><kw>lock-on-active</kw></para>
+ <para><literal>lock-on-active</literal></para>
</listitem>
<listitem>
- <para><kw>date-effective</kw></para>
+ <para><literal>date-effective</literal></para>
</listitem>
<listitem>
- <para><kw>date-expires</kw></para>
+ <para><literal>date-expires</literal></para>
</listitem>
<listitem>
- <para><kw>no-loop</kw></para>
+ <para><literal>no-loop</literal></para>
</listitem>
<listitem>
- <para><kw>auto-focus</kw></para>
+ <para><literal>auto-focus</literal></para>
</listitem>
<listitem>
- <para><kw>activation-group</kw></para>
+ <para><literal>activation-group</literal></para>
</listitem>
<listitem>
- <para><kw>agenda-group</kw></para>
+ <para><literal>agenda-group</literal></para>
</listitem>
<listitem>
- <para><kw>ruleflow-group</kw></para>
+ <para><literal>ruleflow-group</literal></para>
</listitem>
<listitem>
- <para><kw>entry-point</kw></para>
+ <para><literal>entry-point</literal></para>
</listitem>
<listitem>
- <para><kw>duration</kw></para>
+ <para><literal>duration</literal></para>
</listitem>
<listitem>
- <para><kw>package</kw></para>
+ <para><literal>package</literal></para>
</listitem>
<listitem>
- <para><kw>import</kw></para>
+ <para><literal>import</literal></para>
</listitem>
<listitem>
- <para><kw>dialect</kw></para>
+ <para><literal>dialect</literal></para>
</listitem>
<listitem>
- <para><kw>salience</kw></para>
+ <para><literal>salience</literal></para>
</listitem>
<listitem>
- <para><kw>enabled</kw></para>
+ <para><literal>enabled</literal></para>
</listitem>
<listitem>
- <para><kw>attributes</kw></para>
+ <para><literal>attributes</literal></para>
</listitem>
<listitem>
- <para><kw>rule</kw></para>
+ <para><literal>rule</literal></para>
</listitem>
<listitem>
- <para><kw>extend</kw></para>
+ <para><literal>extend</literal></para>
</listitem>
<listitem>
- <para><kw>template</kw></para>
+ <para><literal>template</literal></para>
</listitem>
<listitem>
- <para><kw>query</kw></para>
+ <para><literal>query</literal></para>
</listitem>
<listitem>
- <para><kw>declare</kw></para>
+ <para><literal>declare</literal></para>
</listitem>
<listitem>
- <para><kw>function</kw></para>
+ <para><literal>function</literal></para>
</listitem>
<listitem>
- <para><kw>global</kw></para>
+ <para><literal>global</literal></para>
</listitem>
<listitem>
- <para><kw>eval</kw></para>
+ <para><literal>eval</literal></para>
</listitem>
<listitem>
- <para><kw>not</kw></para>
+ <para><literal>not</literal></para>
</listitem>
<listitem>
- <para><kw>in</kw></para>
+ <para><literal>in</literal></para>
</listitem>
<listitem>
- <para><kw>or</kw></para>
+ <para><literal>or</literal></para>
</listitem>
<listitem>
- <para><kw>and</kw></para>
+ <para><literal>and</literal></para>
</listitem>
<listitem>
- <para><kw>exists</kw></para>
+ <para><literal>exists</literal></para>
</listitem>
<listitem>
- <para><kw>forall</kw></para>
+ <para><literal>forall</literal></para>
</listitem>
<listitem>
- <para><kw>action</kw></para>
+ <para><literal>action</literal></para>
</listitem>
<listitem>
- <para><kw>reverse</kw></para>
+ <para><literal>reverse</literal></para>
</listitem>
<listitem>
- <para><kw>result</kw></para>
+ <para><literal>result</literal></para>
</listitem>
<listitem>
- <para><kw>end</kw></para>
+ <para><literal>end</literal></para>
</listitem>
<listitem>
- <para><kw>init</kw></para>
+ <para><literal>init</literal></para>
</listitem>
</itemizedlist>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Package.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Package.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Package.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -25,7 +25,7 @@
up a package. Note that a package <emphasis>must</emphasis> have a namespace and be declared
using standard Java conventions for package names; i.e., no spaces, unlike
rule names which allow spaces. In terms of the order of elements, they can
- appear in any order in the rule file, with the exception of the <kw>package</kw>
+ appear in any order in the rule file, with the exception of the <literal>package</literal>
statement, which must be at the top of the file. In all cases, the semicolons are
optional.</para>
@@ -80,7 +80,7 @@
</mediaobject>
</figure>
- <para>With <kw>global</kw> you define global variables. They are used to make
+ <para>With <literal>global</literal> you define global variables. They are used to make
application objects available to the rules. Typically, they are used
to provide data or services that the rules use, especially application
services used in rule consequences, and to return data from the rules,
@@ -130,8 +130,8 @@
<para>Note that these are just named instances of objects that you pass in
from your application to the working memory. This means you can pass in
any object you want: you could pass in a service locator, or perhaps a
- service itself. With the new <kw>from</kw> element it is now common to pass a
- Hibernate session as a global, to allow <kw>from</kw> to pull data from a named
+ service itself. With the new <literal>from</literal> element it is now common to pass a
+ Hibernate session as a global, to allow <literal>from</literal> to pull data from a named
Hibernate query.</para>
<para>One example may be an instance of a Email service. In your
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Rule.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Rule.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-Rule.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -38,9 +38,9 @@
<para>Attributes - described below - are optional. They are best written
one per line.</para>
- <para>The LHS of the rule follows the <kw>when</kw> keyword (ideally on a new
- line), similarly the RHS follows the <kw>then</kw> keyword (again, ideally on
- a newline). The rule is terminated by the keyword <kw>end</kw>. Rules cannot
+ <para>The LHS of the rule follows the <literal>when</literal> keyword (ideally on a new
+ line), similarly the RHS follows the <literal>then</literal> keyword (again, ideally on
+ a newline). The rule is terminated by the keyword <literal>end</literal>. Rules cannot
be nested.</para>
<example>
@@ -92,7 +92,7 @@
<variablelist>
<varlistentry>
- <term><kw>no-loop</kw></term>
+ <term><literal>no-loop</literal></term>
<listitem>
<para>default value: false</para>
@@ -108,7 +108,7 @@
</varlistentry>
<varlistentry>
- <term><kw>ruleflow-group</kw></term>
+ <term><literal>ruleflow-group</literal></term>
<listitem>
<para>default value: N/A</para>
@@ -123,7 +123,7 @@
</varlistentry>
<varlistentry>
- <term><kw>lock-on-active</kw></term>
+ <term><literal>lock-on-active</literal></term>
<listitem>
<para>default value: false</para>
@@ -147,7 +147,7 @@
</varlistentry>
<varlistentry>
- <term><kw>salience</kw></term>
+ <term><literal>salience</literal></term>
<listitem>
<para>default value : 0</para>
@@ -164,7 +164,7 @@
<varlistentry>
- <term><kw>agenda-group</kw></term>
+ <term><literal>agenda-group</literal></term>
<listitem>
<para>default value: MAIN</para>
@@ -178,7 +178,7 @@
</varlistentry>
<varlistentry>
- <term><kw>auto-focus</kw></term>
+ <term><literal>auto-focus</literal></term>
<listitem>
<para>default value: false</para>
@@ -193,7 +193,7 @@
</varlistentry>
<varlistentry>
- <term><kw>activation-group</kw></term>
+ <term><literal>activation-group</literal></term>
<listitem>
<para>default value: N/A</para>
@@ -212,7 +212,7 @@
</varlistentry>
<varlistentry>
- <term><kw>dialect</kw></term>
+ <term><literal>dialect</literal></term>
<listitem>
<para>default value: as specified by the package</para>
@@ -231,7 +231,7 @@
<varlistentry>
- <term><kw>date-effective</kw></term>
+ <term><literal>date-effective</literal></term>
<listitem>
<para>default value: N/A</para>
@@ -244,7 +244,7 @@
</varlistentry>
<varlistentry>
- <term><kw>date-expires</kw></term>
+ <term><literal>date-expires</literal></term>
<listitem>
<para>default value: N/A</para>
@@ -257,7 +257,7 @@
</varlistentry>
<varlistentry>
- <term><kw>duration</kw></term>
+ <term><literal>duration</literal></term>
<listitem>
<para>default value: no default value</para>
@@ -320,11 +320,11 @@
</example>
<para>Conditional elements work on one or more <emphasis>patterns</emphasis> (which are
- described below). The most common one is <kw>and</kw>, which is implicit when you
+ described below). The most common one is <literal>and</literal>, which is implicit when you
have multiple patterns in the LHS of a rule that are not connected in
- any way. Note that an <kw>and</kw> cannot have a leading declaration binding like
- <kw>or</kw>. This is obvious, since a declaration can only
- reference a single fact, and when the <kw>and</kw> is satisfied it matches more
+ any way. Note that an <literal>and</literal> cannot have a leading declaration binding like
+ <literal>or</literal>. This is obvious, since a declaration can only
+ reference a single fact, and when the <literal>and</literal> is satisfied it matches more
than one fact - so which fact would the declaration bind to?</para>
<section>
@@ -625,7 +625,7 @@
</figure>
<para>You can do checks against fields that are or may be null, using
- '==' and '!=' as you would expect, and the literal <kw>null</kw> keyword, as
+ '==' and '!=' as you would expect, and the literal <literal>null</literal> keyword, as
in <code>Cheese(type != null)</code>, where the evaluator will not
throw an exception and return true if the value is null.
Type coercion is always attempted if the field and the value are
@@ -672,14 +672,14 @@
<para>The operators '==' and '!=' are valid for all types. Other
relational operatory may be used whenever the type values are
- ordered; for date fields, '<' means "before". The pair <kw>matches</kw> and
- <kw>not matches</kw> is only applicable to string fields, <kw>contains</kw> and
- <kw>not contains</kw> require the field to be of some Collection type.
+ ordered; for date fields, '<' means "before". The pair <literal>matches</literal> and
+ <literal>not matches</literal> is only applicable to string fields, <literal>contains</literal> and
+ <literal>not contains</literal> require the field to be of some Collection type.
Coercion to the correct value for the evaluator and the field will be
attempted, as mentioned in the "Values" section.</para>
<simplesect>
- <title>The Operator <kw>matches</kw></title>
+ <title>The Operator <literal>matches</literal></title>
<para>Matches a field against any valid Java <indexterm>
<primary>regular expression</primary>
@@ -697,10 +697,10 @@
</simplesect>
<simplesect>
- <title>The Operator <kw>not matches</kw></title>
+ <title>The Operator <literal>not matches</literal></title>
<para>The operator returns true if the string does not match the
- regular expression. The same rules apply as for the <kw>matches</kw> operator.
+ regular expression. The same rules apply as for the <literal>matches</literal> operator.
Example:</para>
<example>
@@ -711,9 +711,9 @@
</simplesect>
<simplesect>
- <title>The Operator <kw>contains</kw></title>
+ <title>The Operator <literal>contains</literal></title>
- <para>The operator <kw>contains</kw> is used to check whether a
+ <para>The operator <literal>contains</literal> is used to check whether a
field that is a <indexterm>
<primary>Collection</primary>
</indexterm>Collection or array contains the specified
@@ -728,9 +728,9 @@
</simplesect>
<simplesect>
- <title>The Operator <kw>not contains</kw></title>
+ <title>The Operator <literal>not contains</literal></title>
- <para>The operator <kw>not contains</kw> is used to check whether a
+ <para>The operator <literal>not contains</literal> is used to check whether a
field that is a <indexterm>
<primary>Collection</primary>
</indexterm>Collection or array does <emphasis>not</emphasis> contain the
@@ -744,15 +744,15 @@
</example>
<blockquote>
- <note><para>For backward compatibility, the <kw>excludes</kw>
- operator is supported as a synonym for <kw>not contains</kw>.</para></note>
+ <note><para>For backward compatibility, the <literal>excludes</literal>
+ operator is supported as a synonym for <literal>not contains</literal>.</para></note>
</blockquote>
</simplesect>
<simplesect>
- <title>The Operator <kw>memberOf</kw></title>
+ <title>The Operator <literal>memberOf</literal></title>
- <para>The operator <kw>memberOf</kw> is used to check whether a field is a
+ <para>The operator <literal>memberOf</literal> is used to check whether a field is a
member of a collection or array; that collection must be a variable.</para>
<example>
@@ -763,9 +763,9 @@
</simplesect>
<simplesect>
- <title>The Operator <kw>not memberOf</kw></title>
+ <title>The Operator <literal>not memberOf</literal></title>
- <para>The operator <kw>not memberOf</kw> is used to check whether a
+ <para>The operator <literal>not memberOf</literal> is used to check whether a
field is not a
member of a collection or array; that collection must be a variable.</para>
@@ -777,9 +777,9 @@
</simplesect>
<simplesect>
- <title>The Operator <kw>soundslike</kw></title>
+ <title>The Operator <literal>soundslike</literal></title>
- <para>This operator is similar to <kw>matches</kw>, but it checks
+ <para>This operator is similar to <literal>matches</literal>, but it checks
whether a word has almost the same sound (using English pronounciation)
as the given value. This is based on the Soundex algorithm
(see <code>http://en.wikipedia.org/wiki/Soundex</code>).</para>
@@ -967,8 +967,8 @@
<title>Compound Value Restriction</title>
<para>The compound value restriction is used where there is more
- than one possible value to match. Currently only the <kw>in</kw> and
- <kw>not in</kw> evaluators support this. The second operand of this operator must be
+ than one possible value to match. Currently only the <literal>in</literal> and
+ <literal>not in</literal> evaluators support this. The second operand of this operator must be
a comma-separated list of values, enclosed in parentheses. Values may
be given as variables, literals, return values or qualified identifiers.
Both evaluators are actually "syntactic sugar", internally rewritten as
@@ -1095,7 +1095,7 @@
you wish to modify a nested value you should remove the parent objects
first and re-assert afterwards. If you only have a single parent at
the root of the graph, when in the MVEL dialect, you can use the
- <kw>modify</kw> construct and its block setters to write the nested accessor
+ <literal>modify</literal> construct and its block setters to write the nested accessor
assignments while retracting and inserting the the root parent object
as required. Nested accessors can be used on either side of the operator
symbol.</para>
@@ -1120,12 +1120,12 @@
</section>
<section>
- <title>Conditional Element <kw>and</kw></title>
+ <title>Conditional Element <literal>and</literal></title>
- <para>The Conditional Element <kw>and</kw> is used to group other Conditional
+ <para>The Conditional Element <literal>and</literal> is used to group other Conditional
Elements into a logical conjunction. The root element of the LHS is an
- implicit prefix <kw>and</kw> and doesn't need to be specified. Drools supports
- both prefix <kw>and</kw> and infix <kw>and</kw>, but prefix is the preferred option
+ implicit prefix <literal>and</literal> and doesn't need to be specified. Drools supports
+ both prefix <literal>and</literal> and infix <literal>and</literal>, but prefix is the preferred option
as its implicit grouping avoids confusion.</para>
<figure>
@@ -1157,9 +1157,9 @@
Person( favouriteCheese == cheeseType )</programlisting>
</example>
- <para>Infix <kw>and</kw> is supported along with explicit grouping with
+ <para>Infix <literal>and</literal> is supported along with explicit grouping with
parentheses, should it be needed. The symbol '&&', as an
- alternative to <kw>and</kw>, is deprecated although it is still supported in
+ alternative to <literal>and</literal>, is deprecated although it is still supported in
the syntax for legacy support reasons.</para>
<figure>
@@ -1186,17 +1186,17 @@
</section>
<section>
- <title>Conditional Element <kw>or</kw></title>
+ <title>Conditional Element <literal>or</literal></title>
- <para>The Conditional Element <kw>or</kw> is used to group other Conditional
- Elements into a logical disjunction. Drools supports both prefix <kw>or</kw> and
- infix <kw>or</kw>, but prefix is the preferred option as its implicit grouping
- avoids confusion. The behavior of the Conditional Element <kw>or</kw> is different
+ <para>The Conditional Element <literal>or</literal> is used to group other Conditional
+ Elements into a logical disjunction. Drools supports both prefix <literal>or</literal> and
+ infix <literal>or</literal>, but prefix is the preferred option as its implicit grouping
+ avoids confusion. The behavior of the Conditional Element <literal>or</literal> is different
from the connective '||' for constraints and restrictions in field
constraints. The engine actually has no understanding of the Conditional
- Element <kw>or</kw>; instead, via a number of different logic transformations,
- a rule with <kw>or</kw> is rewritten as a number of subrules. This process ultimately
- results in a rule that has a single <kw>or</kw> as the root node and one subrule
+ Element <literal>or</literal>; instead, via a number of different logic transformations,
+ a rule with <literal>or</literal> is rewritten as a number of subrules. This process ultimately
+ results in a rule that has a single <literal>or</literal> as the root node and one subrule
for each of its CEs. Each subrule can activate and fire like any normal rule;
there is no special behavior or interaction between these subrules. - This can
be most confusing to new rule authors.</para>
@@ -1220,9 +1220,9 @@
</programlisting>
</example>
- <para>Infix <kw>or</kw> is supported along with explicit grouping with
+ <para>Infix <literal>or</literal> is supported along with explicit grouping with
parentheses, should it be needed. The symbol '||', as an alternative to
- <kw>or</kw>, is deprecated although it is still supported in the syntax for
+ <literal>or</literal>, is deprecated although it is still supported in the syntax for
legacy support reasons.</para>
<figure>
@@ -1247,7 +1247,7 @@
Person( favouriteCheese == cheeseType ) )</programlisting>
</example>
- <para>The Conditional Element <kw>or</kw> also allows for optional pattern
+ <para>The Conditional Element <literal>or</literal> also allows for optional pattern
binding. This means that each resulting subrule will bind its pattern to
the pattern binding. Each pattern must be bound separately,
using eponymous variables:</para>
@@ -1259,13 +1259,13 @@
pensioner : Person( sex == "m", age > 65 ) )</programlisting>
</example>
- <para>Since the conditional element <kw>or</kw> results in multiple subrule
+ <para>Since the conditional element <literal>or</literal> results in multiple subrule
generation, one for each possible logically outcome, the example above
would result in the internal generation of two rules. These two rules
work independently within the Working Memory, which means both can
match, activate and fire - there is no shortcutting.</para>
- <para>The best way to think of the conditional element <kw>or</kw> is as a
+ <para>The best way to think of the conditional element <literal>or</literal> is as a
shortcut for generating two or more similar rules. When you think
of it that
way, it's clear that for a single rule there could be multiple
@@ -1273,7 +1273,7 @@
</section>
<section>
- <title>Conditional Element <kw>eval</kw></title>
+ <title>Conditional Element <literal>eval</literal></title>
<figure>
<title>eval</title>
@@ -1285,11 +1285,11 @@
</mediaobject>
</figure>
- <para>The CE <kw>eval</kw> is essentially a catch-all which allows any semantic code
+ <para>The CE <literal>eval</literal> is essentially a catch-all which allows any semantic code
(that returns a primitive boolean) to be executed. This code can refer to
variables that were bound in the LHS of the rule, and functions in the
rule package. Overuse of eval reduces the declarativeness of your rules
- and can result in a poorly performing engine. While <kw>eval</kw> can be used
+ and can result in a poorly performing engine. While <literal>eval</literal> can be used
anywhere in the patterns, the best practice is to add it as the last
conditional element in the LHS of a rule.</para>
@@ -1314,7 +1314,7 @@
</section>
<section>
- <title>Conditional Element <kw>not</kw></title>
+ <title>Conditional Element <literal>not</literal></title>
<figure>
<title>not</title>
@@ -1327,11 +1327,11 @@
</mediaobject>
</figure>
- <para>The CE <kw>not</kw> is first order logic's non-existential quantifier and checks
+ <para>The CE <literal>not</literal> is first order logic's non-existential quantifier and checks
for the non-existence of something in the Working Memory. Think of "not"
as meaning "there must be none of...".</para>
- <para>The keyword <kw>not</kw> be followed by parentheses around the CEs
+ <para>The keyword <literal>not</literal> be followed by parentheses around the CEs
that it applies to. In the simplest case of a single pattern (like
below) you may optionally omit the parentheses.</para>
@@ -1348,7 +1348,7 @@
not Bus(color == "red")
// Brackets are optional:
not ( Bus(color == "red", number == 42) )
-// "not" with nested infix <kw>and</kw> - two patterns,
+// "not" with nested infix <literal>and</literal> - two patterns,
// brackets are requires:
not ( Bus(color == "red") and
Bus(color == "blue") )</programlisting>
@@ -1356,7 +1356,7 @@
</section>
<section>
- <title>Conditional Element <kw>exists</kw></title>
+ <title>Conditional Element <literal>exists</literal></title>
<figure>
<title>exists</title>
@@ -1369,16 +1369,16 @@
</mediaobject>
</figure>
- <para>The CE <kw>exists</kw> is first order logic's existential quantifier and checks
+ <para>The CE <literal>exists</literal> is first order logic's existential quantifier and checks
for the existence of something in the Working Memory. Think of "exists" as
meaning "there is at least one..". It is different from just having the pattern
on its own, which is more like saying "for each one of...". If you use
- <kw>exists</kw> with a pattern, the rule will only activate at most once, regardless
+ <literal>exists</literal> with a pattern, the rule will only activate at most once, regardless
of how much data there is in working memory that matches the
- condition inside of the <kw>exists</kw> pattern. Since only the existence matters,
+ condition inside of the <literal>exists</literal> pattern. Since only the existence matters,
no bindings will be established.</para>
- <para>The keyword <kw>exists</kw> must be followed by parentheses around the
+ <para>The keyword <literal>exists</literal> must be followed by parentheses around the
CEs that it applies to. In the simplest case of a single pattern (like
below) you may optionally omit the parentheses.</para>
@@ -1394,7 +1394,7 @@
<programlisting>exists Bus(color == "red")
// brackets are optional:
exists ( Bus(color == "red", number == 42) )
-// "exists" with nested infix <kw>and</kw>,
+// "exists" with nested infix <literal>and</literal>,
// brackets are required:
exists ( Bus(color == "red") and
Bus(color == "blue") )</programlisting>
@@ -1402,7 +1402,7 @@
</section>
<section>
- <title>Conditional Element <kw>forall</kw></title>
+ <title>Conditional Element <literal>forall</literal></title>
<figure>
<title>forall</title>
@@ -1415,8 +1415,8 @@
</mediaobject>
</figure>
- <para>The Conditional Element <kw>forall</kw> completes the First Order Logic
- support in Drools. The Conditional Element <kw>forall</kw> evaluates to true
+ <para>The Conditional Element <literal>forall</literal> completes the First Order Logic
+ support in Drools. The Conditional Element <literal>forall</literal> evaluates to true
when all facts that match the first pattern match all the remaining
patterns. Example:</para>
@@ -1435,7 +1435,7 @@
true.</para>
<para>To state that all facts of a given type in the working memory must
- match a set of constraints, <kw>forall</kw> can be written with a single pattern
+ match a set of constraints, <literal>forall</literal> can be written with a single pattern
for simplicity. Example:</para>
<para><example>
@@ -1450,7 +1450,7 @@
</programlisting>
</example></para>
- <para>Another example shows multiple patterns inside the <kw>forall</kw>:<example>
+ <para>Another example shows multiple patterns inside the <literal>forall</literal>:<example>
<title>Multi-Pattern Forall</title>
<programlisting>rule "all employees have health and dental care programs"
@@ -1466,7 +1466,7 @@
</example></para>
<para>Forall can be nested inside other CEs for complete expressiveness.
- For instance, <kw>forall</kw> can be used inside a <kw>not</kw> CE. Note that only single
+ For instance, <literal>forall</literal> can be used inside a <literal>not</literal> CE. Note that only single
patterns have optional parentheses, so that with a nested forall parentheses
must be used :<example>
<title>Combining Forall with Not CE</title>
@@ -1488,14 +1488,14 @@
<programlisting>not(p1 and not(and p2 p3...))</programlisting>
- <para>Also, it is important to note that <kw>forall</kw> is a <emphasis>scope
+ <para>Also, it is important to note that <literal>forall</literal> is a <emphasis>scope
delimiter</emphasis>. Therefore, it can use any previously bound
variable, but no variable bound inside it will be available for use
outside of it.</para>
</section>
<section>
- <title>Conditional Element <kw>from</kw></title>
+ <title>Conditional Element <literal>from</literal></title>
<figure>
<title>from</title>
@@ -1507,7 +1507,7 @@
</mediaobject>
</figure>
- <para>The Conditional Element <kw>from</kw> enables users to specify an arbitrary
+ <para>The Conditional Element <literal>from</literal> enables users to specify an arbitrary
source for data to be matched by LHS patterns. This
allows the engine to reason over data not in the Working Memory. The data
source could be a sub-field on a bound variable or the results of a method
@@ -1547,8 +1547,8 @@
</programlisting></para>
<para>Previous examples were evaluations using a single pattern. The
- CE <kw>from</kw> also support object sources that return a collection of objects.
- In that case, <kw>from</kw> will iterate over all objects in the
+ CE <literal>from</literal> also support object sources that return a collection of objects.
+ In that case, <literal>from</literal> will iterate over all objects in the
collection and try to match each of them individually. For instance, if
we want a rule that applies 10% discount to each item in an order, we
could do:</para>
@@ -1565,9 +1565,9 @@
<para>The above example will cause the rule to fire once for each item
whose value is greater than 100 for each given order.</para>
- <para>You must take caution, however, when using <kw>from</kw>,
+ <para>You must take caution, however, when using <literal>from</literal>,
especially in conjunction with the
- <kw>lock-on-active</kw> rule attribute
+ <literal>lock-on-active</literal> rule attribute
as it may produce unexpected results. Consider the example provided earlier, but
now slightly modified as follows:</para>
@@ -1598,27 +1598,27 @@
will find that only the second rule fires.</para>
<para>If you were to turn on the audit log, you would also see that when the second rule fires,
- it deactivates the first rule. Since the rule attribute <kw>lock-on-active</kw>
+ it deactivates the first rule. Since the rule attribute <literal>lock-on-active</literal>
prevents a rule from creating new activations when a set of facts change, the first rule fails to
reactivate. Though the set of facts have not changed, the use of
- <kw>from</kw> returns a new fact for all intents and purposes each time
+ <literal>from</literal> returns a new fact for all intents and purposes each time
it is evaluated.
</para>
<para>First, it's important to review why you would use the above pattern. You may have
many rules across different rule-flow groups. When rules modify working memory and other rules
downstream of your RuleFlow (in different rule-flow groups) need to be reevaluated,
- the use of <kw>modify</kw> is critical. You don't, however, want other rules in the
+ the use of <literal>modify</literal> is critical. You don't, however, want other rules in the
same rule-flow group to place activations on one another recursively. In this case,
- the <kw>no-loop</kw> attribute is ineffective, as it would only prevent a rule from
- activating itself recursively. Hence, you resort to <kw>lock-on-active</kw>.</para>
+ the <literal>no-loop</literal> attribute is ineffective, as it would only prevent a rule from
+ activating itself recursively. Hence, you resort to <literal>lock-on-active</literal>.</para>
<para>
There are several ways to address this issue:</para>
<itemizedlist>
<listitem>
- <para>Avoid the use of <kw>from</kw> when you can assert all facts into working memory
+ <para>Avoid the use of <literal>from</literal> when you can assert all facts into working memory
or use nested object references in your constraint expressions (shown below).</para>
</listitem>
<listitem>
@@ -1626,13 +1626,13 @@
in your condition (LHS).</para>
</listitem>
<listitem>
- <para>Avoid the use of <kw>lock-on-active</kw> when you
+ <para>Avoid the use of <literal>lock-on-active</literal> when you
can explicitly manage how rules within the same rule-flow group place
activations on one another (explained below).</para>
</listitem>
</itemizedlist>
- <para>The preferred solution is to minimize use of <kw>from</kw> when you can assert
+ <para>The preferred solution is to minimize use of <literal>from</literal> when you can assert
all your facts into working memory directly. In the example above, both the
Person and Address instance can be asserted into working memory. In this case,
because the graph is fairly simple, an even easier solution is to modify your
@@ -1662,12 +1662,12 @@
holds one or more Addresses and you wish to use an existential quantifier to
match people with at least one address that meets certain conditions.
In this case, you would have to resort to
- the use of <kw>from</kw> to reason over the collection.</para>
+ the use of <literal>from</literal> to reason over the collection.</para>
<para>
- There are several ways to use <kw>from</kw> to achieve this and not all of them
- exhibit an issue with the use of <kw>lock-on-active</kw>.
- For example, the following use of <kw>from</kw> causes both rules to fire as
+ There are several ways to use <literal>from</literal> to achieve this and not all of them
+ exhibit an issue with the use of <literal>lock-on-active</literal>.
+ For example, the following use of <literal>from</literal> causes both rules to fire as
expected:</para>
<para><programlisting>rule "Assign people in North Carolina (NC) to sales region 1"
@@ -1718,15 +1718,15 @@
end</programlisting></para>
<para>In the above example, the $addresses variable is returned from the
- use of <kw>from</kw>. The example also introduces
+ use of <literal>from</literal>. The example also introduces
a new object, assessment, to highlight one possible solution in this case.
If the $assessment variable assigned in the condition (LHS) is moved to the last condition
in each rule, both rules fire as expected.
</para>
<para>
- Though the above examples demonstrate how to combine the use of <kw>from</kw>
- with <kw>lock-on-active</kw> where no loss of rule activations occurs, they
+ Though the above examples demonstrate how to combine the use of <literal>from</literal>
+ with <literal>lock-on-active</literal> where no loss of rule activations occurs, they
carry the drawback of placing a dependency
on the order of conditions on the LHS. In addition, the solutions present
greater complexity for the rule author in terms of keeping track of
@@ -1734,12 +1734,12 @@
<para>A better alternative is to
assert more facts into working memory. In this case, a person's addresses
- may be asserted into working memory and the use of <kw>from</kw>
+ may be asserted into working memory and the use of <literal>from</literal>
would not be necessary.</para>
<para>There are cases, however, where asserting all data into working memory is not
practical and we need to find other solutions. Another option is to reevaluate the
- need for <kw>lock-on-active</kw>. An alternative to <kw>lock-on-active</kw> is to
+ need for <literal>lock-on-active</literal>. An alternative to <literal>lock-on-active</literal> is to
directly manage how rules within the same rule-flow group activate one another
by including conditions in each rule that prevent rules from activating
each other recursively when working memory is modified. For example, in the
@@ -1750,7 +1750,7 @@
</section>
<section>
- <title>Conditional Element <kw>collect</kw></title>
+ <title>Conditional Element <literal>collect</literal></title>
<figure>
<title>collect</title>
@@ -1763,7 +1763,7 @@
</mediaobject>
</figure>
- <para>The Conditional Element <kw>collect</kw> allows rules to reason over a collection
+ <para>The Conditional Element <literal>collect</literal> allows rules to reason over a collection
of objects obtained from the given source or from the working memory. In First
Oder Logic terms this is the cardinality quantifier. A simple example:</para>
@@ -1786,7 +1786,7 @@
If 3 or more alarms are found for a given system, the rule will
fire.</para>
- <para>The result pattern of <kw>collect</kw> can
+ <para>The result pattern of <literal>collect</literal> can
be any concrete class that implements the <code>java.util.Collection</code>
interface
and provides a default no-arg public constructor. This means that you can use
@@ -1797,13 +1797,13 @@
<para>Both source and result patterns can be constrained as any other
pattern.</para>
- <para>Variables bound before the <kw>collect</kw> CE are in the scope of both source and
+ <para>Variables bound before the <literal>collect</literal> CE are in the scope of both source and
result patterns and therefore you can use them to constrain both your
- source and result patterns. But note that <kw>collect</kw> is a scope delimiter for
+ source and result patterns. But note that <literal>collect</literal> is a scope delimiter for
bindings, so that any binding made inside of it is not available for use
outside of it.</para>
- <para>Collect accepts nested <kw>from</kw> CEs. The following example is a valid
+ <para>Collect accepts nested <literal>from</literal> CEs. The following example is a valid
use of "collect":</para>
<programlisting>import java.util.LinkedList;
@@ -1822,7 +1822,7 @@
</section>
<section>
- <title>Conditional Element <kw>accumulate</kw></title>
+ <title>Conditional Element <literal>accumulate</literal></title>
<figure>
<title>accumulate</title>
@@ -1834,20 +1834,20 @@
</mediaobject>
</figure>
- <para>The Conditional Element <kw>accumulate</kw> is a more flexible and powerful
- form of <kw>collect</kw>, the sense that it can be used to do what <kw>collect</kw> does
- and also achieve things that the CE <kw>collect</kw> is not capable of doing.
+ <para>The Conditional Element <literal>accumulate</literal> is a more flexible and powerful
+ form of <literal>collect</literal>, the sense that it can be used to do what <literal>collect</literal> does
+ and also achieve things that the CE <literal>collect</literal> is not capable of doing.
Basically, what it does is that it allows a rule to iterate
over a collection of objects, executing custom actions for each of the
elements, and at the end it returns a result object.</para>
- <para>The general syntax of the <kw>accumulate</kw> CE is:</para>
+ <para>The general syntax of the <literal>accumulate</literal> CE is:</para>
- <programlisting><replaceable><result pattern></replaceable> <kw>from accumulate(</kw> <replaceable><source pattern></replaceable><kw>,</kw>
- <kw>init(</kw> <replaceable><init code></replaceable> <kw>),</kw>
- <kw>action(</kw> <replaceable><action code></replaceable> <kw>),</kw>
- <kw>reverse(</kw> <replaceable><reverse code></replaceable> <kw>),</kw>
- <kw>result(</kw> <replaceable><result expression></replaceable> <kw>) )</kw>
+ <programlisting><replaceable><result pattern></replaceable> <literal>from accumulate(</literal> <replaceable><source pattern></replaceable><literal>,</literal>
+ <literal>init(</literal> <replaceable><init code></replaceable> <literal>),</literal>
+ <literal>action(</literal> <replaceable><action code></replaceable> <literal>),</literal>
+ <literal>reverse(</literal> <replaceable><reverse code></replaceable> <literal>),</literal>
+ <literal>result(</literal> <replaceable><result expression></replaceable> <literal>) )</literal>
</programlisting>
<para>The meaning of each of the elements is the following:</para>
@@ -1893,10 +1893,10 @@
<para><emphasis><result pattern></emphasis>: this
is a regular pattern that the engine tries to match against the
object returned from the <emphasis><result expression></emphasis>.
- If it matches, the <kw>accumulate</kw> conditional element
+ If it matches, the <literal>accumulate</literal> conditional element
evaluates to <emphasis>true</emphasis> and the engine
proceeds with the evaluation of the next CE in the rule. If it does
- not matches, the <kw>accumulate</kw> CE
+ not matches, the <literal>accumulate</literal> CE
evaluates to <emphasis>false</emphasis> and the engine
stops evaluating CEs for that rule.</para>
</listitem>
@@ -1941,7 +1941,7 @@
but it is strongly recommended that the user writes it in order to benefit
from the <emphasis>improved performance on update and retract</emphasis>.</para>
- <para>The <kw>accumulate</kw> CE can be used to
+ <para>The <literal>accumulate</literal> CE can be used to
execute any action on source objects. The following example instantiates
and populates a custom object:</para>
@@ -2035,7 +2035,7 @@
line to the configuration file or set a system property to let the
engine know about the new function. As an example of an Accumulate
Function implementation, the following is the implementation of the
- <kw>average</kw> function:</para>
+ <literal>average</literal> function:</para>
<programlisting>/*
* Copyright 2007 JBoss Inc
@@ -2164,26 +2164,26 @@
memory; without having to first reference a working memory
instance.</para>
- <para><kw>update(</kw><emphasis>object, handle</emphasis><kw>);</kw>
+ <para><literal>update(</literal><emphasis>object, handle</emphasis><literal>);</literal>
will tell the engine that an object has
changed (one that has been bound to something on the LHS) and rules may
need to be reconsidered.</para>
- <para><kw>update(</kw><emphasis>object</emphasis><kw>);</kw> can
+ <para><literal>update(</literal><emphasis>object</emphasis><literal>);</literal> can
also be used; here the Knowledge Helper will look up the facthandle for you,
via an identity check, for the passed object. (Note that if you provide
Property Change Listeners to your Java beans that you are inserting into
the engine, you can avoid the need to call <code>update()</code> when the
object changes.)</para>
- <para><kw>insert(new</kw> <emphasis>Something</emphasis><kw>());</kw>
+ <para><literal>insert(new</literal> <emphasis>Something</emphasis><literal>());</literal>
will place a new object of your creation into the Working Memory.</para>
- <para><kw>insertLogical(new</kw> <emphasis>Something</emphasis><kw>());</kw>
+ <para><literal>insertLogical(new</literal> <emphasis>Something</emphasis><literal>());</literal>
is similar to insert, but the object will be automatically retracted when there are
no more facts to support the truth of the currently firing rule.</para>
- <para><kw>retract(</kw><emphasis>handle</emphasis><kw>);</kw>
+ <para><literal>retract(</literal><emphasis>handle</emphasis><literal>);</literal>
removes an object from Working Memory.</para>
<para>These convenience methods are basically macros that provide short
@@ -2293,16 +2293,16 @@
</section>
<section>
- <title>The <kw>modify</kw> Statement</title>
+ <title>The <literal>modify</literal> Statement</title>
<para>This language extension provides a structured approach to
fact updates. It combines the update operation with a number of
setter calls to change the object's fields. This is the syntax
- schema for the <kw>modify</kw> statement:</para>
+ schema for the <literal>modify</literal> statement:</para>
- <programlisting><kw>modify ( </kw><replaceable><fact-expression></replaceable><kw> ) {</kw>
- <replaceable><expression></replaceable> [ <kw>,</kw> <replaceable><expression></replaceable> ]*
-<kw>}</kw></programlisting>
+ <programlisting><literal>modify ( </literal><replaceable><fact-expression></replaceable><literal> ) {</literal>
+ <replaceable><expression></replaceable> [ <literal>,</literal> <replaceable><expression></replaceable> ]*
+<literal>}</literal></programlisting>
<para>The parenthesized <emphasis><fact-expression></emphasis> must yield
a fact object reference. The expression list in the block should consist of
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-TypeDeclaration.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-TypeDeclaration.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Language_Reference/Section-TypeDeclaration.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -59,8 +59,8 @@
<title>Declaring New Types</title>
<para>To declare a new type, all you need to do is use the keyword
- <kw>declare</kw>, followed by the list of fields, and the keyword
- <kw>end</kw>.</para>
+ <literal>declare</literal>, followed by the list of fields, and the keyword
+ <literal>end</literal>.</para>
<example>
<title>Declaring a new fact type: Address</title>
@@ -98,7 +98,7 @@
defined fact type Address.</para>
<para>You may avoid having to write the fully qualified name of a class
- every time you write it by using the <kw>import</kw> clause, as previously
+ every time you write it by using the <literal>import</literal> clause, as previously
discussed.</para>
<para><example>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Quick_Start/Section-The_Basics.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Quick_Start/Section-The_Basics.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-Quick_Start/Section-The_Basics.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -318,9 +318,9 @@
end</programlisting>
<para>Whereas the Stateless Session uses standard Java syntax to modify
- a field, in the above rule we use the <kw>modify</kw> statement, which acts as a
+ a field, in the above rule we use the <literal>modify</literal> statement, which acts as a
sort of "with" statement. It may contain a series of comma separated Java
- expressions, i.e., calls to setters of the object selected by the <kw>modify</kw>
+ expressions, i.e., calls to setters of the object selected by the <literal>modify</literal>
statement's control
expression. This modifies the data, and makes the engine aware of those changes
so it can reason over them once more. This process is called inference, and
@@ -336,7 +336,7 @@
to Propositional Logic,
where the engine is constraining against individual intances. Drools also has
support for First Order Logic that allows you to look at sets of data.
- A pattern under the keyword <kw>not</kw> matches when something does not exist.
+ A pattern under the keyword <literal>not</literal> matches when something does not exist.
The rule given below turns the sprinkler off as soon as the fire in that
room has disappeared.</para>
@@ -353,8 +353,8 @@
<para>While there is one sprinkler per room, there is just a single alarm
for the building. An <code>Alarm</code> object is created when a fire occurs,
but only one <code>Alarm</code> is needed for the entire building, no matter
- how many fires occur. Previously <kw>not</kw> was introduced to match the absence of
- a fact; now we use its complement <kw>exists</kw> which matches for one or more
+ how many fires occur. Previously <literal>not</literal> was introduced to match the absence of
+ a fact; now we use its complement <literal>exists</literal> which matches for one or more
instances of some category.</para>
<programlisting>rule "Raise the alarm when we have one or more fires"
@@ -366,7 +366,7 @@
end</programlisting>
<para>Likewise, when there are no fires we want to remove the alarm, so
- the <kw>not</kw> keyword can be used again.</para>
+ the <literal>not</literal> keyword can be used again.</para>
<programlisting>rule "Cancel the alarm when all the fires have gone"
when
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-User_Guide/Section-Running.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-User_Guide/Section-Running.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-expert/src/main/docbook/en-US/Chapter-User_Guide/Section-Running.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -104,7 +104,7 @@
<emphasis>assert</emphasis> or <emphasis>assertion</emphasis> to refer
to facts made available to the system. However, due to "assert" being
a keyword in most languages, we have decided to use the
- <kw>insert</kw> keyword; so expect to hear the two used
+ <literal>insert</literal> keyword; so expect to hear the two used
interchangeably.</para>
<!-- FIXME - I think we might want to add this sentence to the previous paragraph.
@@ -171,7 +171,7 @@
objects. The <code>update()</code> method can only be used with
objects that have shadow proxies turned on. The update method is only
available within Java code. On the right hand side of a rule, also the
- <kw>modify</kw> statement is supported, providing simplified calls to
+ <literal>modify</literal> statement is supported, providing simplified calls to
the object's setters.</para>
<programlisting>Cheese stilton = new Cheese("stilton");
@@ -1697,11 +1697,11 @@
</example>
<para><code><set-global></code> also supports two other optional
- attributes, <kw>out</kw> and <kw>out-identifier</kw>. A true value for the
- boolean <kw>out</kw> will add the global to the
+ attributes, <literal>out</literal> and <literal>out-identifier</literal>. A true value for the
+ boolean <literal>out</literal> will add the global to the
<code><batch-execution-results></code> payload, using the name from
- the <kw>identifier</kw> attribute. <kw>out-identifier</kw> works like
- <kw>out</kw> but additionally allows you to override the identifier used
+ the <literal>identifier</literal> attribute. <literal>out-identifier</literal> works like
+ <literal>out</literal> but additionally allows you to override the identifier used
in the <code><batch-execution-results></code> payload.</para>
<example>
@@ -1723,8 +1723,8 @@
</example>
<para>There is also a <code><get-global></code> element, without
- contents, with just an <kw>out-identifier</kw> attribute. (There is no
- need for an <kw>out</kw> attribute because retrieving the value is the
+ contents, with just an <literal>out-identifier</literal> attribute. (There is no
+ need for an <literal>out</literal> attribute because retrieving the value is the
sole purpose of a <code><get-global></code> element.</para>
<example>
@@ -1737,11 +1737,11 @@
</programlisting>
</example>
- <para>While the <kw>out</kw> attribute is useful in returning specific
+ <para>While the <literal>out</literal> attribute is useful in returning specific
instances as a result payload, we often wish to run actual queries. Both
- parameter and parameterless queries are supported. The <kw>name</kw>
+ parameter and parameterless queries are supported. The <literal>name</literal>
attribute is the name of the query to be called, and the
- <kw>out-identifier</kw> is the identifier to be used for the query results
+ <literal>out-identifier</literal> is the identifier to be used for the query results
in the <code><execution-results></code> payload.</para>
<example>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-Flow/Chapter-RuleFlow.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-Flow/Chapter-RuleFlow.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-Flow/Chapter-RuleFlow.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -501,7 +501,7 @@
of rules that need to be evaluated. The rules are evaluated when the node
is reached. A RuleFlowGroup node should have one incoming connection and
one outgoing connection. Rules can become part of a specific ruleflow group
- using the <kw>ruleflow-group</kw> attribute in the header. When a RuleFlowGroup node
+ using the <literal>ruleflow-group</literal> attribute in the header. When a RuleFlowGroup node
is reached in the ruleflow, the engine will start executing rules that are
part of the corresponding ruleflow-group (if any). Execution will
automatically continue to the next node if there are no more active rules in
@@ -511,7 +511,7 @@
the other rules. Note that the ruleflow will immediately continue with the
next node if it encounters a ruleflow group where there are no active rules
at that time. If the ruleflow group was already active, the ruleflow group
- will remain active and exeution will only continue if all active rules of the
+ will remain active and execution will only continue if all active rules of the
ruleflow group has been completed. It contains the following properties:</para>
<itemizedlist>
<listitem>
@@ -1595,7 +1595,7 @@
<para>To use a ruleflow to describe the order in which rules should be
evaluated, you should first group rules into ruleflow groups using the
- <kw>ruleflow-group</kw> rule attribute ("options" in the GUI). Then you
+ <literal>ruleflow-group</literal> rule attribute ("options" in the GUI). Then you
should create a ruleflow graph (which is a flow chart) that graphically
describe the order in which the rules should be considered, by specifying
the order in which the ruleflow-groups should be evaluated.</para>
Modified: labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-RulesAndProcesses/Chapter-RulesAndProcesses.xml
===================================================================
--- labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-RulesAndProcesses/Chapter-RulesAndProcesses.xml 2010-07-21 13:23:57 UTC (rev 34095)
+++ labs/jbossrules/trunk/drools-docs/drools-docs-flow/src/main/docbook/en-US/Chapter-RulesAndProcesses/Chapter-RulesAndProcesses.xml 2010-07-21 13:45:37 UTC (rev 34096)
@@ -212,12 +212,12 @@
<para>Drools Flow can easily include a set of rules as part of the process.
The rules that need to be evaluated should be grouped in a ruleflow
- group, using the <kw>ruleflow-group</kw> rule attribute. Activating a
+ group, using the <literal>ruleflow-group</literal> rule attribute. Activating a
RuleSet node for the group triggers the evaluation of these rules in your
process. This example uses two RuleSet nodes in the process: one for the
validation of the order and one for calculating the discount. For example,
one of the rules for validiting an order is shown below. Note the
- <kw>ruleflow-group</kw> attribute, which ensures that this rule is evaluated
+ <literal>ruleflow-group</literal> attribute, which ensures that this rule is evaluated
as part of the RuleSet node with the same ruleflow group shown in the
figure.</para>
<programlisting>
More information about the jboss-svn-commits
mailing list