Ejemplo

A continuación se muestra un conjunto de reglas de ejemplo:

<?xml version="1.0" encoding="UTF-8"?>
<RuleSet name="Example_externalRuleObjects"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation=
"http://www.curamsoftware.com/CreoleRulesSchema.xsd">
  <Class name="Person">

    <!-- Estos atributos se deben especificar en el momento de la creación -->
    <Initialization>
      <Attribute name="firstName">
        <type>
          <javaclass name="String"/>
        </type>
      </Attribute>

      <Attribute name="lastName">
        <type>
          <javaclass name="String"/>
        </type>
      </Attribute>
    </Initialization>

    <Attribute name="incomes">
      <type>
        <javaclass name="List">
          <ruleclass name="Income"/>
        </javaclass>
      </type>
      <derivation>
        <!-- Leer todos los objetos de regla de
              tipo "Income" -->
        <readall ruleclass="Income"/>
      </derivation>
    </Attribute>

  </Class>

  <Class name="Income">
    <Attribute name="amount">
      <type>
        <javaclass name="Number"/>
      </type>
      <derivation>
        <specified/>
      </derivation>
    </Attribute>

  </Class>

</RuleSet>

En el conjunto de reglas anterior, la expresión readall se utiliza para recuperar todas las instancia de la clase de regla Income.

Para crear un objeto de regla externa, el código de cliente o las pruebas deben especificar la sesión cuando se crea el objeto de regla:

package curam.creole.example;

import junit.framework.TestCase;
import curam.creole.calculator.CREOLETestHelper;
import curam.creole.execution.RuleObject;
import curam.creole.execution.session.InterpretedRuleObjectFactory;
import curam.creole.execution.session.RecalculationsProhibited;
import curam.creole.execution.session.Session;
import curam.creole.execution.session.Session_Factory;
import
 curam.creole.execution.session.StronglyTypedRuleObjectFactory;
import curam.creole.parser.RuleSetXmlReader;
import
 curam.creole.ruleclass.Example_externalRuleObjects.impl.Income;
import
 curam.creole.ruleclass.Example_externalRuleObjects.impl.Income_Factory;
import
 curam.creole.ruleclass.Example_externalRuleObjects.impl.Person;
import
 curam.creole.ruleclass.Example_externalRuleObjects.impl.Person_Factory;
import curam.creole.ruleitem.RuleSet;
import curam.creole.storage.inmemory.InMemoryDataStorage;

/**
 * Prueba objetos de regla externa creados directamente por el código de cliente.
 */
public class TestCreateExternalRuleObjects extends TestCase {

  /**
   * Ejemplo que muestra la creación de objetos de regla externa utilizando
   * código generado.
   */
  public void testUsingGeneratedTestClasses() {

    final Session session =
        Session_Factory.getFactory().newInstance(
            new RecalculationsProhibited(),
            new InMemoryDataStorage(
                new StronglyTypedRuleObjectFactory()));

    /**
     * Tenga en cuenta que el compilador impone que se proporcione el tipo correcto de
     * argumentos de inicialización.
     */
    final Person person =
        Person_Factory.getFactory().newInstance(session, "Juan",
            "Herrero");
    CREOLETestHelper.assertEquals("Juan", person.firstName()
        .getValue());

    /**
     * Estos objetos los recuperará la expresión
     *
     * <readall ruleclass="Income"/>
     *
     * en el conjunto de reglas.
     */
    final Income income1 =
        Income_Factory.getFactory().newInstance(session);
    income1.amount().specifyValue(123);

    final Income income2 =
        Income_Factory.getFactory().newInstance(session);
    income2.amount().specifyValue(345);

  }

  /**
   * Ejemplo que muestra la creación de objetos de regla externa utilizando
   * el intérprete de conjunto de reglas CER.
   */
  public void testUsingInterpreter() {

    /* leer en el conjunto de reglas */
    final RuleSet ruleSet = getRuleSet();

    /* iniciar una sesión interpretada */
    final Session session =
        Session_Factory.getFactory().newInstance(
            new RecalculationsProhibited(),
            new InMemoryDataStorage(
                new InterpretedRuleObjectFactory()));

    /**
     * Tenga en cuenta que el compilador no puede imponer que se proporcione el tipo correcto de
     * argumentos de inicialización se proporcionan - si son incorrectos
     * CER informará de un error de tiempo de ejecución.
     */
    final RuleObject person =
        session.createRuleObject(ruleSet.findClass("Person"),
            "Juan", "Herrero");
    CREOLETestHelper.assertEquals("Juan", person
        .getAttributeValue("firstName").getValue());

    /**
     * Estos objetos los recuperará la expresión
     *
     * <readall ruleclass="Income"/>
     *
     * en el conjunto de reglas.
     */
    final RuleObject income1 =
        session.createRuleObject(ruleSet.findClass("Income"));
    income1.getAttributeValue("amount").specifyValue(123);

    final RuleObject income2 =
        session.createRuleObject(ruleSet.findClass("Income"));
    income2.getAttributeValue("amount").specifyValue(345);
  }

  /**
   * Lee Example_externalRuleObjects del archivo de
   * origen XML.
   */
  private RuleSet getRuleSet() {

    /* La vía de acceso relativa al archivo de origen de conjunto de reglas */
    final String ruleSetRelativePath =
        "./rules/Example_externalRuleObjects.xml";

    /* leer en el origen de conjunto de reglas */
    final RuleSetXmlReader ruleSetXmlReader =
        new RuleSetXmlReader(ruleSetRelativePath);

    /* volcar los problemas */
    ruleSetXmlReader.validationProblemCollection().printProblems(
        System.err);

    /* fallar si hay errores en el conjunto de reglas */
    assertTrue(!ruleSetXmlReader.validationProblemCollection()
        .containsErrors());

    /* devolver el conjunto de reglas del lector */
    return ruleSetXmlReader.ruleSet();
  }

}