Trait Execute 

pub trait Execute {
    // Required methods
    fn run(
        &self,
        out: &mut dyn Write,
        err: &mut dyn Write,
    ) -> Result<Ending, Abend>;
    fn run_with(
        &self,
        dds: Dds,
        out: &mut dyn Write,
        err: &mut dyn Write,
    ) -> Result<Ending, Abend>;
    fn execute<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
    ) -> Result<(Ending, i16), Abend>;
    fn execute_with<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
    ) -> Result<(Ending, i16), Abend>;
    fn execute_observed<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
        observer: Option<Observer<'w>>,
    ) -> Result<(Ending, i16), Abend>;
    fn execute_main<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
        observer: Option<Observer<'w>>,
        parm: &str,
    ) -> Result<(Ending, i16), Abend>;
    fn execute_with_arguments<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
        observer: Option<Observer<'w>>,
        arguments: &[Option<Vec<u8>>],
    ) -> Result<(Ending, i16), Abend>;
    fn execute_kept<'w>(
        &self,
        library: Library,
        dds: Dds,
        sysin: Option<Box<dyn BufRead + 'w>>,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
        observer: Option<Observer<'w>>,
        kept: &mut Option<Remains>,
    ) -> Result<(Ending, i16), Abend>;
    fn execute_cics<'w>(
        &self,
        library: Library,
        dds: Dds,
        task: Task,
        clock: Clock,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
    ) -> Result<(Ending, Task), Abend>;
    fn execute_cics_with<'w>(
        &self,
        library: Library,
        dds: Dds,
        task: Task,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
    ) -> Result<(Ending, Task), Abend>;
    fn execute_cics_observed<'w>(
        &self,
        library: Library,
        dds: Dds,
        task: Task,
        clock: Clock,
        database: Option<&'w mut (dyn Database + '_)>,
        out: &'w mut dyn Write,
        err: &'w mut dyn Write,
        observer: Option<Observer<'w>>,
    ) -> Result<(Ending, Task), Abend>;
}

Running a compiled program, in a run unit of its own or as a CICS task.

Required Methods

fn run(&self, out: &mut dyn Write, err: &mut dyn Write) -> Result<Ending, Abend>

fn run_with( &self, dds: Dds, out: &mut dyn Write, err: &mut dyn Write, ) -> Result<Ending, Abend>

Runs with the DDs that ASSIGN names map to.

fn execute<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, out: &'w mut dyn Write, err: &'w mut dyn Write, ) -> Result<(Ending, i16), Abend>

Runs as the first program of a run unit: CALL finds other programs in library, ACCEPT reads sysin. Returns how the run ended and RETURN-CODE.

fn execute_with<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, ) -> Result<(Ending, i16), Abend>

Runs as Execute::execute does, with EXEC SQL answered by database.

fn execute_observed<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, observer: Option<Observer<'w>>, ) -> Result<(Ending, i16), Abend>

Runs as Execute::execute_with does, telling observer what the run opens, closes and loads.

fn execute_main<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, observer: Option<Observer<'w>>, parm: &str, ) -> Result<(Ending, i16), Abend>

Runs as Execute::execute_observed does, as the main program of a job step that EXEC PGM= started with parm: the first PROCEDURE DIVISION USING item addresses a halfword length and the program arguments Language Environment finds in it.

fn execute_with_arguments<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, observer: Option<Observer<'w>>, arguments: &[Option<Vec<u8>>], ) -> Result<(Ending, i16), Abend>

Runs as Execute::execute_observed does, as a subprogram whose caller passed arguments, one per PROCEDURE DIVISION USING item: the bytes of the item passed, or None for OMITTED, which passes a null address. Each argument is input to the run, and EXIT PROGRAM returns.

fn execute_kept<'w>( &self, library: Library, dds: Dds, sysin: Option<Box<dyn BufRead + 'w>>, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, observer: Option<Observer<'w>>, kept: &mut Option<Remains>, ) -> Result<(Ending, i16), Abend>

Runs as Execute::execute_observed does, and puts what the run left in its run unit in kept.

fn execute_cics<'w>( &self, library: Library, dds: Dds, task: Task, clock: Clock, out: &'w mut dyn Write, err: &'w mut dyn Write, ) -> Result<(Ending, Task), Abend>

Runs as the first program of a CICS task. task says who started it, what COMMAREA it starts with, and what files and queues it has. Returns how the run ended and the task, with RETURN TRANSID and COMMAREA if it ended that way.

fn execute_cics_with<'w>( &self, library: Library, dds: Dds, task: Task, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, ) -> Result<(Ending, Task), Abend>

A CICS task with a database: SYNCPOINT commits, and the end of the task commits, or rolls back after an abend, and closes every cursor. The database outlives the task, so a region’s tasks can share one.

fn execute_cics_observed<'w>( &self, library: Library, dds: Dds, task: Task, clock: Clock, database: Option<&'w mut (dyn Database + '_)>, out: &'w mut dyn Write, err: &'w mut dyn Write, observer: Option<Observer<'w>>, ) -> Result<(Ending, Task), Abend>

Runs as Execute::execute_cics_with does, telling observer what the task opens, loads and passes to an operation an input could steer.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Execute for Compiled