[JAVA] Aiuto esercizio d'esame...

[Rintrah84]

Ciao,
tra qualche giono dovrò sostenere un secondo esame di Java...mi sono un po' bloccato con questo esercizio (che ho risolto in parte)...mi date una mano per favore?

Il testo dice:

Un insieme di processi condividono un unico buffer, di dimensioni illimitate, in cui possono scrivere e prelevare dati di tipo generico ma capaci di misurarsi.
Ciascun processo è caratterizzato dallo specifico tipo di dato che può scrivere e leggere dal buffer ed opera nella maniera seguente:

1) I processi possono iniziare ad operare solo dopo che il buffer è stato creato.

2) Un processo sa scrivere in fondo al buffer un dato del suo tipo, che riceve in input.

3) Un processo sa leggere dal buffer un dato del suo tipo: a questo scopo, tiene traccia della posizione p dell’ultimo dato del suo tipo letto dal buffer e, a partire dalla posizione p, cerca il successivo dato del suo tipo e lo restituisce in output.

4) Un processo sa cercare nel buffer un dato del suo tipo di misura minima; se tale dato esiste ed è unico
esso viene restituito in output, se esistono più dati del tipo corretto di valore minimo viene comunicato il numero di dati di valore minimo individuati, se il buffer non contiene alcun dato del tipo corretto viene comunicata la lista dei tipi dei dati contenuti nel buffer.

Si richiede l’implementazione in Java del tipo di dato Processo e degli altri eventuali tipi coinvolti.

Allora...io l'ho pensato così:

Inizialmente realizzo un'interface chiamata Misurabile che rappresenterà la caratteristica comune a tutti i tipi che la implementano e che potranno essere scritti nel buffer, ovvero la capacità di restituire la misura dell'oggetto:


/** OVERVIEW: Si tratta di un'interface che descrive la caratteristica comune ad una serie di tipi che la implementeranno:
ovvero la capacità di restituire al chiamante la propria misura */

public interface Misurabile{
double misura(); // Ogni elemento di tipo Misurabile deve essere capace di misurarsi
}


Poi implemento il tipo BufferDiMisurabili che mi rappresenta il mio buffer che viene condiviso dai vari processi:


/** OVERVIEW: La classe rappresena un buffer, di dimensioni illimitate, in cui un insieme di processi possono scrivere o
leggere un dato di tipo Misurabile */

private class BufferDiMisurabili{

private Vector BufferMisurabili; // Il buffer di dimensioni illimitate viene rappresentato da un Vector

/* Rappresenta lo stato del buffer: true se il buffer è stato creato, false altrimenti. Inizialmente è settato a false */
private boolean statoBuffer = false;

/** EFFETCTS: Crea un nuovo buffer di oggetti misurabili e setta a true lo stato del buffer
@param: void
@return: Il riferimento ad un oggetto di tipo BufferDiMisurabili */

public BufferDiMisurabili(){
V = new Vector(); // Crea un buffer vuoto
statoBuffer = true; // Setta a true statoBuffer così da identificare che il buffer è stato creato ed è pronto all'uso
}

/** EFFECTS: Inserisce un generico oggetto di tipo Misurabile dentro il buffer se questo è stato creato, altrimenti
solleva una failureException
@param: Il riferimento ad un oggetto Misurabile
@return: void */

public set(Misurabile m){
if(statoBuffer == true) // Se il buffer è stato creato
V.addElement(m); // Aggiunge il parametro al buffer
else throw new FailureException(); // Altrimenti solleva un'eccezione
}
................
................
.................

}


A questo punto iniziano i problemi ed i dubbi su come fare quello che devo fare:

1) Per quanto riguarda l'inserimento in fondo al buffer di un generale dato Misurabile non credo ci siano problemi, invece per quanto riguarda la lettura? dentro la classe che rappresenta il buffer cosa ci devo mettere?

2) Come implemento la classe processo? Possono essere tanti tipo di processi...processi che leggono e scrivono interi,processi che leggono e scrivono stringhe e così via? Devo usare una classe abstract che ne rappresenta la struttura comune e poi estenderla ed ognuna di esse userà un proprio ditpo di oggetto Misurabile? Ad esempio ho un processo lettore e scrittore di interi che userà al proprio interno un InteroMisurabile che implemente Misurabile

Qualche consiglio?

Tnx

[javacomelava]

ehehe...sempre piu persona di informatica a tor vergata scrivono qui.Comunque L'approccio che hai usato è sbagliato.L'interfaccia va bene ma Il Testo ti chiede che i processi CONDIVIDONO LO STESSO BUFFER,questo dovrebbe farti capire che il buffer va inteso come variabile di classe,all'interno della classe Processo.
avrai un metodo di classe che inizializza il buffer(che poi è un Vector),e solo dopo averlo inizialiatto puoi inserire un processo,se possibile,in base ai vincoli successivi.

Poi attenzione a quando inserisci un Misurabile nel buffer,dovresti controllare che il tipo effettivo sia sempre lo stesso.Cosi come hai fatto tu potresti inserire nel buffer rettangoli misurabili,Frazioni misurabili,articoli misurabili,cavalli misurabili e cosi via.Se cosi' fosse come fai a stabilire chi ha maggior misura tra una Frazione Misurabile e un Rettangolo Misurabile???

Per il controllo dei tipi effettivi puoi usare:

CONTROLLO STATICO:

instanceof

CONTROLLO DINAMICO:

metodo di istanza della classe Class: isInstance()

Dai uno sguarda alla documentazione per utilizzarli.



Se hai problemi comunque posso inviarti la soluzione via p.m.

Auguri per l'esame con la buona Miriam :D

[Rintrah84]

ehehe...sempre piu persona di informatica a tor vergata scrivono qui.Comunque L'approccio che hai usato è sbagliato.L'interfaccia va bene ma Il Testo ti chiede che i processi CONDIVIDONO LO STESSO BUFFER,questo dovrebbe farti capire che il buffer va inteso come variabile di classe,all'interno della classe Processo.
avrai un metodo di classe che inizializza il buffer(che poi è un Vector),e solo dopo averlo inizialiatto puoi inserire un processo,se possibile,in base ai vincoli successivi.

Poi attenzione a quando inserisci un Misurabile nel buffer,dovresti controllare che il tipo effettivo sia sempre lo stesso.Cosi come hai fatto tu potresti inserire nel buffer rettangoli misurabili,Frazioni misurabili,articoli misurabili,cavalli misurabili e cosi via.Se cosi' fosse come fai a stabilire chi ha maggior misura tra una Frazione Misurabile e un Rettangolo Misurabile???

Per il controllo dei tipi effettivi puoi usare:

CONTROLLO STATICO:

instanceof

CONTROLLO DINAMICO:

metodo di istanza della classe Class: isInstance()

Dai uno sguarda alla documentazione per utilizzarli.



Se hai problemi comunque posso inviarti la soluzione via p.m.

Auguri per l'esame con la buona Miriam :D

Miriaaammmm mi ha già steccato una volta ad MP...e dire che LP era andato liscio liscio 27 alla prima botta :cry: :cry: :cry:

Ti ringrazio per la dritta...è un mese che non tocco Java per dare altre schifezze e sono un po' arruginiti...in effetti la storia del buffer è proprio come dici te, è una variabile di istanza il Vector...non ci stavo pensando :doh:

Ho solo un dubbio su quello che dici: il testo dice esplicitamente che un insieme di processi diversi (che scrivono e leggono tipi di dato diversi) condividono il buffer...quindi nel buffer potrei avere appunto un intero misurabile, un double misurbaile, un rettangolo misurabile, etcetc...nel buffer ci posso mettere dentro qualsiasi misurabil (cioè...ce lo mette il relativo processo che gestisce quel tipo di dati).

A conferma di ciò credo ci siano i punti 3 e 4 delle spechifiche:


3) Un processo sa leggere dal buffer un dato del suo tipo: a questo scopo, tiene traccia della posizione p dell’ultimo dato del suo tipo letto dal buffer e, a partire dalla posizione p, cerca il successivo dato del suo tipo e lo restituisce in output.

4) Un processo sa cercare nel buffer un dato del suo tipo di misura minima; se tale dato esiste ed è unico
esso viene restituito in output, se esistono più dati del tipo corretto di valore minimo viene comunicato il numero di dati di valore minimo individuati, se il buffer non contiene alcun dato del tipo corretto viene comunicata la lista dei tipi dei dati contenuti nel buffer.


Il processo per leggere un dato del suo tipo lo deve cercare all'interno del buffer e stessa cosa vale per la ricerca...

mmm confermi o smentisci? :D
Altra cosa...ma quà dentro secondo te serve metterci un iteratore o me lo posso risparmiare?

Tnx ;)

[javacomelava]

Confermo che hai ragione.

Ti ricordo però che in ogni caso tu non puoi "confrontare" due misurabili diversi potresti quindi inserire un'altro metodo dell'interfaccia che controlla se due tipi misurabili sono effettivamente dello stesso tipo effettivo.


public interface Misurabile{

//Altri metodi

boolan confrontaMisurabili(Misurabile M);

}

(comunque per quest'ultima cosa,sono io che mi faccio le paranoie,magari per l'esercizio in questione non serve nemmeno).

Attenzione,il BUFFER E' UNA VARIABILE DI CLASSE NON DI ISTANZA!

[Rintrah84]

Confermo che hai ragione.

Ti ricordo però che in ogni caso tu non puoi "confrontare" due misurabili diversi potresti quindi inserire un'altro metodo dell'interfaccia che controlla se due tipi misurabili sono effettivamente dello stesso tipo effettivo.


public interface Misurabile{

//Altri metodi

boolan confrontaMisurabili(Misurabile M);

}

(comunque per quest'ultima cosa,sono io che mi faccio le paranoie,magari per l'esercizio in questione non serve nemmeno).

Attenzione,il BUFFER E' UNA VARIABILE DI CLASSE NON DI ISTANZA!

mmm ho scritto di istanza? sono rinkojonito...il concetto era di classe...è uno condiviso da tutte le istanze...rinkojonimento mio :)

[morskott]

per svago ho provato a implementare l'esercizio, vedi se ti può esser utile/*
Un insieme di processi condividono un unico buffer, di dimensioni illimitate, in cui possono scrivere e prelevare dati di tipo generico ma capaci di misurarsi.
Ciascun processo è caratterizzato dallo specifico tipo di dato che può scrivere e leggere dal buffer ed opera nella maniera seguente:

1) I processi possono iniziare ad operare solo dopo che il buffer è stato creato.

2) Un processo sa scrivere in fondo al buffer un dato del suo tipo, che riceve in input.

3) Un processo sa leggere dal buffer un dato del suo tipo: a questo scopo, tiene traccia della posizione p dell’ultimo dato del suo tipo letto dal buffer e,
a partire dalla posizione p, cerca il successivo dato del suo tipo e lo restituisce in output.

4) Un processo sa cercare nel buffer un dato del suo tipo di misura minima; se tale dato esiste ed è unico
esso viene restituito in output, se esistono più dati del tipo corretto di valore minimo viene comunicato il numero di dati di valore minimo individuati,
se il buffer non contiene alcun dato del tipo corretto viene comunicata la lista dei tipi dei dati contenuti nel buffer.

Si richiede l’implementazione in Java del tipo di dato Processo e degli altri eventuali tipi coinvolti.
*/

import java.util.*;

interface Dato extends Comparable<Dato>{

}
class Buffer{
private Map<Class<? extends Dato>,List<Dato>> buf;

public Buffer(){
this.buf=new HashMap<Class<? extends Dato>,List<Dato>>();
}

public void add(Dato d){
List<Dato> vect=this.buf.get(d.getClass());
if (vect==null){
vect=new LinkedList<Dato>();
this.buf.put(d.getClass(),vect);
}
vect.add(vect.size(),d);
}

public Dato get(Class<? extends Dato> claz,int p){
List<Dato> vect=this.buf.get(claz);
if (vect==null) return null;
if (vect.size()<=p) return null;
return vect.get(p);
}

public Dato getMinimo(Class<? extends Dato> claz) throws DatiMultipliException,DatoNonEsistenteException{
List<Dato> vect=this.buf.get(claz);
if (vect==null) throw new DatoNonEsistenteException(this.buf.keySet());
Set<Dato> d=new HashSet<Dato>();
d.add(vect.get(0));
Dato curr=vect.get(0);
for (int i=1;i<vect.size();i++){
Dato temp=vect.get(i);
if (temp.compareTo(curr)<0){
d.clear();
d.add(temp);
curr=temp;
}
if (temp.compareTo(curr)==0){
d.add(temp);
}
}
if (d.size()!=1) throw new DatiMultipliException(d.size());
return curr;
}
}
class DatiMultipliException extends Exception{
private int num;

public DatiMultipliException(int num){
this.num=num;
}

public int getNum(){
return this.num;
}
}
class DatoNonEsistenteException extends Exception{
private Set<Class<? extends Dato>> tipiDato;

public DatoNonEsistenteException(Set<Class<? extends Dato>> tipi){
this.tipiDato=tipi;
}

public Set<Class<? extends Dato>> getTipiDato(){
return this.tipiDato;
}
}

public class Processo implements Runnable{
private Class<? extends Dato> tipoDiDatoDiInteresse;
private Buffer buf;

public Processo(Class<? extends Dato> dat){
this.tipoDiDatoDiInteresse=dat;
}

public void setBuffer(Buffer buf){
this.buf=buf;
}

public void run(){
while (this.buf==null){
Thread.yield();
}
List<Dato> dati=new LinkedList<Dato>();
Random rand=new Random();
int max=rand.nextInt(10)+1;
for (int i=0;i<max;i++){
try{
dati.add(this.tipoDiDatoDiInteresse.newInstance());
} catch(InstantiationException ex){
System.out.println("Non dovrebbe accadere");
} catch(IllegalAccessException ex){
System.out.println("Non dovrebbe accadere");
}
}
for (int i=0;i<dati.size();i++){
this.buf.add(dati.get(i));
}
int p=0;
Dato d=this.buf.get(this.tipoDiDatoDiInteresse,p);
while(d!=null){
System.out.println(d.toString());
p++;
d=this.buf.get(this.tipoDiDatoDiInteresse,p);
}
try{
Dato min=this.buf.getMinimo(this.tipoDiDatoDiInteresse);
System.out.println("Il dato minore risulta: "+min.toString());
} catch(DatiMultipliException ex){
System.out.println("Son presenti "+String.valueOf(ex.getNum())+" valori minimi");
} catch(DatoNonEsistenteException ex){
Set<Class<? extends Dato>> tipi=ex.getTipiDato();
System.out.println("Son presenti i seguenti tipi:");
for (Class<? extends Dato> c:tipi){
System.out.println(c.getName());
}
}
}

public static void main(String[] args){
Processo p1=new Processo(Scarpa.class);
Processo p2=new Processo(Libro.class);
Thread t1=new Thread(p1);
Thread t2=new Thread(p2);
t1.start();
t2.start();
Buffer b=new Buffer();
p1.setBuffer(b);
p2.setBuffer(b);
}
}

class Scarpa implements Dato{
private int numero;

public Scarpa(){
Random rand=new Random();
this.numero=rand.nextInt(50);
}

public int compareTo(Dato d){
Scarpa s=(Scarpa)d;
return this.numero-s.numero;
}

public String toString(){
return "Scarpa numero "+String.valueOf(this.numero);
}
}
class Libro implements Dato{
private int numeroPagine;

public Libro(){
Random rand=new Random();
this.numeroPagine=rand.nextInt(50);
}

public int compareTo(Dato d){
Libro s=(Libro)d;
return this.numeroPagine-s.numeroPagine;
}

public String toString(){
return "Libro lungo "+String.valueOf(this.numeroPagine)+" pagine";
}
}

[Rintrah84]

Ti ringrazio...ma ci hai messo in mezzo varie cosucce di cui non ho la minima idea di cosa si tratti come Maps ed un sacco di altre cose...io alla fine l'ho risolto in quest'altro modo, probabilmente più rozzo...se hai tempo gli puoi dare un'occhiata e dirmi se l'idea può andare?

Ho sempre l'interface Misurabile:


/** OVERVIEW: Si tratta di un'interface che descrive la caratteristica comune ad una serie di tipi che la implementeranno:
ovvero la capacità di restituire al chiamante la propria misura */

public interface Misurabile{
double misura(); // Ogni elemento di tipo Misurabile deve essere capace di misurarsi
}


e la classe Processo l'ho realizzata nel seguente modo:


import java.util.*;

/** OVERVIEW: Si tratta di una classe che rappresenta un insieme di processi che leggono e scrivono dati di tipo Misurabile
su di un buffer illimitato.
Tale classe verrà poi estesa da altre sottoclassi che rappresentano processi di varia natura e che si
diferenziano in base al tipo effetivo di dato Misurabile che leggono o scrivono nel buffer */

public class Processo{

/* Il buffer condiviso dai vari processi viene rappresnentato mediante un Vector definito come variabile di classe */
private static Vector buffer;

static boolean statoBuffer = false; // TRUE: il buffer è stato creato; FALSE: il buffer non è stato creato

static int ultimo; // Contiene l'ultima posizione scritta all'interno del buffer

/* Contiene la posizione p dell'ultimo dato del suo tipo che un determinato processo ha letto dal buffer */
private int posizione = -1; // Inizialmente è settato ad un valore non valido perchè non ha ancora letto nulla

/* Contiene la posizione p del primo dato inserito nel buffer da un processo, inizialmente settata a -1 per indicare che
il processo non ha ancora inserito nulla nel buffer */
private int primo = -1;

private boolean isFirst = true; // Dopo aver inserito il primo elemento nel buffer viene settata a false

/** EFFECTS: Si tratta di un metodo di classe che crea il buffer (rendendo possibile le operazioni dei processi su di
esso) e setta a TRUE la variabile statoBuffer. Tale metodo è comune a tutti i tipi di processi e viene
implementato nella classe abstract */

public static void creaBuffer(){

if(statoBuffer = false){ // Se il buffer non è stato ancora creato
buffer = new Vector(); // Crea il nuovo buffer
statoBuffer = true; // Setta a true statoBuffer per avvertire i processi che il buffer è creato e pronto all'uso
ultimo = -1; // Non è ancora stato scritto nulla nel buffer
}

/* Altrimenti solleva un'eccezione che avverte i processi che il buffer era già esistente e pronto all'uso */
else throw new BufferEsistenteException();
}

/** EFFETCS: Inserisce un qualsiasi oggetto di tipo Misurabile nel buffer se il buffer è stato correttamente creato,
altrimenti solleva un'eccezione
@param: il riferimento ad un oggetto Misurabile */

public void inserisci(Misurabile m){

if(statoBuffer = false) throw new FailureException(); // Se il buffer non è stato creato solleva un'eccezione

/* Altrimenti se il buffer è stato creato e se si tratta del primo elemento ad essere inserito dal processo */
else if(isFirst = true){
buffer.addElement(m); // Inserisci l'elemento nella prima posizione
ultimo ++; // Incrementa di 1 il contatore dell'ultimo elemento inserito nel buffer
/* La posizione del primo elemento scritto dal processo nel buffer è la posizione dell'ultimo elemento scritto */
primo = ultimo;
isFirst = false; // Cambia lo stato di isFirst
}

/* Se invece il buffer è stato creato ma non si tratta del primo inserimento fatto dal processo bisogna controllare
a runtime che il tipo effettivo dell'elemento che si stà tentando di inserire sia lo stesso del primo elemento
inserito dal processo nel buffer (che caratterizza il processo) */
else{
/* Se il tipo del primo elemento inserito dal processo è lo stesso del parametro m */
if(buffer.elementAt(primo).getClass().isInstance(m)){
buffer.addElement(m); // Inserisci l'elemento nella prima posizione
ultimo ++; // Incrementa di 1 il contatore dell'ultimo elemento inserito nel buffer
}
else throw new FailureException(); // Altrimenti solleva un'eccezione
}

}

/** EFFECTS: Se il buffer è stato creato, il processo legge un dato del suo tipo. Il dato letto è il successore
dell'ultimo dato precedentemente letto dal processo
REQUIRES: Si assume che il buffer sia stato precedentemente creato
@param: void
@return: Un qualsiasi oggetto che implementa Misurabile */

public Misurabile leggi(){

/* Variabile contatore per scorrere i dati nel buffer che viene fatta partire dalla posizione dell'elemento
successivo dell'ultimo elemento letto dal processo */
int i = posizione + 1;

while(i < buffer.size()){ // Scorre il buffer fino alla fine

/* Se l'oggetto in posizione i del buffer ha lo stesso tipo effettivo del primo elemento inserito nel buffer
dal processo (il cui tipo caratterizza il processo) */
if(buffer.elementAt(primo).getClass().isInstance(buffer.elementAt(i))){
return (Misurabile) buffer.elementAt(i); //Se lo trova ritorna al chiamante l'i-esimo elemento
}

i++; // Passa all'elemento successivo
}

throw new FailureException("Non trovato"); // Se non lo trova allora solleva una FailureException con testo
}

/** EFFECTS: Il processo cerca nel buffer il dato relativo al suo tipo avente misura minima. Se lo trova ed è unico
lo restituisce in output; Se esistono più dati del tipo corretto aventi valore minimo allora viene
comunicato in output anche il numero di dati aventi valore minimo; Se e il buffer non contiene alcun dato
del tipo corretto viene comunicata la lista dei tipi dei dati contenuti nel buffer
REQUIRES: Si assume che il buffer sia stato precedentemente creato */

public void cercaElementoMinimo(){

int posizioneMinimo;
int i; // Contatore per scorrere il buffer

if(primo == -1){ // Se il processo non ha ancora inserito neanche un dato del suo tipo nel buffer
for(i=0; i<buffer.size(); i++) // Scorri tutti gli elementi del buffer e stampane il relativo tipo
System.out.println("L'elemento in osizione: " + i + "contiene un dato di tipo: " + buffer.elementAt(i).getClass());
}

else{ // Altrimenti significa che il processo ha già scritto almeno un dato del suo tipo nel buffer

/* Inizialmente la posizione del minimo è la posizione del primo elemento inserito nel buffer dal processo */
posizioneMinimo = primo;

int numeroMinimi = 0; // Contiene il numero degli elementi minimi trovati nel buffer

/* Fai partire la scansione di ricerca dall'elemento minimo dalla posizione successiva al primo elemento
inserito nel buffer dal processo */
i = primo + 1;

while(i < buffer.size()){ // Scorre il buffer fino alla fine

/* Se l'elemento del buffer in posizione i ha lo stesso tipo effettivo del primo dato inserito nel buffer
dal processo (quindi del dato che caratterizza il processo) */
if(buffer.elementAt(primo).getClass().isInstance(buffer.elementAt(i))){
/* Se l'elemento in posizione i è minore del'elemento minimo correntemente trovato */
if(buffer.elementAt(i).misura() < buffer.elementAt(posizioneMinimo).misura()){
posizioneMinimo = i; // L'elemento in posizione i diventa il nuvo elemento minimo
i++; // Passa all'elemento successivo
numeroMinimi = 1; // Se trova un nuovo minimo resetta ad 1 il valore del numero dei minimi trovati
}

/* Se l'elemento in posizione i ha lo stesso valore dell'elemento minimo */
else if(buffer.elementAt(i).misura() == buffer.elementAt(posizioneMinimo).misura())
numeroMinimi ++; // Incrementa il numero degli elementi minimi trovati fino ad ora

else // Se l'elemento in posizione i è maggiore dell'elemento minimo trovato
i++; // Passa ad analizare il prossimo elemento del buffer

}

/* Se l'elemento in posizione i non ha lo stesso tipo effettivo del dato che caratterizza il processo */
else{
i++; // Lo ignora (non esegue il confronto) e passa al prossimo elemento del buffer
}
} // Fine del while di scansione del buffer

/* A QUESTO PUTO VIENE RESTITUITA UNA RISPOSTA ALL'UTENTE */

if(numeroMinimi == 1) // Significa che il minimo esiste ed è unico
System.out.println("Il valore minimo scritto dal processo nel buffer è: " + buffer.elementAt(posizioneMinimo));

else{ // Altrimenti significa che ci sono più minimi aventi lo stesso valore nel buffer scriti dal processo
System.out.println("Il valore minimo scritto dal processo nel buffer è: " + buffer.elementAt(posizioneMinimo));
System.out.println("Il numero di valori minimi scritti dal processo nel buffer è:" + numeroMinimi);
}

}
} // Fine del metodo CercaElementoMinimo


}


Qualche nota rapida sull'implementazione della classe Processo:

1) La classe Processo rappresenta TUTTI i tipi di processo, ad ogni oggetto di tipo Processo è associato un suo specifico tipo che implementa l'interface Misurabile. IL TIPO DI UN PROCESSO VIENE IDENTIFICATO DAL TIPO DEL PRIMO DATO CHE SCRIVE NEL BUFFER CONDIVISO.

Ad esempio se un processo scrive nel buffer il tipo InteroConfrontabile come primo dato da lui scritto --> Dopo questa prima scrittura potrà leggere, scrivere e cercare all'interno del buffer solo dati di tipo InteroConfrontabile.

Per fare questa cosa ho usato le seguenti variabili:

1.1) Variabile primo di tipo int che contiene la posizione p del primo dato inserito nel buffer da un processo.

1.2) La variabile booleana isFirst che mi dice se un dato che si vuole inserire nel buffer è il primo dato che il processo vuole scrivere (se è true allora può scrivere un qualsiasi Misurabile nel buffer, se è false deve controllare che sia del tipo corretto ed il controllo viene fatto confrontando il tipo effettivo del parametro ricevuto dal metodo inserisci con il tipo effettivo del primo oggetto scritto dal processo...se hanno lo stesso tipo effettivo il processo lo scrive nel buffer altrimenti solleva un'eccezione.

Poi vabbè c'è il metodo leggi() che è abbastanza semplice, si salva in una variabile la posizione dell'ultimo elemento letto dal buffer del tipo associato al processo e ne cerca il successivo nel buffer

Ed infine il metodo cercaMinimo che dovrebbe fare quanto richiesto dalle specifiche.

Secondo te è accettabile come implementazione?

Grazie