Java - programacion en java jcsp (como se haría este ejercicio)

// BancoCSP_skel.java

// Lars feat. Julio -- 2021

// esqueleto de código para JCSP

// (peticiones aplazadas)

package cc.banco;

import org.jcsp.lang.Alternative;

import org.jcsp.lang.AltingChannelInput;

import org.jcsp.lang.Any2OneChannel;

import org.jcsp.lang.CSProcess;

import org.jcsp.lang.Channel;

import org.jcsp.lang.Guard;

import org.jcsp.lang.One2OneChannel;

import org.jcsp.lang.ProcessManager;

// otras librerías: estructuras de datos, etc.

//

//

//

// COMPLETAD

//

//

//

//

public class BancoCSP implements Banco, CSProcess {

    // canales: uno por operación

    // serán peticiones aplazadas

    private Any2OneChannel chIngresar;

    private Any2OneChannel chDisponible;

    private Any2OneChannel chTransferir;

    private Any2OneChannel chAlertar;

    // clases para peticiones

    // regalamos una como ejemplo

    public class TransferirReq {

	// atributos (pueden ser públicos)

	String from;

	String to;

	int value;

	One2OneChannel resp;

	// constructor

	public TransferirReq(String from, String to, int value) {

	    this.from = from; this.to = to; this.value = value; this.resp = Channel.one2one();

	}

    }

    public class AlertarReq {

	// atributos (pueden ser públicos)

	//

	// COMPLETAD

	//

	// constructor

	//

	// COMPLETAD

	//

    }

    public class IngresarReq {

	// atributos (pueden ser públicos)

	//

	// COMPLETAD

	//

	// constructor

	//

	// COMPLETAD

	//

    }

    public class DisponibleReq {

	// atributos (pueden ser públicos)

	//

	// COMPLETAD

	// constructor

	//

	// COMPLETAD

	//

    }

    // constructor de BancoCSP

    public BancoCSP() {

	this.chIngresar = Channel.any2one();

	this.chAlertar = Channel.any2one();

	this.chDisponible = Channel.any2one();

	this.chTransferir = Channel.any2one();

	new ProcessManager(this).start();

    }

    // interfaz Banco

    /**

     * Un cajero pide que se ingrese una determinado valor v a una

     * cuenta c. Si la cuenta no existe, se crea.

     * @param c número de cuenta

     * @param v valor a ingresar

     */

    public void ingresar(String c, int v) {

	// comprobar PRE

	// COMPLETAD

	// crear petición

	// COMPLETAD

	// enviar petición

	// COMPLETAD

    }

    /**

     * Un ordenante pide que se transfiera un determinado valor v desde

     * una cuenta o a otra cuenta d.

     * @param o número de cuenta origen

     * @param d número de cuenta destino

     * @param v valor a transferir

     * @throws IllegalArgumentException si o y d son las mismas cuentas

     *

     */

    public void transferir(String o, String d, int v) {

	// comprobar PRE

	// COMPLETAD

	// crear petición

	// COMPLETAD

	// enviar petición

	// COMPLETAD

	// esperar confirmación

	// COMPLETAD

    }

    /**

     * Un consultor pide el saldo disponible de una cuenta c.

     * @param c número de la cuenta

     * @return saldo disponible en la cuenta id

     * @throws IllegalArgumentException si la cuenta c no existe

     */

    public int disponible(String c) {

	// crear petición

	// COMPLETAD

	// enviar petición

	// COMPLETAD

	// recibir respuesta del servidor

	// COMPLETAD

	// tratar resultado

	//

	// COMPLETAD

	//

	//

    }

    /**

     * Un avisador establece una alerta para la cuenta c. La operación

     * termina cuando el saldo de la cuenta c baja por debajo de m.

     * @param c número de la cuenta

     * @param m saldo mínimo

     * @throws IllegalArgumentException si la cuenta c no existe

     */

    public void alertar(String c, int v) {

	// crear petición

	// COMPLETAD

	// enviar petición

	// COMPLETAD

	// tratar respuesta del servidor

	//

	// COMPLETAD

    }

    // Código del servidor

    public void run() {

	// nombres simbólicos para las entradas

	final int INGRESAR   = 0;

	final int DISPONIBLE = 1;

	final int TRANSFERIR = 2;

	final int ALERTAR    = 3;

	// construimos la estructura para recepción alternativa

	final Guard[] guards = new AltingChannelInput[4];

	guards[INGRESAR]   = chIngresar.in();

	guards[DISPONIBLE] = chDisponible.in();

	guards[TRANSFERIR] = chTransferir.in();

	guards[ALERTAR]    = chAlertar.in();

	Alternative servicios = new Alternative(guards);

	// El estado del recurso debe ir en el servidor (aquí)

	// Reutilizar de la práctica de monitores

	// COMPLETAD

	// colecciones para peticiones aplazadas

	// reutilizar de monitores si es posible

	//

	// COMPLETAD

	//

	//

	// Bucle principal del servicio

	while(true) {

	    int servicio = servicios.fairSelect();

	    switch (servicio) {

	    case INGRESAR: {

		// recibir petición

		// COMPLETAR

		// realizar ingreso

		//

		//

		//

		break;

	    }

	    case DISPONIBLE: {

		// recibir petición

		// COMPLETAD

		// responder

		// COMPLETAD

		//

		break;

	    }

	    case TRANSFERIR: {

		// recibir petición

		// COMPLETAD

		// encolar petición

		// (alternativamente, se puede comprobar CPRE y

		//  solo encolar si estrictamente necesario)

		//

		//

		//  COMPLETAD

		//

		//

		break;

	    }

	    case ALERTAR: {

		// recibir petición

		// COMPLETAD

		// encolar petición

		// (alternativamente, se puede comprobar CPRE y

		//  solo encolar si estrictamente necesario)

		//

		//

		// COMPLETAD

		//

		//

		break;

	    }

	    }// END SWITCH

	    // tratamiento de peticiones aplazadas

	    // en parte, reutilizar de monitores

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    // COMPLETAD

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    //

	    // no debemos volver al inicio del bucle

	    // de servicio mientras haya alguna

	    // petición pendiente que se pueda atender !!

	}// END BUCLE SERVICIO

    }// END run SERVIDOR