Newsgroup: it.lavoro.informatica
Titolo: Scusate(non è una trollata) ho bisogno

di sapere come si tratta in java questa roba qui.
 
01 CAMPO-UNICO PIC X(30).
01 CAMPO-NOME REDEFINES CAMPO-UNICO.
      02 COGNOME PIC X(15).
      02 NOME PIC X(15).
      02 NOMI REDEFINES NOME.
          03 PRIMO-NOME PIC X(7).
          03 FILLER PIC X.
          03 SECONDO-NOME PIC X(07).
 
-- 
(..) la rivoluzione non è un pranzo di gala, non è una festa letteraria, 
non è un disegno o un ricamo; non si può
fare con tanta eleganza, con tanta serenità e delicatezza, con tanta 
grazia e cortesia. La rivoluzione è un atto
di violenza, è l'azione implacabile di una classe che abbatte il potere 
di un'altra classe. (Mao Tze-tung)

 di sapere come si tratta in java questa roba qui.
 
si tratta così:
 
new File("troiaio.cbl").delete();


no, scusa, sto parlando sul serio, non si puo fare?


 
 
La consulenza si paga.
 
 


cioe non lo sai



Prova a chiedere su it.scienza.informatica, anche per tutto il resto.
Li c'è più giro.
 

           03 SECONDO-NOME PIC X(07).
 
 
01 ma incolli gli snippet fatti da altri?
 
02 
http://www.nicolamaggi.it/Cobol/areelav.htm
 
 
03 io non sono un vero programmatore (ho solo python e ruby nel mio 
bagaglio) quindi non mi pongo tanto il problema di dare risposte che siano 
perfette e precise. Ma qual è il problema insito nel quesito? REDEFINES è 
un pointer? Puoi simulare i pointer in python con 3 righe di codice se non 
sono supportati. 
 
04  devo ammettere che mi stupisce un po' che gli altri facciano finta di 
non voler rispondere. 
 
 
 
-- 
Massimiliano Adamo

           03 SECONDO-NOME PIC X(07).
 
Semplice:
 
    class Name {
        private final String firstName;
        private final String middleName;
        private final String lastName;
 
        public Name(String firstName, String middleName, String lastName) {
            this.firstName = firstName;
            this.middleName = middleName;
            this.lastName = lastName;
        }
 
        public String getFirstName() {
            return firstName;
        }
 
        public String getMiddleName() {
            return middleName;
        }
 
        public String getLastName() {
            return lastName;
        }
 
        public String getFullName() {
            return firstName + " " + middleName + " " + lastName;
        }
    }
 
Pulito, chiaro, leggibile (niente 01, 02, 03, i FILLER, i PIC, le indentazioni, e stronzate varie), immutable (come ogni classe dovrebbe essere) e facilmente testabile (magari in TDD).


OK! ma allora è vero che Morde non capisce un cazzo. Sei bravo...cazzo!


Il 01/03/2015 23.03, 4ndre4 ha scritto:

anzi ti diro di piu, mi hai fatto venire voglia di buttarmi sul java.


Il 01/03/2015 23.03, 4ndre4 ha scritto:

te non ci crederai mai, ma sai che quelli del mainframe non passano a 
java perchè non riescono a capire sta cosa? .... non solo questa ...ma 
per esempiio questa. Bravo andrea.



boh, premetto di non averi capito, perché leggo male il javese :)
 
con python 2:
 
def delta11(name, middlename, surname):
    print name + " " + middlename + " " + surname
 
while True: 
    myname = raw_input("enter Surname: ")
    mysurname = raw_input("enter Name: ")
    mymiddlename = raw_input("enter MiddlenameName: ")
    delta11(myname, mysurname,  mymiddlename)
 
 
Ma se mi spiegate meglio lo sistemo. 
 
 
-- 
Massimiliano Adamo


no è sbagliato devi scrivere una classe che sia in grado di 
restituire/gestire il cognome+ il nome1 + il nome2  oppure tutti insieme 
oppure singolarmente


 oppure singolarmente
 
wow

 java perchè non riescono a capire sta cosa?
 
Eh, lo so. Ma e` anche per questo che nel mondo dello sviluppo software, oggi facciamo benissimo a meno di loro.


 
le union non esistono in java quindi una traduzione pari pari non è 
possibile (è possibile in C  e C++ invece)
Si aggira il tutto usando il metodo substring della classe String o 
(ancora meglio) lavorare in modo logico sul problema (non a basso 
livello come in COBOL) costruendo una classe
 

 non voler rispondere. 
 
Io ieri ero in montagna.
Secondo te, quando sono in montagna, mi preoccupo di cosa può scrivere qualcuno in un newsgroup?
 
(hint: no).
 
;-)
 
-- 
Ciao!
Luca

 boh, premetto di non averi capito, perché leggo male il javese :)
 
Beh, dai, le classi e gli accessors si fanno anche in Python (e si scrivono _quasi_ allo stesso modo)... ;)
 
-- 
Ciao!
Luca

 oppure singolarmente
 
Invece, per quel che ti riguarda, 'filler'... Sono eoni che non lo vedo!

 possibile (è possibile in C  e C++ invece)
 
Dal mio punto di vista, le union erano utilissime in un contesto in cui non esistevano le classi (e anche, in effetti, per fare porcherie a basso livello che non è più il caso di fare... ;-)).
Avendo le classi, le union hanno un perso quasi del tutto la loro utilità.
 
-- 
Ciao!
Luca.
 

 livello come in COBOL) costruendo una classe
 
Invece si può fare, in Java ed altri linguaggi. Fai un bell'array di caratteri e puoi emulare esattamente il Cobol, in particolare l'istruzione REDEFINES, sia in lettura che in scrittura (se è quello che interessa).

 anzi ti diro di piu, mi hai fatto venire voglia di buttarmi sul java.
 
Non lo fare, il tuo capo potrebbe mandarti davanti all'inquisizione
e farti torturare a morte per eresia.
 
 

 boh, premetto di non averi capito, perché leggo male il javese :)
 
Il problema e` che non hai capito il codice COBOL scritto da Delta11 :)


dai, ci mancherebbe :) mi riferivo esclusivamente a quanti hanno risposto "la
 consulenza si paga", "lo so ma non lo dico" ... 


questa era una premessa sottintesa :)


Quoto: wow :)

 anzi ti diro di piu, mi hai fatto venire voglia di buttarmi sul java.
 
Puoi provarci, ma non hai molte possibilita`.
 
Poi fammi sapere come scrivere questo in COBOL:
 
List<User> ngTrolls = ngUsers.stream().filter(u -> u.age > 180 || u.name.startsWith("Del")).collect(Collectors.toList());


Dipende dall'uso.
Una possibile implementazione che permette di partire e regredire al 
campo unico, ma anche accedere al singolo campo, a meno dei controlli su 
lunghezze e null, potrebbe essere:
public class Nomi {
  String primo, secondo;
  public Nomi() {
    super();
  }
  public Nomi(String nomi) {
    this();
    parse(nomi);
  }
  public Nomi(String primo, String  secondo) {
   this();
   this.primo = primo;
   this.secondo = secondo;
  }
  public void parse(String nomi) {
   primo = nomi.subString(0, 7);
   secondo = nomi.subString(8);
  }
  public String getPrimo() {
   return primo;
  }
  public String getSecondo() {
   return secondo;
  }
  public void setPrimo(String primo) {
   this.primo = primo;
  }
  public void setSecondo(String secondo ) {
   this.secondo = secondo ;
  }
  public String format() {
    return String.format("%7s %7s", primo, secondo);
  }
}
public class Unico {
   String cognome;
   Nomi nomi;
  public Unico() {
    super();
  }
  public Unico(String unico) {
    this();
    parse(unico);
  }
  public Unico(String cognome, Nomi nomi) {
    this();
    this.cognome= cognome;
    this.nomi= nomi;
  }
  public Unico(String cognome, String primo, String  secondo) {
    this();
    this.cognome= cognome;
    this.nomi= new Nomi(primo, secondo);
  }
  static void parse(String unico ) {
   cognome= unico.subString(0, 15);
   nomi = new Nomi(unico.subString(15));
  }
  public String getCognome() {
   return cognome;
  }
  public void setCognome(String cognome) {
   this.cognome= cognome;
  }
  public Nomi getNomi() {
   return nomi;
  }
  public void setNomi(Nomicognome) {
   this.nomi= nomi;
  }
  public  String format() {
    return String.format("%15s %15s", cognome, nomi.format());
  }
}
 
In modo un po' piu' brutale, ma sostanzialmente con le stesse funzionalita':
public class Unico {
  String unico;
  public Unico(String unico) {
    super();
    this.unico = unico;
  }
  public String getCognome() {
   return unico.subString(0, 15);
  }
  public Nomi getNomi() {
   return unico.subString(15);
  }
  public String getPrimo() {
   return unico.subString(15, 22);
  }
  public String getSecondo() {
   return unico.subString(23);
  }
  public String getUnico() {
   return unico;
  }
 
}
 


 
Vero, possono essere comunque ancora utili in casi particolari
 
Da non abusarne come tutto nella vita
 


Ho scritto una traduzione pari pari, non che non si possa fare
 


Tutto sto casino per emulare delle redefines ?
 
 
Non è meglio una classe NomeCognome tipo:
 
class NomeCognome {
	public NomeCognome(String) { .. }
	public String Cognome() {...}
	public String Nome1() { ...}
	public String Nome2() { ...}
}
 
In fondo lo scopo di quella struttura COBOL è quello di estrarre il 
cognone e 2 nomi da una unica stringa
 
 
 
 


guarda, non è questione di coobol, anche in java se scrivi na roba del 
genere sei da LICENZIAMENTO. Un po come quelli che programmavano in 
assembler e lavoravano solo sui registri.....duravano poco.
Ma possibile che siate sempre tutti cosi competitivi? la prima regole è 
la condivisione e la collaborazione. la seconda è :  quando hai finito 
di fare un lavoro chiediti come si poteva fare meglio.
NON VA BENE RAGAZZI. NON VA BENE....vi mancano proprio le basi ....DEL 
LAVORO.



 
la soluzione che mi piace di piu è quella di andrea anche se ha saltato 
una redefines , ma in ogni caso è la piu pulita e il concetto è quello.


 di fare un lavoro chiediti come si poteva fare meglio.
 
Ecco, appunto. Chiediti come si puo` scrivere un programma che genera sequenze di Fibonacci con meno delle tue 8000 linee di codice COBOL :)

 la soluzione che mi piace di piu è quella di andrea[...]
 
Non ci crederai, ma IntelliJ IDEA ti crea lo stub della classe, devi solo aggiungere i tre field privati, premi un paio di shortcut e il sistema ti genera costruttori e setter. Con un altro shortcut, ti crea la classe tester.
E tutto nel tempo che ci metti a lanciare il tuo ambiente COBOL! Incredibile!

 con meno delle tue 8000 linee di codice COBOL
 
esatto i treni arrivavano in orario e poi non sei nemmeno obierttivo, 
per fare 2 redefines del cazzo hai scritto una classe di 20 
istruzioni...l'onestà intellettuale è la prima regola.


 istruzioni...
 
No, caro. Io ho scritto tre dichiarazioni di membri privati. Il resto lo ha costruito l'ambiente di sviluppo con un paio di shortcut.
Tempo impiegato: 5 secondi :)
Tu avrai scritto anche due redefines del cazzo, ma tali rimangono: redefines del cazzo.
 

 cognone e 2 nomi da una unica stringa
Infatti ho premesso "Dipende dall'uso".
Se vuoi estrarre i 3 campi va bene anche la tua, ma se vuoi conservare 
le 5 definizioni + filler accedere ai 5 campi distintamente, anche in 
modifica, e regredire alla forma primitiva, la tua classe non va bene.
Poi siamo d'accordo che se hai bisogno di una redefines significa che 
c'e' un problemino nel modello dati.
Io ho immaginato ad un'adapter per accedere ad una struttura in cui i 
campi non sono definiti.
 
 

 c'e' un problemino nel modello dati.
 
UNA PUTTANATA PAZZESCA....ma perchè le spari alla cazzo in questo modo.
il cobol ha una tipicizzazione moltissimamente strong per tipo lunghezza 
e struttura dei campi.



 
Questa è una perla di saggezza:
il COBOL ha una tipizzazione strong
 
Conosce solo aree di memoria (le stringhe a lunghezza fissa), un po di 
tipi numerici e gli array come strutture
 
Ma quale tipizzazione, ma lo sai cosa significa tipizzazione dei dati ?
 


L' op non ha definito a cosa servano quelle redefines quindi ho fatto 
unna supposizione ragionevole, estrarre nome/nomi e cognome da una stringa
Certo se si vogliono aggiungere altre funzionalità quella classe cosi 
come è non va bene, occorre aggiungere altro o fare altre classi.
Sulle redefined in COBOL è normale usarle in quanto è proprio la 
struttura del linguaggio molto povera a portare a ciò
 
In altri casi (con altri linguaggi) usare le union non è sempre sbagliato
Dipende dal problema
 
Un esempio (C++):
 
class any_type {
	public:
		enum  atm  { atm_null,atm_int,atm_long,atm_char_pointer,...}
		any_type();
		template <typename T>
		any_type(const T&);
		atm type()const;
		template <typename T>
		T get()const;
	private:
		union {
			int i;
			long l;
			char* p;
			.....
		};
		atm _type;
	};
 
senza le union si avrebbe uno spreco inutile di memoria
Comunque meglio incapsularle in una classe in modo da evitare errori di uso
 
 


Ero certo che non avresti capito, avevo anche aggiunto una postilla, che 
hai proditoriamente tagliato.
Innanzi tutto trova da qualche parte cosa si intende per modello dati, 
che sospetto tu non ne abbia che una pallida idea, forse.
In secondo luogo non l'ho nemmeno citata la tipizzazione del cobol, 
sebbene ne potrei parlare a lungo.
Ovvero, se devi interpretare un campo db fatto come la tua redefines, 
(tutti i valori concatenati in posizioni e lunghezze fisse), converrai 
che chi ha disegnato il db, poteva sforzarsi un po' di piu'.

 Dipende dal problema
Ovviamente. Quando ho avuto bisogno delle union in C, non mi sono mica 
vergognato.