JavaGenerator (PegaRULES Java Engine v7.4.0

All Superinterfaces:

GenericAssembler, GenericAssemblerValidator

All Known Subinterfaces:

JavaGeneratorExtended
```
public interface JavaGenerator
extends GenericAssemblerValidator
```
The JavaGenerator interface identifies the code fragments required to specify how a defining Rule- instance is to be implemented. These fragments are combined by First-Use Assembly, which can coordinate multiple definitions into a single implementation class.
Each implementation of this interface is associated with one or more defining Rule- classes. It determines how the specifications in instances of those classes are to be implemented in Java. The implementation must specify a constructor that accepts a FirstUseAssembler instance as its only parameter. This instance will provide access to the defining Rule- ClipboardPage, will receive the generated Java fragments, and will provide a variety of supporting functionality.
The JavaGenerator instance is "primary" if it corresponds to the reference that initiated the current Rules Assembly of Java code into an implementation class. It is "embedded" if it is being incorporated into an implementation class initiated by a different rule reference.
Each class that implements JavaGenerator must have a constructor of the form: JavaGenerator(FirstUseAssembler fua) The argument to the constructor provides access to the defining rule instance, implements functionality that can assist with the Java generation, and receives the Java as it is generated.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`COPYRIGHT`
`static byte`	`DEFERRED` Value returned by `methodAccess`, indicating that the referenced Rule- will be assembled separately.
`static byte`	`PRIMARY` Value returned by `methodAccess`, indicating that the implementations of the referenced Rule- will be included directly in the primary code buffer.
`static byte`	`SUPPORT` Value returned by `methodAccess`, indicating that the implementations of the referenced Rule- will be included as a separate method in the support code buffer, invoked from the primary code buffer.
`static java.lang.String`	`VERSION`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`java.lang.String`	`getConstructorBody()` Generates the java for the body of the constructor for a rule.
`java.lang.String`	`getDefinedPrimaryPageClass()` Names the class of the primary page that will be used by this rule in the absence of overriding information.
`java.lang.String`	`getInterfaceName()` Names the access interface implemented by the generated Java when this processing is primary.
`void`	`methodAbsent(java.lang.String aMsgDescr)` Generates the code to handle the absence of the associated defining ClipboardPage instance.
`byte`	`methodAccess(ExpressionMap aKeys)` Establishes the structure for accessing the implementation of this instance within the implementation of another Rule- reference.
`void`	`methodBody(int aCircumstanceCount)` Provides the Java that implements one defining rule instance.
`void`	`methodCall(java.lang.String aMethodName, ExpressionMap aKeys)` Generates the Java to invoke an implementation of the associated Rule- class.
`void`	`methodCallVersion(java.lang.String aMethodName)` Generates the Java to call a method that implements a single version of this rule.
`void`	`methodClose()` /** Generates "closing" code common for all versions of the rule being assembled.
`void`	`methodFinish()` Generates the Java to complete the implementation.
`void`	`methodHeader()` Adds the access-method prototype to the primary code buffer, including the opening brace for its definition.
`void`	`methodInit()` Generates initialization code common for all versions of the rule being assembled.
`void`	`methodVersionFinish(int aVersion)` Generates the Java to complete a method that implements a single version of the rule being assembled.
`java.lang.String`	`methodVersionHeader(int aVersion)` Generates method declaration for a method that implements a single version of the rule being assembled, including the opening brace.

Methods inherited from interface com.pega.pegarules.pub.generator.GenericAssemblerValidator
getLocalParametersName, getPagesAndClassesName, getParametersName

- Field Detail
  - VERSION
```
static final java.lang.String VERSION
```
  - COPYRIGHT
```
static final java.lang.String COPYRIGHT
```
    See Also:
    
    Constant Field Values
  - DEFERRED
```
static final byte DEFERRED
```
    Value returned by methodAccess, indicating that the referenced Rule- will be assembled separately.
    
    See Also:
    
    Constant Field Values
  - PRIMARY
```
static final byte PRIMARY
```
    Value returned by methodAccess, indicating that the implementations of the referenced Rule- will be included directly in the primary code buffer.
    
    See Also:
    
    Constant Field Values
  - SUPPORT
```
static final byte SUPPORT
```
    Value returned by methodAccess, indicating that the implementations of the referenced Rule- will be included as a separate method in the support code buffer, invoked from the primary code buffer.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - getDefinedPrimaryPageClass
```
java.lang.String getDefinedPrimaryPageClass()
```
    Names the class of the primary page that will be used by this rule in the absence of overriding information. Typically the name of the class in which the rule instance is defined.
    
    Specified by:
    
    getDefinedPrimaryPageClass in interface GenericAssembler
    
    Returns:
    
    name of default Class for primary page
  - getInterfaceName
```
java.lang.String getInterfaceName()
```
    Names the access interface implemented by the generated Java when this processing is primary. The access interface must extend GeneratedJava and declare the method used to access this functionality. The interface might also define constants used by this processing.
    
    Returns:
    
    name of access interface
  - getConstructorBody
```
java.lang.String getConstructorBody()
```
    Generates the java for the body of the constructor for a rule. The declaration of the constructor is generated by FUAInstance; therefore the returned String does not contain the constructor DECLARATION. Only rule-specific initialization logic is returned and is added to the stardard constructor body that is generated for ALL FUA rules.
    
    Returns:
    
    null if no specialized code needs to be added for the rule's constructor.
  - methodCall
```
void methodCall(java.lang.String aMethodName,
                ExpressionMap aKeys)
```
    Generates the Java to invoke an implementation of the associated Rule- class. This is used at design time for any reference to a definition that will be provided by First-Use Assembly, and during runtime assembly for references that cannot or should not be inlined or for references to an appropriate local method previously established.
    
    Parameters:
    
    aMethodName - When this value is null, the generated call should be to the separately assembled implementation of this reference. A non-null value names a local method that implements the desired processing.
    
    aKeys - Identifies the generated Java that is to be referenced. A value for "pxObjClass" is required and must be a StringExpression for which isLiteral is true. This was used to identify the implementation class that has been selected. Any of the other values specified might require runtime evaluation.
  - methodHeader
```
void methodHeader()
```
    Adds the access-method prototype to the primary code buffer, including the opening brace for its definition. This method is called only when this instance isPrimary.
    This method might also provide variable declarations, such as a 'result' variable, to be shared by the alternative implementations, but it is preferred to implement the methodInit() method and generate that code there.
  - methodAccess
```
byte methodAccess(ExpressionMap aKeys)
```
    Establishes the structure for accessing the implementation of this instance within the implementation of another Rule- reference. It supports three techniques, indicated by the value it returns:
    - DEFERRED -- The referenced Rule- will be assembled separately. Access to the processing can be provided by calling:
      methodCall(null, aKeys);
    - PRIMARY -- The implementations of the referenced Rule- will be included directly in the primary code buffer. This is generally only possible when the access method does not return a value and when any parameters can have unique names. It is recommended that this method provide an opening brace for a compound statement to enclose this implementation. The variables identifying any parameters should also be defined here.
    - SUPPORT -- The implementation of the referenced Rule- will be included as a separate method in the support code buffer, invoked from the primary code buffer. If the implementation will be reusable, use FirstUseAssembler.getMethodName() to provide the name for the implementing method. This will notify First-Use Assembly of its reusability, when relevant conditions apply. The reference to the method can be provided by calling:
      methodCall(method-name, aKeys);
      The method prototype, opening brace, and any shared variable declarations should be added to the support code buffer. For subsequent processing, the support code buffer will be made the primary buffer and an auxiliary support code buffer provided.
    When this method is called, isEmbedded() and isRuntime() will both return true.
    Parameters:
    
    aKeys - Identifies the generated Java that is to be referenced. A value for "pxObjClass" and for each of the key properties that value indicates is provided by a StringExpression for which isLiteral is true; the corresponding values are also provided in the 'keys' StringMap of the associated FirstUseAssembler instance. Additional parameters for the method being referenced might also be defined.
    
    Returns:
    
    value indicating how access is being provided: DEFERRED, PRIMARY, or SUPPORT
  - methodBody
```
void methodBody(int aCircumstanceCount)
```
    Provides the Java that implements one defining rule instance. The code is added to the primary code buffer. A support code buffer is also available, to which complete members of the implementation class may be added, to assist with the implementation. This method will always have access to exactly one defining rule instance. Generates the implementing code for one defining ClipboardPage instance. This code is typically enclosed in a compound statement.
    
    Parameters:
    
    aCircumstanceCount - The unique circumstance instance which is being processed.
  - methodAbsent
```
void methodAbsent(java.lang.String aMsgDescr)
```
    Generates the code to handle the absence of the associated defining ClipboardPage instance. The recommended practice is to generate code that throws a suitable exception on execution.
    Parameters:
    aMsgDescr - identifies the reason that no implementation is available. Some possible reasons are:
    
    No definition is currently available.
    
    The defining Rule- instance is "Blocked".
    
    MultipleRuleVersionException
    
    No available definition for the default circumstance.
  - methodFinish
```
void methodFinish()
```
    Generates the Java to complete the implementation. This should consist of the the closing brace that completes the implementation initiated by methodHeader. It might also create the return statement when one is needed--but it is preferred to generate this statement in a methodClose() method.
    The requirements for a particular implementation might vary depending whether this instance isPrimary (whether methodHeader or methodAccess was used to begin the implementation), and on the value returned by methodAccess when it was used.
  - methodCallVersion
```
void methodCallVersion(java.lang.String aMethodName)
```
    Generates the Java to call a method that implements a single version of this rule.
    This method does not need to be implemented. If it is not, then it should throw UnsupportedOperationException. If this method is implemented, then all of the following methods must be implemented:
    Parameters:
    
    aMethodName - the name of the method to call
  - methodVersionHeader
```
java.lang.String methodVersionHeader(int aVersion)
```
    Generates method declaration for a method that implements a single version of the rule being assembled, including the opening brace.
    This method does not need to be implemented. If it is not, then it should throw UnsupportedOperationException. If this method is implemented, then all of the following methods must be implemented:
    Parameters:
    
    aVersion - a number that uniquely identifies the version of the rule whose implementation method is to be called
    
    Returns:
    
    the name of the method that was created
  - methodVersionFinish
```
void methodVersionFinish(int aVersion)
```
    Generates the Java to complete a method that implements a single version of the rule being assembled. In particular, it must complete the method that was started by calling methodVersionHeader(int) with the same argument. Normally, this method should simple emit a single closing bracket.
    This method does not need to be implemented. If it is not, then it should throw UnsupportedOperationException. If this method is implemented, then all of the following methods must be implemented:
    Parameters:
    
    aVersion - a number that uniquely identifies the version of the rule whose implementation method is to be called
  - methodInit
```
void methodInit()
```
    Generates initialization code common for all versions of the rule being assembled. Java to complete a method that implements a single version of the rule being assmebled. In particular, it must complete the method that was started by calling methodVersionHeader(int) with the same argument. Normally, this method should simple emit a single closing bracket.
    This method does not need to be implemented. If it is not, then it should throw UnsupportedOperationException.
  - methodClose
```
void methodClose()
```
    /** Generates "closing" code common for all versions of the rule being assembled. This might include a return statement where applicable.
    This method does not need to be implemented. If it is not, then it should throw UnsupportedOperationException.

Interface JavaGenerator

Field Summary

Method Summary

Methods inherited from interface com.pega.pegarules.pub.generator.GenericAssemblerValidator

Field Detail

VERSION

COPYRIGHT

DEFERRED

PRIMARY

SUPPORT

Method Detail

getDefinedPrimaryPageClass

getInterfaceName

getConstructorBody

methodCall

methodHeader

methodAccess

methodBody

methodAbsent

methodFinish

methodCallVersion

methodVersionHeader

methodVersionFinish

methodInit

methodClose