BitBabel Terminal V0.5...

IDENTIFICATION DIVISION.
PROGRAM-ID. STUDENTS.

DATA DIVISION.
    LINKAGE SECTION.
    01 ID PIC 9(9).
    01 STUDENT.
        02 ID PIC 9(9).
        02 FIRST-NAME PIC X(16).
        02 LAST-NAME PIC X(32).
        02 AGE PIC 9(3) VALUE 0.
        02 GENDER PIC X(1).
            88 MALE VALUE 'M'.
            88 FEMALE VALUE 'F'.
            88 VALID VALUES 'M' 'F'.
    EXEC SQL
        IMPORT SQLCA
    END-EXEC.

PROCEDURE DIVISION USING BY REFERENCE RETURNING STUDENT.
    EXEC SQL
        SELECT FNAME, LNAME, AGE
        FROM STUDENTS
        INTO :FIRST-NAME, :LAST-NAME, :AGE
        WHERE ID = :ID
    END-EXEC
    IF SQLCODE >= 100 THEN
        INITIALIZE STUDENT
    END-IF.
                Back
                

using AlienSoftworks.BitBabel.Data;
using System.Threading;
using System.Threading.Tasks;

namespace Cobol
{
    public class Students : IStudents
    {
        private static string _sqlQuery = 
        @"SELECT FNAME, LNAME, AGE
               FROM STUDENTS
               INTO @firstName, @lastName, @age
               WHERE ID = @id";

        private IDataAccessComponent _dataAccessComponent;

        public Students(IDataAccessComponent iDataAccessComponent)
        {
            _dataAccessComponent = iDataAccessComponent;
        }

        [CobolPicture("9(9)")]
        private uint Id { get; set; }

        private IStudent TheStudent { get; set; }

        public async Task<IStudent> Process(CancellationToken cancellationToken)
        {
            {
                var outputParameters = new Dictionary<string, (Type, Action<object>)>();
                outputParameters["firstName"] = (typeof(string), _ => TheStudent.FirstName = (string)_);
                outputParameters["lastName"] = (typeof(string), _ => TheStudent.LastName = (string)_);
                outputParameters["age"] = (typeof(ushort), _ => TheStudent.Age = (ushort)_);
                outputParameters["id"] = (typeof(uint), _ => Id = (uint)_);
                var rows = await _dataAccessComponent.Execute(
                    _sqlQuery,
                    null,
                    null,
                    outputParameters,
                    cancellationToken);
                if (rows == 0)
                {
                    DataStructure.Initialize(
                        this,
                        nameof(TheStudent),
                        new bool?[0],
                        new object[0],
                        false);
                }
            }

            return TheStudent;
        }

        public class Student : IStudent
        {
            private static string[] _validValues = new string[] { "M", "F" };

            public Student()
            {
                FirstName = "";
                LastName = "";
                Gender = "";
            }

            public string this[int index, int length]
            {
                get { return this.GetFragment(index, length); }
                set { this.SetFragment(index, length, value); }
            }

            public virtual uint Id { get; set; }

            public virtual string FirstName { get; set; }

            public virtual string LastName { get; set; }

            public virtual ushort Age { get; set; } = (ushort)0;

            public virtual string Gender { get; set; }

            public virtual bool Male
            {
                get { return Gender == "M"; }
                set { Gender = value == true ? "M" : default; }
            }

            public virtual bool Female
            {
                get { return Gender == "F"; }
                set { Gender = value == true ? "F" : default; }
            }

            public virtual bool Valid
            {
                get { return System.Linq.Enumerable.Contains(Student._validValues, Gender); }
            }

            public override string ToString()
            {
                return this.Stringify();
            }
        }
    }
}
                Back
                

using System.Threading;
using System.Threading.Tasks;

namespace Cobol
{
    public interface IStudents
    {
        Task<IStudent> Process(CancellationToken cancellationToken);
    }
}
                Back
                

package cobol;

import java.util.function.Consumer;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import javafx.util.Pair;
import net.bitbabel.data.CobolName;
import net.bitbabel.data.CobolPicture;
import net.bitbabel.data.DataAccessComponent;
import net.bitbabel.data.DataStructure;
import net.bitbabel.reflect.Order;
import net.bitbabel.util.ArrayOf;
import static net.bitbabel.ObjectExtensions.fromString;
import static net.bitbabel.ObjectExtensions.stringify;
import static net.bitbabel.reflect.Part.getFragment;
import static net.bitbabel.reflect.Part.setFragment;
import static net.bitbabel.util.stream.StreamHelper.toStream;

public class StudentsImpl implements Students {
    private static String[] validValues = new String[] { "M", "F" };
    private static String sqlQuery =
        "SELECT FNAME, LNAME, AGE\nFROM STUDENTS\nINTO firstName, lastName, age\nWHERE ID = id";

    private final DataAccessComponent dataAccessComponent;

    public StudentsImpl(DataAccessComponent dataAccessComponent) {
        resetLocalStorage();
        this.dataAccessComponent = dataAccessComponent;
    }

    private int _id;

    @Order(0)
    @CobolPicture("9(9)")
    @CobolName("ID")
    private int getId() {
        return _id;
    }

    @Order(0)
    @CobolPicture("9(9)")
    @CobolName("ID")
    private int setId(int value) {
        return _id = value;
    }

    private StudentsStudent _theStudent;

    @Order(1)
    @CobolName("STUDENT")
    private StudentsStudent getTheStudent() {
        return _theStudent;
    }

    @Order(1)
    @CobolName("STUDENT")
    private StudentsStudent setTheStudent(StudentsStudent value) {
        return _theStudent = value;
    }

    public static Student asStudent(String value) {
        return fromString(new StudentsImpl(null).new Student(), value);
    }

    public void reset() {
        resetLocalStorage();
    }

    public StudentsStudent process() {
        {
            Map<String, Pair<Class<?>, Consumer<Object>>> outputParameters = new HashMap<>();
            outputParameters.put("firstName", new Pair<Class<?>, Consumer<Object>>(String.class, x -> getTheStudent().setFirstName((String)x)));
            outputParameters.put("lastName", new Pair<Class<?>, Consumer<Object>>>String.class, x -> getTheStudent().setLastName((String)x)));
            outputParameters.put("age", new Pair<Class<?>, Consumer<Object>>(Short.class, x -> getTheStudent().setAge((short)x)));
            outputParameters.put("id", new Pair<Class<?>, Consumer<Object>>(Integer.class, x -> setId((int)x)));
            int rows = dataAccessComponent.execute(
                sqlQuery,
                null,
                null,
                outputParameters);
            if (rows == 0)
            {
                DataStructure.initialize(
                    this,
                    "TheStudent",
                    (Optional<Boolean>[])ArrayOf.values(Optional.class, 0),
                    new Object[0],
                    false);
            }
        }
        return getTheStudent();
    }

    private void resetLocalStorage() {
        setTheStudent(new StudentsImpl(null).new Student());
    }

    public class Student implements StudentsStudent {
        public Student() {
            this._firstName = "";
            this._lastName = "";
            this._gender = "";
        }

        public String get(int index, int length) {
            return getFragment(this, index, length);
        }

        public String put(int index, int length, String value) {
            setFragment(this, index, length, value);
            return this.get(index, length);
        }

        private int _id;

        public int getId() {
            return _id;
        }

        public int setId(int value) {
            return _id = value;
        }

        private String _firstName;

        public String getFirstName() {
            return _firstName;
        }

        public String setFirstName(String value) {
            return _firstName = value;
        }

        private String _lastName;

        public String getLastName() {
            return _lastName;
        }

        public String setLastName(String value) {
            return _lastName = value;
        }

        private short _age = 0;

        public short getAge() {
            return _age;
        }

        public short setAge(short value) {
            return _age = value;
        }

        private String _gender;

        public String getGender() {
            return _gender;
        }

        public String setGender(String value) {
            return _gender = value;
        }

        public boolean isMale() {
            return getGender() == "M";
        }

        public boolean isMale(boolean value) {
            setGender(value == true ? "M" : null);
            return isMale();
        }

        public boolean isFemale() {
            return getGender() == "F";
        }

        public boolean isFemale(boolean value) {
            setGender(value == true ? "F" : null);
            return isFemale();
        }

        public boolean isValid() {
            return toStream(StudentsImpl.validValues).anyMatch(x -> Objects.equals(x, getGender()));
        }

        @Override
        public String toString() {
            return stringify(this);
        }
    }
}
                Back
                

package cobol;

import net.bitbabel.Program;

public interface Students extends Program {
    StudentsStudent process();
}
                Back
                

//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//PROC1     EXEC PGM=&PROG
//STEPLIB   DD DSN=&BASELB,DISP=SHR
//IN1       DD DSN=&DSNAME,DISP=SHR
//OUT1      DD SYSOUT=*
//SYSOUT    DD SYSOUT=*
//SYSIN     DD DSN=&DATAC
//*
                Back
                

using namespace System.Linq;

class Catlproc
{
    static [int] $proc1 = -1;

    static [bool] getReturnCode()
    {
        return [Enumerable]::Max(@([Catlproc]::$proc1));
    }

    static [void] Process([string] $prog, [string] $baselb, [string] $dsname, [string] $datac)
    {
        if ($prog -eq $null)
        {
            $prog = "";
        }

        if ($baselb -eq $null)
        {
            $baselb = "MYCOBOL.BASE.LIB1";
        }

        if ([Catlproc]::getReturnCode() -le 0)
        {
            [Catlproc]::Proc1($prog, $baselb, $dsname, $datac);
        }
    }

    static [void] Proc1([string] $prog, [string] $baselb, [string] $dsname, [string] $datac)
    {
        & $prog `
            -STEPLIB DSN=$baselb,DISP=SHR `
            -IN1 DSN=$dsname,DISP=SHR `
            -OUT1 SYSOUT=* `
            -SYSOUT SYSOUT=* `
            -SYSIN DSN=$datac;
        [Catlproc]::$proc1 = $LastExitCode;
    }
}
                Back