Skip to content

Class ZCL_LLM_TEMPLATE_PARSER

AI Generated documentation.

Overview

The zcl_llm_template_parser class is designed to parse and render templates based on a limited Jinja2-like syntax. It provides methods to add templates, render them with a given context, and handle various control structures and variable substitutions. The class is particularly useful for generating dynamic content by embedding variables and control logic within templates.

Public Methods

  1. Constructor:

  2. Initializes the template parser with an empty list of templates.

  3. add_template:

  4. Purpose: Adds or replaces a template with a given name and content.
  5. Parameters:
    • name: Name of the template.
    • content: Content of the template.
    • replace: Boolean flag to determine if an existing template with the same name should be replaced.

  6. Raises: zcx_llm_template_parser if template parsing fails.

  7. render:

  8. Purpose: Renders a template with the given name using the provided context.
  9. Parameters:
    • template_name: Name of the template to render.
    • context: Data context for variable resolution.
  10. Returns: Rendered template string.
  11. Raises: zcx_llm_template_parser if rendering fails.

Dependencies

The class does not have any external dependencies beyond standard ABAP types and classes. It relies on internal methods and data structures to manage templates and their rendering.

Details

Internal Workflow

The internal workflow of the zcl_llm_template_parser class involves several key steps:

  1. Template Addition:

  2. Templates are added using the add_template method. If a template with the same name already exists and the replace flag is set to true, the existing template is replaced.

  3. Tokenization:

  4. The tokenize method converts the template content into a sequence of tokens. It handles different types of tokens such as text, variables, control structures, and comments.

  5. Parsing:

  6. The parse_tokens method processes the tokens and replaces variables with values from the provided context. It handles control structures like loops and conditionals.

  7. Variable Resolution:

  8. The resolve_variable method resolves variable paths to their values. It supports nested structures and table indices.

  9. Control Structures:

  10. The class handles various control structures such as if, else, elif, for, and endfor. These are managed using a control stack to keep track of the current state of the parsing process.

Key Methods

  1. tokenize:
  2. Converts the template string into a sequence of tokens.

  3. Handles different token types and removes comments.

  4. parse_tokens:

  5. Processes the tokens and replaces variables with values from the context.

  6. Manages control structures and handles nested loops.

  7. resolve_variable:

  8. Resolves variable paths to their values.

  9. Supports nested structures and table indices.

  10. evaluate_condition_true:

  11. Evaluates conditions in control structures.

  12. Supports logical operators and comparison operators.

  13. apply_filter:

  14. Applies filters to variable values.

  15. Supports filters like upper, lower, capitalize, and default.

  16. format_table:

  17. Formats tables as strings.
  18. Supports elementary types, structures, and nested tables.

Logic Flow

The following Mermaid diagram illustrates the logic flow of the zcl_llm_template_parser class:

graph TD
    A[add_template] --> B[tokenize]
    B --> C[parse_tokens]
    C --> D[resolve_variable]
    C --> E[evaluate_condition_true]
    C --> F[apply_filter]
    C --> G[format_table]
    C --> H[handle_conditional]
    C --> I[handle_for_loop]
    C --> J[handle_endfor]
    C --> K[process_token]
    C --> L[check_control_stack_conditions]
    C --> M[handle_nested_for_loop]
    C --> N[handle_endif]
    C --> O[process_loop_content]
    C --> P[render]

Interaction with Foreign Objects

The class interacts with the following foreign objects:

  • ABAP Data Types: The class uses standard ABAP data types to define templates and tokens.
  • ABAP Classes: The class uses internal methods and data structures to manage templates and their rendering.
  • ABAP Tables: The class uses internal tables to store templates and tokens.

Error Handling

The class raises exceptions of type zcx_llm_template_parser for various error conditions, including unclosed tokens, invalid paths, unclosed control structures, and variable resolution errors. This ensures that any issues during template parsing or rendering are properly handled and reported.