/***************************************************************/
/* Prof. Dr. Gregor Büchel                                     */
/* Source: Dat5.java                                           */
/* Stand : 07.04.2002                                          */
/*                                                             */
/* Testprogramm für zeichenorientierte Dateiverarbeitung mit   */
/* definiertem Datensatzaufbau (fester Recordaufbau):          */
/* <name>  ::=<B15> ::={<B>}15:15   (String)                   */
/* <plz>   ::=<N5>  ::={<Z>}5:5     (int)                      */
/* <ort>   ::=<B10> ::={<B>}10:10   (String)                   */
/* <gehalt>::=<F5.2>::=<N5>.<N2>    (double)                   */
/* <DS>    ::=<name><plz><ort><gehalt>                         */
/* LRECL=38                                                    */
/***************************************************************/
import java.io.*;

class Dat5
{
 public static void main(String args[]) throws IOException
 {int iz=0,ia=1,eplz,m,ir,aiplz;
  String ename,eort,esplz,esgehalt;
  String aname,aort,aplz,agehalt;
  double egehalt,agy,sum=0.;
  String ds,s1;
  char ezf[];
  ezf= new char[39]; /* (LRECL=38)+LF+CR */
  ds=new String();
  ename=new String();
  eort=new String();
  esplz=new String();
  esgehalt=new String();
  aname=new String();
  aort=new String();
  aplz=new String();
  agehalt=new String();
  s1=new String();
  do
  {m=menue();
   switch(m)
   {case 1: FileWriter pta = new FileWriter("npog1.txt");
            PrintWriter pd1 = new PrintWriter(pta);
            do
            {/* <name> erfassen und auf Länge 15 bringen */
             System.out.println("Bitte <name> eingeben:");
             ename=IO1.einstring();
             ename=flString(ename,15);
             System.out.println("Name("+ename.length()+")="+ename);
             /* <plz> erfassen und auf Länge 5 bringen */
             System.out.println("Bitte <plz> eingeben:");
             do
             { eplz=IO1.einint();
               if (eplz<1000||eplz>99999)
               {System.out.println("Die deutsche PLZ liegt zwischen 1000 und 99999.");
                System.out.println("Daher bitte Neueingabe der PLZ!");
               }
             } while (eplz<1000||eplz>99999);
             esplz=flint(eplz,5);
             System.out.println("PLZ("+esplz.length()+")="+esplz);
             /* <ort> erfassen und auf Länge 10 bringen */
             System.out.println("Bitte <ort> eingeben:");
             eort=IO1.einstring();
             eort=flString(eort,10);
             System.out.println("Ort("+eort.length()+")="+eort);
             /* <gehalt> erfassen und auf Länge (5,2) bringen */
             do
             { System.out.println("Bitte <gehalt> eingeben:");
               do
               { egehalt=IO1.eindouble();
                 if (egehalt<0.)
                  {System.out.println("Dieses System kennt keine negativen Gehälter.");
                   System.out.println("Daher bitte Neueingabe des GEHALTS!");
                  }
               } while (egehalt<0.);
               esgehalt=fldouble(egehalt,5,2);
             } while(esgehalt==null); 
             System.out.println("Gehalt("+esgehalt.length()+")="+esgehalt);
             /* DS schreiben */
             ds=ename;
             ds=ds.concat(esplz);
             ds=ds.concat(eort);
             ds=ds.concat(esgehalt);
             pd1.println(ds); 
             iz=iz+1;
             System.out.println("Einen nächsten Datensatz erfassen?(ja=1/nein=0)");
             ia=IO1.einint();  
            } while(ia==1);
            System.out.println(iz+" Datensätze geschrieben");
            pd1.close();  
            break;
    case 2: FileReader pte = new FileReader("npog1.txt");
            BufferedReader pd3 = new BufferedReader(pte);
            iz=0;
            /* Lesen Datensatz: hier LRECL=38 */
            ir=pd3.read(ezf,0,38);
            while(ir!=-1)
            {iz=iz+1;
             s1=new String(ezf);
             aname=s1.substring(0,15);
             aplz=s1.substring(15,20);
             aort=s1.substring(20,30);
             agehalt=s1.substring(30,38); 
             aiplz=Integer.parseInt(aplz); 
             agy=Double.valueOf(agehalt).doubleValue();
             System.out.println(iz+".DS (name("+aname.length()+")): "+aname);  
             System.out.println(iz+".DS (plz("+aplz.length()+"))  : "+aplz);  
             System.out.println(iz+".DS (plz(geparst): "+aiplz);  
             System.out.println(iz+".DS (ort("+aort.length()+")) : "+aort);  
             System.out.println(iz+".DS (gehalt("+agehalt.length()+")) : "+agehalt);  
             System.out.println(iz+".DS (gehalt(geparst)="+agy);
             sum=sum+agy;
             /* Überlesen: LF- und CR-Zeichen, denn             */
             /* die Eingabedatei wurde mit println() erzeugt !  */
             ir=pd3.read(ezf,0,2);
             /* Lesen Datensatz: hier LRECL=38 */
             ir=pd3.read(ezf,0,38);
            }
            pd3.close();
            System.out.println("Gehaltssumme       : "+sum);
            sum=sum/iz;
            System.out.println("Durchschnittsgehalt: "+sum);  
            System.out.println("EOF: "+iz+" Datensätze gelesen");  
            break;
    
    case 9: System.out.println("ENDE!");
            break;
    default: System.out.println("Unzulaessige Eingabe!");
   }
  } while(m!=9);
 }  
 
 public static int menue()
 {int ir;
  System.out.println("Recordorientierte Dateiverarbeitung:");  
  System.out.println("(1) Erzeugen und Schreiben von Records");
  System.out.println("(2) Lesen von Records"); 
  System.out.println("(9) ENDE");
  System.out.println("Bitte wählen Sie!");
  ir=IO1.einint();
  return ir;   
 }

 public static String flString(String estr, int l1)
 {/**************************************************************/
  /* Methode, um einen String estr auf feste Länge l1 zu setzen */
  /* estr wird linksbündig notiert, d.h.                        */
  /* estr.length()<l1 => Auffüllen mit Blanks                   */
  /* estr.length()>l1 => Abschneiden                            */
  /**************************************************************/
  int i,k,d;
  String astr;
  astr= new String();
  k=estr.length();
  /* Hier findet noch keine Prüfung statt, ob l1 korrekt über-  */  
  /* geben wurde.                                               */
  if (k==l1) astr=estr;
  if (k>l1)
  {astr=estr.substring(0,l1);
  }
  if (k<l1)
  {d=l1-k;
   astr=estr;
   for(i=0; i<d; i=i+1)
   {astr=astr.concat(" ");
   }
  }
  return astr;   
 }

 public static String flint(int n, int l1)
 {/**************************************************************/
  /* Methode, um eine int-Zahl n in einen String sr mit fester  */
  /* Länge l1 zu konvertieren.                                  */
  /* Der Zahlstring wird rechtsbündig geschrieben, d.h.         */
  /* Laenge(n)<l1 => Auffüllen mit führenden Nullen             */
  /* Laenge(n)>l1 => Abschneiden der führenden Stellen          */
  /**************************************************************/
  int il,k;
  String s1,sr;
  s1=new String();
  sr=new String();
  s1=Integer.toString(n);
  il=s1.length();
  if (il==l1) sr=s1;
  if (il>l1)  sr=s1.substring(il-l1);
  if (il<l1)
  {sr="0";
   for(k=0; k<l1-il-1; k=k+1)
   {sr=sr.concat("0");
   }
   sr=sr.concat(s1);
  } 
  return sr;   
 }
 
 public static String fldouble(double x, int vk, int nk)
 {/**************************************************************/
  /* Methode, um eine double-Zahl x in einen String sr mit      */
  /* fester Anzahl Vorkommastellen vk und Nachkommastellen nk   */
  /* mit fester Länge l1 zu konvertieren.                       */
  /* Der Zahlstring wird rechtsbündig geschrieben, d.h.         */
  /* Laenge(x_vork)<vk => Auffüllen mit führenden Nullen        */
  /* Laenge(x_vork)>vk => Abschneiden der führenden Stellen     */
  /* Laenge(x_nack)<nk => Abschneiden der folgenden Stellen     */
  /* Laenge(x_vork)>vk => Auffüllen mit folgenden Nullen        */
  /**************************************************************/
  int k,ip,vork,nack,ex;
  String s1,sv,sh,svr,shr,sr;
  s1=new String();
  sr=new String();
  sv=new String();
  sh=new String();
  svr=new String();
  shr=new String();
  s1=Double.toString(x);
  ip=s1.indexOf(".");
  sv=s1.substring(0,ip);
  sh=s1.substring(ip+1);
  ex=s1.indexOf("E");
  if (ex>-1)
  { System.out.println("->"+s1+" ip="+ip+" sv:"+sv+" sh:"+sh+" ex:"+ex);
    System.out.println("Bitte keine Exponentialdarstellung!");
    System.out.println("Demo funktioniert nur mit kleinen Zahlen!");
    System.out.println("Bitte Neueingabe!");
    sr=null;
    return sr;
  }
  vork=sv.length();
  nack=sh.length();
  /* Erzeugen des festformatierten Vorkommastrings svr */
  if (vork==vk) svr=sv;
  if (vork>vk)  svr=sv.substring(vork-vk);
  if (vork<vk)
  {svr="0";
   for(k=0; k<vk-vork-1; k=k+1)
   {svr=svr.concat("0");
   }
   svr=svr.concat(sv);
  } 
  /* Erzeugen des festformatierten Nachkommastrings shr */
  if (nack==nk) shr=sh;
  if (nack>nk)  shr=sh.substring(0,nk);
  if (nack<nk)
  {shr=sh;
   for(k=0; k<nk-nack; k=k+1)
   {shr=shr.concat("0");
   }
  }
  /* Zusammenbau des festformatierten Double-Strings sr */
 sr=svr;
 sr=sr.concat(".");
 sr=sr.concat(shr); 
 return sr;   
 }

}