Ejercicios 2010 (Comunicación II (segunda parte))

Ejercicio 1

El siguiente ejercicio consiste en completar el siguiente código correspondiente a 2 agentes. El objetivo es que un agente (Policia) envíe mensaje de petición indicando que ha ocurrido un altercado al agente (Comisaria). Este agente podrá atender o no dicha petición.
Nota:
  • Tenemos 2 agentes: "policia" (clase Policia), "comisaria" (clase Comisaria).
  • Al lanzar los agentes, se debe lanzar primero Comisaria y luego Policia.

Comisaria.java
package examples.practica5;
 
import java.util.StringTokenizer;
import jade.core.Agent;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
import jade.proto.AchieveREResponder;
import jade.domain.FIPANames;
import jade.domain.FIPAAgentManagement.NotUnderstoodException;
import jade.domain.FIPAAgentManagement.RefuseException;
import jade.domain.FIPAAgentManagement.FailureException;
 
 
public class Comisaria extends Agent {
 
    public double DISTANCIA_MAX;
 
    protected void setup()
    {
        DISTANCIA_MAX=(Math.random()*10);
        System.out.println("Comisaria "+getLocalName()+": Esperando avisos...");
        MessageTemplate protocolo = ..............................................................;
        MessageTemplate performativa = ...........................................................;
        MessageTemplate plantilla = ..............................................................;
 
        addBehaviour(new ManejadorResponder(this, plantilla));
    }
 
    class ManejadorResponder extends AchieveREResponder
    {
        public ManejadorResponder(Agent a,MessageTemplate mt) {
            super(a,mt);
        }
 
        protected ACLMessage ............(.........)throws NotUnderstoodException, RefuseException
        {
            System.out.println("Comisaria "+getLocalName()+": Hemos recibido una llamada de " + request.getSender().getName() + " diciendo que ha visto un altercado.");
            StringTokenizer st=new StringTokenizer(request.getContent());
            String contenido=st.nextToken();
 
         System.out.println("contenidooo "+contenido);
            if(contenido.equalsIgnoreCase("accidente"))
            {
 
                int distancia=Integer.parseInt(st.nextToken());
                if (distancia==1)
                {
                    System.out.println("Comisaria "+getLocalName()+": especializada en robos, Vamos para ahi");
                    ACLMessage agree = request.createReply();
                    agree.setPerformative(ACLMessage.AGREE);
                    return agree;
                }
 
 
        else if (distancia==2)
                {
                    System.out.println("Comisaria "+getLocalName()+": especializada en incendios, Vamos para ahi");
                    ACLMessage agree = request.createReply();
                    agree....................;
                    return agree;
                }
 
        else if (distancia==3)
                {
                    System.out.println("Comisaria "+getLocalName()+": especializada en disturbios, Vamos para ahi");
                    ACLMessage agree = ......................;
                    agree.setPerformative(ACLMessage.AGREE);
                    return .........;
                }
                else
                {
                    System.out.println("Comisaria "+getLocalName()+": Accidente fuera de nuestro radio de accion. No llegaremos a tiempo!!!");
                    throw new RefuseException("Accidente demasiado lejos");
                }
            }
            else throw new NotUnderstoodException("Comisaria manda un mensaje que no puedo entender.");
        }
 
        protected ACLMessage prepareResultNotification(ACLMessage request,ACLMessage response) throws FailureException
        {
            if (Math.random() > 0.2) {
                System.out.println("Comisaria "+getLocalName()+": Han vuelto de atender el accidente.");
                ACLMessage inform = request.createReply();
                inform.............................;
                return inform;
            }
            else
            {
                System.out.println("Comisaria "+getLocalName()+": Han hecho todo lo posible, lo sentimos.");
                throw new FailureException("Han hecho todo lo posible");
            }
        }
    }
}

Policia.java
package examples.practica5;
 
import jade.core.Agent;
import jade.core.AID;
import jade.lang.acl.ACLMessage;
import jade.proto.AchieveREInitiator;
import jade.domain.FIPANames;
 
 
public class Policia extends Agent {
 public double Incidente;
    protected void setup()
    {
 
        Object[] args = getArguments();
        if (args != null && args.length > 0) {
    Incidente=(Math.random()*10);
    System.out.println("Altercado solicitando refuerzos");
    if (Incidente<=3){
    System.out.println("Se ha producido un Robo (codigo1)");
                 }
        if (Incidente>3 &&Incidente<=6){
    System.out.println("Se ha producido un Incendio (codigo2)");
                 }
    if (Incidente>6 && Incidente<=10){
    ........................................................;
                 }
      ACLMessage msg = new ACLMessage(..............);
            for (int i = 0; i < args.length; ++i)
                msg.addReceiver(new AID((String) args[i], AID.ISLOCALNAME));
            msg.setProtocol(........................);
       if (Incidente<=3){
            msg.setContent("accidente 1");
 
            addBehaviour(new ManejadorInitiator(this,msg));
         }
     if (Incidente>3 &&Incidente<=6){
            msg.............;
 
            addBehaviour(new ManejadorInitiator(this,msg));
         }
        if (Incidente>6 && Incidente<=10){
        msg.setContent("accidente 3");
 
                addBehaviour(................................);
                 }
 
 
        }
        else System.out.println("Debe de esribir el nombre de una comisaría como minimo (pasado como parametro).");
    }
 
    class ManejadorInitiator extends AchieveREInitiator
    {
        public ManejadorInitiator(Agent a,ACLMessage msg) {
            super(a,msg);
        }
 
        protected void handleAgree(ACLMessage agree)
        {
            System.out.println("Comisaria " + agree.getSender().getName()
                    + " informa que han salido refuerzos");
        }
 
        protected void handleRefuse(.....................)
        {
            System.out.println("Comisaria " + refuse.getSender().getName()
                    + " Contacte con otra comisaria más cercana, nos encontramos demasiado lejos para ayudarle");
        }
 
        protected void handleNotUnderstood(ACLMessage notUnderstood)
        {
            System.out.println("Comisaria " + ............................
                    + " no puede entender el mensaje.");
        }
 
        protected void handleInform(ACLMessage inform)
        {
            System.out.println("Comisaria " + inform.getSender().getName()
                    + " informa que han atendido el accidente.");
        }
 
        protected void .............(ACLMessage fallo)
        {
            if (fallo.getSender().equals(myAgent.getAMS())) {
                System.out.println("Alguna de las comisarias no existe");
            }
            else
            {
                System.out.println("Fallo en la comisaria " + fallo.getSender().getName()
                        + ": " + fallo.getContent().substring(1, fallo.getContent().length()-1));
            }
        }
    }
 
}

Ejercicio 2

El siguiente ejercicio consiste en completar el siguiente código correspondiente a las siguientes clases. El objetivo es que un agente (Comprador) envía una propuesta a varios respondedores (Agencia), evalúa las respuestas de éstos y selecciona la óptima.
Nota:
  • Tenemos 3 agentes: "comprador" (clase Comprador), "agencia" (clase Agencia), "agencia2" (clase Agencia).
  • Al lanzar los agentes, se debe lanzar primero las "agencias" y luego el "comprador".

Comprador.java

package examples.practica5;
 
import jade.core.AID;
import jade.core.Agent;
import jade.domain.DFService;
import jade.domain.FIPANames;
import jade.domain.FIPAAgentManagement.DFAgentDescription;
import jade.domain.FIPAAgentManagement.ServiceDescription;
import jade.lang.acl.ACLMessage;
import jade.proto.ContractNetInitiator;
 
import java.util.Date;
import java.util.Vector;
 
public class Comprador extends Agent {
 
    //Número de ofertas que se considerarán.
    private int numeroDeOfertas;
 
    //Precio máximo que se pagará por un inmueble.
    private int precionMaximo;
 
    protected void setup() {
        //El precio máximo se recibirá como argumento de entrada.
        Object[] args = this.getArguments();
 
        if (args != null && args.length == 1) {
            this.precionMaximo = Integer.parseInt(((String) args[0]));
 
            //Búsqueda del servicio de venta de pisos en las páginas amarillas.
 
            ********
        ********
        ********
 
            DFAgentDescription descripcion = new DFAgentDescription();
            descripcion.addLanguages("Español");
            descripcion.addServices(servicio);
 
            try {
                DFAgentDescription[] resultados = DFService.search(this, descripcion);
                if (resultados.length <= 0) {
                    System.out.println("No existen ventas de pisos.");
                } else {
                    System.out.println("Busco piso, hay " + resultados.length + " ofertas...");
 
                    //Creamos el mensaje CFP(Call For Proposal) cumplimentando sus parámetros
                    *********
 
                    for (DFAgentDescription agente:resultados) {
                        mensajeCFP.addReceiver(agente.getName());
                    }
            //Protocolo que vamos a utilizar
                    mensajeCFP.setProtocol(*************************);
                    mensajeCFP.setContent("Busco piso, ¿proponeis precios?");
 
                    //Indicamos el tiempo que esperaremos por las ofertas.
                    mensajeCFP.setReplyByDate(new Date(System.currentTimeMillis() + 15000));
 
                    //Se añade el comportamiento que manejará las ofertas.
                    this.addBehaviour(new ManejoOpciones(this, mensajeCFP));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
 
        } else {
            System.out.println("Debe de introducir el precio maximo que esta dispuesto a pagar (pasado como parametro)");
        }
 
    } // Fin del setup
 
    private class ManejoOpciones extends ContractNetInitiator {
 
        public ManejoOpciones(Agent agente, ACLMessage plantilla) {
            super(agente, plantilla);
        }
 
        //Manejador de proposiciones.
        protected void handlePropose(ACLMessage propuesta, Vector aceptadas) {
            System.out.printf("%s: Recibida oferta de %s Inmobiliaria. Ofrece un piso por %s euros.\n",
                this.myAgent.getLocalName(), propuesta.getSender().getLocalName(), propuesta.getContent());
        }
 
        //Manejador de rechazos de proposiciones.
        protected void handleRefuse(ACLMessage rechazo) {
                ****************************
        ****************************
        }
 
        //Manejador de respuestas de fallo.
        protected void handleFailure(ACLMessage fallo) {
            if (fallo.getSender().equals(myAgent.getAMS())) {
 
        //Esta notificacion viene del entorno de ejecución JADE (no existe el receptor)
                System.out.println("AMS: Esta venta de pisos no existe o no es accesible");
            } else {
                System.out.printf("%s: %s Inmobiliaria ha sufrido un fallo.\n",
                    this.myAgent.getLocalName(), fallo.getSender().getLocalName());
            }
            //Falló, por lo tanto, no recibiremos respuesta desde ese agente
            Comprador.this.numeroDeOfertas--;
        }
 
        //Método colectivo llamado tras finalizar el tiempo de espera o recibir todas las propuestas.
        protected void handleAllResponses(Vector respuestas, Vector aceptados) {
 
        //Se comprueba si una venta de pisos se pasó del plazo de envío de ofertas.
            if (respuestas.size() < numeroDeOfertas) {
                System.out.printf("%s: %d ventas de pisos llegan tarde.\n",
                    this.myAgent.getLocalName(), Comprador.this.numeroDeOfertas - respuestas.size());
            }
 
            //Escogemos la mejor oferta
            int mejorOferta = Integer.MAX_VALUE;
            AID mejorInmuebles = null;
            ACLMessage aceptado = null;
            for (Object resp:respuestas) {
                ACLMessage mensaje = (ACLMessage) resp;
                if (mensaje.getPerformative() == ACLMessage.PROPOSE) {
                    ACLMessage respuesta = mensaje.createReply();
                    respuesta.setPerformative(ACLMessage.REJECT_PROPOSAL);
                    aceptados.add(respuesta);
 
                    //Si la oferta es la mejor (inferior a todas las otras)
                    //Se almacena su precio y el AID de la venta de pisos que la hizo.
                    int oferta = Integer.parseInt(mensaje.getContent());
                    if (oferta <= precionMaximo && oferta <= mejorOferta) {
                        mejorOferta = oferta;
                        mejorInmuebles = mensaje.getSender();
                        aceptado = respuesta;
                    }
                }
            }
 
            //Si hay una oferta aceptada se modifica su performativa.
            if (aceptado != null) {
                System.out.printf("%s: Decidido!!! Compro el piso de %s Inmobiliaria\n",
                    this.myAgent.getLocalName(), mejorInmuebles.getLocalName());
                aceptado.setPerformative(ACLMessage.ACCEPT_PROPOSAL);
            }
        }
 
        //Manejador de los mensajes inform.
        ********************************
    ********************************
    ********************************
    }
}
 

Agencia.java

package examples.practica5;
 
import jade.core.Agent;
import jade.domain.DFService;
import jade.domain.FIPAException;
import jade.domain.FIPANames;
import jade.domain.FIPAAgentManagement.DFAgentDescription;
import jade.domain.FIPAAgentManagement.FailureException;
import jade.domain.FIPAAgentManagement.NotUnderstoodException;
import jade.domain.FIPAAgentManagement.RefuseException;
import jade.domain.FIPAAgentManagement.ServiceDescription;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
import jade.proto.ContractNetResponder;
 
public class Agencia extends Agent {
 
    protected void setup() {
        System.out.printf("%s Inmobiliaria : A la espera de compradores...\n", this.getLocalName());
 
        //Registro del servicio de venta de pisos en las páginas amarillas.
        ***********
     ***********
    ***********
 
        DFAgentDescription descripcion = new DFAgentDescription();
        descripcion.setName(getAID());
        descripcion.addLanguages("Español");
        descripcion.addServices(servicio);
 
        try {
            *************************
 
        } catch (FIPAException e) {
            e.printStackTrace();
        }
 
        //Se crea una plantilla que filtre los mensajes a recibir.
        MessageTemplate template = ContractNetResponder.createMessageTemplate(FIPANames.InteractionProtocol.FIPA_CONTRACT_NET);
 
        //Añadimos los comportamientos ante mensajes recibidos
        ****************************
 
    }
 
    //Hacemos una simulación para que pueda dar que existe o no inmueble (sobre un 90% probab).
    private boolean existeInmueble() {
        return (Math.random() * 100 > 10);
    }
 
    //Calculamos un precio para el Inmueble aleatoriamente (estará entre 100000 y 200000).
    private int obtenerPrecio() {
        return (int) (Math.random() * 100000) + 100000;
    }
 
    // Simula fallos en el cálculo de precios.
    private boolean devolverPrecio() {
        return (int) (Math.random() * 10) > 1;
    }
 
    private class CrearOferta extends ContractNetResponder {
        public CrearOferta(Agent agente, MessageTemplate plantilla) {
            super(agente, plantilla);
        }
 
        protected ACLMessage ********************************************************** {
            System.out.printf("%s Inmobiliaria : Peticion de oferta recibida de %s.\n", this.myAgent.getLocalName(), cfp.getSender().getLocalName());
 
            //Comprobamos si existen ofertas disponibles
            if (Agencia.this.existeInmueble()) {
                //Proporcionamos la información necesaria
                int precio = Agencia.this.obtenerPrecio();
                System.out.printf("%s Inmobiliaria: Preparando oferta (%d euros).\n", this.myAgent.getLocalName(), precio);
 
                //Se crea el mensaje
                ACLMessage oferta = cfp.createReply();
                oferta.setPerformative(ACLMessage.PROPOSE);
                oferta.setContent(String.valueOf(precio));
                return oferta;
            } else {
                //Si no hay ofertas disponibles rechazamos el propose
                System.out.printf("%s Inmobiliaria: No tenemos ofertas disponibles.\n", this.myAgent.getLocalName());
                throw new RefuseException("Fallo en la evaluación.");
            }
        }
 
        protected ACLMessage ********************************************************** {
            //Hemos recibido una aceptación de nuestra oferta, enviamos el albarán
            System.out.printf("%s Inmobiliaria: Hay una posible oferta.\n", this.myAgent.getLocalName());
 
            if (devolverPrecio()) {
                System.out.printf("%s Inmobiliaria: Enviando contrato de compra.\n", this.myAgent.getLocalName());
 
                **************
        **************
        **************
            } else {
                System.out.printf("%s Inmobiliaria: Vaya!, ha fallado al enviar el contrato.\n", this.myAgent.getLocalName());
                throw new FailureException("Error al enviar contrato.");
            }
        }
 
        protected void handleRejectProposal(ACLMessage cfp, ACLMessage propose, ACLMessage reject) {
            //Nuestra oferta por el INMUEBLE ha sido rechazada
            System.out.printf("%s Inmobiliaria: Oferta rechazada por su excesivo precio.\n", this.myAgent.getLocalName());
        }
    }
}
 
**






Ejercicios 2009 (Comunicación II (segunda parte))


Ejercicio 1

El siguiente ejercicio consiste en completar el código correspondiente a la comunicación entre un agente comprador y uno o varios agentes librería.(FIPA-ContractNet).

Funcionamiento:
java jade.Boot -container nombreLibreria:agenteLibrería(libro precio libro precio...)
java jade.Boot -container nombreLibreria2:agenteLibrería(libro precio libro precio...)
...
java jade.Boot -container nombreComprador:agenteComprador(libro)


Comprador
//Esta clase se llama Comprador.java
import jade.core.AID;
import jade.core.Agent;
import jade.domain.DFService;
import jade.domain.FIPANames;
import jade.domain.FIPAAgentManagement.DFAgentDescription;
import jade.domain.FIPAAgentManagement.ServiceDescription;
import jade.lang.acl.ACLMessage;
import jade.proto.ContractNetInitiator;
import java.lang.Double;
 
 
import java.util.Date;
import java.util.Vector;
 
public class Comprador extends Agent {
 
 
//comprará el libro más barato que coincida con el titulo
private String titulo;
 
 
    protected void setup() {
        // El nombre del libro se recibirá como argumento de entrada.
 
        Object[] args = this.getArguments();
        if (args != null && args.length ==1) {
        this.titulo = (String) args[0];
        System.out.println("el libro a comprar es "+titulo);
 
 
 
            // Búsqueda del servicio de librerias en las páginas amarillas.
            ServiceDescription servicio = new ServiceDescription();
            servicio.setType("libreria");
            servicio.setName("venta de libros");
 
            DFAgentDescription descripcion = new DFAgentDescription();
            descripcion.addLanguages("castellano");
            descripcion.addServices(servicio);
 
            try {
                DFAgentDescription[] resultados = DFService.search(this, descripcion);
                if (resultados.length <= 0) {
                    System.out.println("No existen libros.");
 
                } else {
                    System.out.println("En busca del libro, tenemos " + resultados.length + " ofertas...");
 
                    // Creamos el mensaje CFP(Call For Proposal) cumplimentando sus parámetros
 
                    **** mensajeCFP = ****
                    for (**** agente:resultados) {
                        *****(****);
                        System.out.println(agente.getName());
                    }
 
        //protocolo que vamos a utilizar
 
                    mensajeCFP.***(***********);
                    ****.****(titulo);
 
 
                    // Se añade el comportamiento que manejará las ofertas.
                    **************
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
 
        } else {
            System.out.println("Número de parámetros introducidos incorrecto (nombre del libro)");
        }
 
    } // Fin del setup
 
    private class ManejoOpciones extends **************{
        public ManejoOpciones(Agent agente, ACLMessage plantilla) {
            super(agente, plantilla);
        }
 
        // Manejador de proposiciones.
 
        protected  **************{
            System.out.printf("%s: Recibida oferta de libreria %s. Ofrece el libro por %s euros.\n",
                this.myAgent.getLocalName(), propuesta.getSender().getLocalName(), propuesta.getContent());
        }
 
        // Manejador de rechazos de proposiciones.
 
        protected **************{
            System.out.printf("%s: La libreria %s no tiene nada que ofrecer.\n",
                this.myAgent.getLocalName(), rechazo.getSender().getLocalName());
        }
 
        // Manejador de respuestas de fallo.
 
        protected **************{
 
             if (fallo.getSender().equals(myAgent.getAMS())) {
            **************
            } else {
                System.out.printf("%s: La libreria %s ha sufrido un fallo.\n",
                    this.myAgent.getLocalName(), fallo.getSender().getLocalName());
            }
 
        }
 
        // Método colectivo llamado tras recibir todas las propuestas.
 
        protected **************(Vector respuestas, Vector aceptados) {
 
 
            // Escoge la mejor oferta
            double mejorOferta = Double.MAX_VALUE;
            AID mejorLibro = null;
            ACLMessage aceptado = null;
            for (Object resp:respuestas) {
                *** mensaje = *** resp;
 
                if (mensaje.**************){
                 **** respuesta = ******
                 respuesta.******
                 aceptados.*******
 
                    // Si la oferta es la mejor (inferior a todas las otras)
                    // se almacena su precio y el AID de la libreria que la hizo.
                    double oferta = Double.parseDouble(mensaje.getContent());
                    if (oferta <= mejorOferta) {
                        mejorOferta = oferta;
                        mejorLibro = mensaje.getSender();
                        aceptado = respuesta;
                    }
                }
            }
 
            // Si hay una oferta aceptada se modifica su performativa.
            if (aceptado != null) {
                System.out.printf("%s: Decidido, el libro de %s es el que compro!\n",
                    this.myAgent.getLocalName(), mejorLibro.getLocalName());
 
                    **************
            }
        }
 
        // Manejador de los mensajes inform.
 
        protected **************(**************){
            System.out.printf("%s: La libreria %s nos ha enviado el contrato!!\n",
                this.myAgent.getLocalName(), inform.getSender().getName());
        }
    }
}


Libreria
//Esta clase se llama Libreria.java
import jade.core.Agent;
import jade.domain.DFService;
import jade.domain.FIPAException;
import jade.domain.FIPANames;
import jade.domain.FIPAAgentManagement.DFAgentDescription;
import jade.domain.FIPAAgentManagement.FailureException;
import jade.domain.FIPAAgentManagement.NotUnderstoodException;
import jade.domain.FIPAAgentManagement.RefuseException;
import jade.domain.FIPAAgentManagement.ServiceDescription;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
import jade.proto.ContractNetResponder;
 
import java.util.Hashtable;
 
public class Libreria extends Agent {
 
 
    // Lista de libros, donde cada libro tendrá un precio asociado
    private Hashtable<String, Double> listaLibros;
 
    private boolean enLista(String libro) {
        return libro != null && this.listaLibros.containsKey(libro);
    }
 
 
    protected void **************(){
        try {
            // Creación de la lista de libros del vendedor.
            this.listaLibros = new Hashtable<String, Double>();
            Object[] argumentos = this.getArguments();
            int j=0;
            for (int i=0; i<argumentos.length; i+=2) {
                j++;
                this.listaLibros.put((String) argumentos[i], Double.parseDouble((String) argumentos[i+1]));
                System.out.print("El libro "+j+" de la libreria es "+(String)argumentos[i]);
                System.out.println(" y su precio es "+(String)argumentos[i+1]);
 
            }
 
 
 
            // Registro del servicio de librería en las páginas amarillas.
            ServiceDescription servicio = new ServiceDescription();
            servicio.setType("**************");
            servicio.setName("**************");
 
            DFAgentDescription descripcion = new DFAgentDescription();
            descripcion.setName(getAID());
            descripcion.addLanguages("castellano");
            descripcion.addServices(servicio);
 
        try {
            DFService.register(this, descripcion);
        } catch (FIPAException e) {
            e.printStackTrace();
        }
 
 
 
 
            // Se crea la plantilla y añade el comportamiento
 
            MessageTemplate plantilla = **************
 
            this**************(new CrearOferta(this,**************));
 
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Argumentos no válidos.");
        }
 
    }
 
    private class  CrearOferta  **************{
 
        public CrearOferta(Agent agente, MessageTemplate plantilla) {
            super(agente, plantilla);
        }
 
         //Prepara respuesta
         protected **************(****)*********{
          String libro = cfp.getContent();
          System.out.printf("Libreria %s: Peticion de oferta recibida de %s por %s.\n", this.myAgent.getLocalName(), cfp.getSender().getLocalName(),libro);
 
 
 
        if (Libreria.this.enLista(libro)) {
            Double precio = Libreria.this.listaLibros.get(libro);
            System.out.printf("Libreria %s preparando oferta con precio %s\n",this.myAgent.getLocalName(),precio);
 
                //Se crea el mensaje de respuesta
 
                ***************************
                ***************************
                **************.setContent(String.valueOf(precio));
                return **************;
 
            } else {System.out.printf("Libreria %s: No tenemos ofertas disponibles.\n", this.myAgent.getLocalName());
                throw new **************("***********");
            }
 
}
 
           //prepara notificación
             protected **************(**************)*********{
            //Hemos recibido una aceptación de nuestra oferta, enviamos el albarán
 
            String libro=cfp.getContent();
 
            if (Libreria.this.enLista(libro)) {
                System.out.printf("Libreria %s: Enviando contrato de compra.\n", this.myAgent.getLocalName());
 
                  //enviar informe
                  *** inform =*****
                  **************
                  *********
 
            } else {
                System.out.printf("Libreria %s: Vaya!, ha fallado al enviar el contrato.\n", this.myAgent.getLocalName());
                **************
            }
        }
 
 
 
        //manejador Rechazo
                 **************
 
 
 
        }
    }
}


Ejercicio 2

Comentar brevemente el funcionamiento del código del ejercicio anterior.