Skip to content

Commit

Permalink
Modified ClassControll.java and EasyReader.java
Browse files Browse the repository at this point in the history 
Unable to read user input. See bug #7
  • Loading branch information
@CarlosFMeneses
CarlosFMeneses committed Mar 11, 2019
1 parent 4b4b425 commit 7c19d95
Show file tree
Hide file tree
Showing 2 changed files with 133 additions and 160 deletions.
10 changes: 9 additions & 1 deletion src/classroomController/ClassController.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,8 +15,16 @@ class ClassController {
* @param args
*/
Classroom currentClassroom = new Classroom(0, 0);

public static void main(String[] args) {
EasyReader kboard = new EasyReader();
System.out.println("kboard instantiated " + kboard);

System.out.print("Enter input file name: ");

int n = kboard.readInt();
System.out.println("fileName instantiated " + n);

System.out.println("Hello World!");

}
Expand Down
283 changes: 124 additions & 159 deletions src/classroomController/EasyReader.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -60,235 +60,200 @@
*/
public class EasyReader
{
private String myFileName;
private BufferedReader myInFile;
private int myErrorFlags = 0;
private static final int OPENERROR = 0x0001;
private static final int CLOSEERROR = 0x0002;
private static final int READERROR = 0x0004;
private static final int EOF = 0x0100;
private String myFileName;
private BufferedReader myInFile;
private int myErrorFlags = 0;
private static final int OPENERROR = 0x0001;
private static final int CLOSEERROR = 0x0002;
private static final int READERROR = 0x0004;
private static final int EOF = 0x0100;

/**
* Constructs an <code>EasyReader</code> associated with
* <code>System.in</code>.
*/
public EasyReader()
{
myFileName = null;
myErrorFlags = 0;
myInFile = new BufferedReader(
new InputStreamReader(System.in), 128);
}
public EasyReader() {
System.out.println("Enter EasyReader()");
myFileName = null;
myErrorFlags = 0;
myInFile = new BufferedReader(new InputStreamReader(System.in), 128);
}

/**
* Constructs an <code>EasyReader</code> associated with a file for reading.
* @param fileName the name or pathname of the file.
*/
public EasyReader(String fileName)
{
myFileName = fileName;
myErrorFlags = 0;
try
{
myInFile = new BufferedReader(new FileReader(fileName), 1024);
}
catch (FileNotFoundException e)
{
myErrorFlags |= OPENERROR;
myFileName = null;
}
}
public EasyReader(String fileName) {
myFileName = fileName;
myErrorFlags = 0;
try {
myInFile = new BufferedReader(new FileReader(fileName), 1024);
} catch (FileNotFoundException e) {
myErrorFlags |= OPENERROR;
myFileName = null;
}
}

/**
* Closes the file.
*/
public void close()
{
if (myFileName == null)
return;
try
{
myInFile.close();
}
catch (IOException e)
{
System.err.println("Error closing " + myFileName + "\n");
myErrorFlags |= CLOSEERROR;
}
}
public void close() {
if (myFileName == null)
return;
try {
myInFile.close();
} catch (IOException e) {
System.err.println("Error closing " + myFileName + "\n");
myErrorFlags |= CLOSEERROR;
}
}

/**
* Checks the status of the file.
* @return true if an error occurred when opening or reading the file;
* false otherwise.
*/
public boolean bad()
{
return myErrorFlags != 0;
}
public boolean bad() {
return myErrorFlags != 0;
}

/**
* Checks the EOF status of the file.
* @return true if EOF was encountered in the previous read
* operation; false otherwise.
*/
public boolean eof()
{
return (myErrorFlags & EOF) != 0;
}
public boolean eof() {
return (myErrorFlags & EOF) != 0;
}

private boolean ready() throws IOException
{
return myFileName == null || myInFile.ready();
}
private boolean ready() throws IOException {
return myFileName == null || myInFile.ready();
}

/**
* Reads the next character from the file (any character including
* a space or a newline character).
* @return the character read or <code>null</code> character
* (Unicode 0) if trying to read beyond the EOF.
*/
public char readChar()
{
char ch = '\u0000';
public char readChar() {
char ch = '\u0000';

try
{
if (ready())
{
ch = (char)myInFile.read();
}
}
catch (IOException e)
{
if (myFileName != null)
System.err.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}
try {
if (ready()) {
ch = (char) myInFile.read();
}
} catch (IOException e) {
if (myFileName != null)
System.err.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}

if (ch == '\u0000')
myErrorFlags |= EOF;
if (ch == '\u0000')
myErrorFlags |= EOF;

return ch;
}
return ch;
}

/**
* Reads from the current position in the file up to and including
* the next newline character. The newline character is thrown away.
* @return the string read (excluding the newline character) or
* null, if trying to read beyond the EOF.
*/
public String readLine()
{
String s = null;
public String readLine() {
System.out.println("Enter readLine ");

String s = null;
System.out.println("s = " + s);

try
{
s = myInFile.readLine();
}
catch (IOException e)
{
if (myFileName != null)
System.err.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}
try {
s = myInFile.readLine();
} catch (IOException e) {
if (myFileName != null)
System.out.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}

if (s == null)
myErrorFlags |= EOF;
return s;
}
if (s == null)
myErrorFlags |= EOF;
return s;
}

/**
* Skips whitespace and reads the next word (a contiguous string of
* non-whitespace characters), up to but excluding the next space,
* newline, etc.
* @return the string read or null, if trying to read beyond the EOF.
*/
public String readWord()
{
StringBuffer buffer = new StringBuffer(128);
char ch = ' ';
int count = 0;
String s = null;
public String readWord() {
StringBuffer buffer = new StringBuffer(128);
char ch = ' ';
int count = 0;
String s = null;

try
{
while (ready() && Character.isWhitespace(ch))
ch = (char)myInFile.read();
while (ready() && !Character.isWhitespace(ch))
{
count++;
buffer.append(ch);
myInFile.mark(1);
ch = (char)myInFile.read();
};
try {
while (ready() && Character.isWhitespace(ch))
ch = (char) myInFile.read();
while (ready() && !Character.isWhitespace(ch)) {
count++;
buffer.append(ch);
myInFile.mark(1);
ch = (char) myInFile.read();
}
;

if (count > 0)
{
myInFile.reset();
s = buffer.toString();
}
else
{
myErrorFlags |= EOF;
}
}
if (count > 0) {
myInFile.reset();
s = buffer.toString();
} else {
myErrorFlags |= EOF;
}
}

catch (IOException e)
{
if (myFileName != null)
System.err.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}
catch (IOException e) {
if (myFileName != null)
System.err.println("Error reading " + myFileName + "\n");
myErrorFlags |= READERROR;
}

return s;
}
return s;
}

/**
* Reads the next integer (without validating its format).
* @return the integer read or 0 if, trying to read beyond the EOF,
* or if the read word does not represent a valid integer.
*/
public int readInt()
{
int result = 0;
String s = readWord();
public int readInt() {
int result = 0;
String s = readWord();

if (s != null)
{
try
{
result = Integer.parseInt(s);
}
catch (NumberFormatException ex)
{
}
}
if (s != null) {
try {
result = Integer.parseInt(s);
} catch (NumberFormatException ex) {
}
}

return result;
}
return result;
}

/**
* Reads the next double (without validating its format).
* @return the number read or <code>Double.NaN</code>, if trying to read
* beyond the EOF, or if the token read does not represent a valid double.
*/
public double readDouble()
{
double result = Double.NaN;
public double readDouble() {
double result = Double.NaN;

String s = readWord();
if (s != null)
{
try
{
result = Double.parseDouble(s);
}
catch (NumberFormatException ex)
{
}
}
return result;
}
String s = readWord();
if (s != null) {
try {
result = Double.parseDouble(s);
} catch (NumberFormatException ex) {
}
}
return result;
}
}

0 comments on commit 7c19d95

Please sign in to comment.