Hi,

I'm having problems with line 37 in my Driver class. I know that I get that error because, according to Java, the variable Task, in the Driver, has not been initialized, but I do not see how I'm not initializing it.

Thanks

import java.util.Scanner;
import java.io.*;

public class Driver 
{
	public static void main(String [] arg) throws IOException  
	{
		Scanner Scan = new Scanner(new File("mfq.txt"));
		LineWriter lw = new LineWriter("csci.txt");
		
		//numbers of queue in the system
		int queues = 5;
		
		//Array holding priority Queues of objects
		ObjectQueue [] objQueue = new ObjectQueue [queues];
		
		//Variable to hold any process/task to be pass to the CPU
		//from the text file or a queue
		Process Task;
	    
		//variable to finish all process when set to false
		boolean END;
		
		//CPU object
		CPU Core = new CPU();
		
		//variable to hold time elapsed in the machine
		int Machine_Time = 0;
		
		// q set to -1 as initial value
		//int q;
		
		//move all process into objQueue[0]
		while (Scan.hasNext())
		{
			Task = new Process (Scan.nextLine(), lw, 0);
			objQueue[0].insert(Task);
			
		}
		
		//set all process into the first priority queue
		do
		{
			//set END to false for a continuous loop until all queues are empty and q to -1 
			END = false;
			int q = -1;
			
			//check if there is any process in the input Queue
			if (!objQueue[0].isEmpty())
			{
				//check if process needs to be send to the CPU
				if (((Process)objQueue[0].query()).getSendTime() == Machine_Time)
				{
					q = 0;
				}
			}
			
			//if process does not have to be send to CPU, look in priority queues
			if (q != 0)
			{
				for (int i = 1; i < queues; i++)
				{
					if (!objQueue[i].isEmpty())
					{
						q = i;
						break;
					}
				}
			}
			
			if (q > -1)
			{
				Task = (Process) objQueue[q].remove();
				
				if (Core.Busy())
				{
					if (q < queues - 1)
						q++;
					
					Task.setQueue(q);
					objQueue[q].insert(Task);
				}
				else
				{
					if (q == 0)
						Core.getProcess(Task, Machine_Time);
					else
						Core.getProcess(Task);
				}
				
				Core.Process();
				
				//if  CPU is not busy
				if (!Core.Busy())
				{
					Task = Core.freeCPU(Machine_Time);
					
					if (Task.getTimer() == 0)
						Task.EndProcess();
					else
					{
						if (q < queues - 1)
							q++;
						
						Task.setQueue(q);
						objQueue[q].insert(Task);
					}
				}
				
				//check if all queues are empty
				for (int c = 0; c < queues; c++)
				{
					if (!objQueue[c].isEmpty())
					{
						END = true;
						break;
					}
				}
			}
		}while (END);
	}
}
public class Process 
{
	//current queue
	private int queue = 0;
	
	//time to send to CPU/Core
	private int submit_time;
	
	//process id
	private int id;
	
	//time for process to be completed
	private int timer;
	
	//time process arrives for the first time into the CPU
	private int time_in;
	
	//time process is completed
	private int time_out;
	
	private LineWriter lw;
	
	//initialize queue, id, timer and submit_time variables
	public Process(String str, LineWriter l, int q)
	{
		lw = l;
		queue = q;
		
		String temp = "";
		id = 0;
		timer = 0;
		submit_time = 0;
		
		for (int c = 0; c < str.length(); c++)
		{
			while (str.charAt(c) == ' ')
			{
				c++;
			}
			
			while ((c < str.length()) && (str.charAt(c) != ' '))
			{
				temp = temp + str.charAt(c);
				c++;
			}
			
			if (submit_time == 0)
				submit_time = Integer.valueOf(temp);
			else if (id == 0)
				id = Integer.valueOf(temp);
			else if (timer == 0)
				 timer = Integer.valueOf(temp);
			
			temp = "";
		}
	}
	
	//decrease time left for process to be completed
	public int getTimer()
	{
		return timer;
	}
	
	//set new time for process to be completed
	public void setTimer()
	{
		timer--;
	}
	//returns process id
	public int getId()
	{
		return id;
	}
	
	//set current queue
	public void setQueue(int x)
	{
		queue = x;
	}
	
	//return current queue
	public int getQueue()
	{
		return queue;
	}
	
	//return time when the process is send to the CPU
	public int getSendTime()
	{
		return submit_time;
	}
	
	//records the machine time that the process was send to the CPU
	public void setTimeIn( int x)
	{
		time_in = x;
	}
	
	//set the machine time when the CPU releases a process
	public void setTimeOut(int x)
	{
		time_out = x;
	}
	
	//retunrs machine time when process is completed
	public int getTimeOut()
	{
		return time_out;
	}
	
	public void EndProcess()
	{
		lw.println(time_in + "		" + "		" + id + "		" + time_out );
		//lw.println();
		
		System.out.println(time_in + "		" + "		" + id + "		" + time_out );
		//System.out.println();
	}
}
public class CPU 
{
	//time that the CPU will spend in a process
	private int CPU_Time;
	
	//process received by the CPU
	private Process Work;
	
	//variable to hold busy flag
	private boolean busy_flag;
	
	
	public CPU()
	{
		busy_flag = false;
		CPU_Time = 0;
	}
	
	//returns true or false if CPU_Time is not 0 (CPU busy)
	public boolean Busy()
	{
		return busy_flag;
	}
	
	//pass process for the first time to CPU
	public void getProcess(Process Task, int t)
	{
		Work = Task;
		Work.setTimeIn(t);
		CPU_Time = (int) java.lang.Math.pow(2, (double) Work.getQueue());
		busy_flag = true;
	}
	
	//pass process from queue into CPU
	public void getProcess(Process Task)
	{
		Work = Task;
		CPU_Time = (int) java.lang.Math.pow(2, (double) Work.getQueue());
		busy_flag = true;
	}
	
	//decrease CPU timer by 1 unit and increase and clears busy flag if CPU_Time = 0
	public void Process()
	{
		CPU_Time--;
		
		//decrease time needed to complete process
		Work.setTimer();
		
		if (CPU_Time == 0 || Work.getTimer() == 0)
			busy_flag = false;
	}
	
	//returns Process to be passed to queue
	public Process freeCPU(int x)
	{
		Work.setTimeOut(x);
		return Work;
	}
}
/**
 * Write a description of class ObjectQueue here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class ObjectQueue
{
    private Object[] item;
    private int front;
    private int rear;
    private int size;
    
    public ObjectQueue(){
        size = 100;
        item = new Object[size];
        front = size-1;
        rear = size-1;
    }
    
    public ObjectQueue(int max){
        size = max;
        item = new Object[size];
        front = size-1;
        rear = size-1;
    }
    
    public boolean isEmpty(){
        return front == rear;
    }
    
    public boolean isFull(){
        return rear == size-1 ? front == 0 : front == rear+1;
    }
    
    public void clear(){
        front = size-1;
        rear = size-1;
    }
    
    public void insert(Object x){
        if (isFull()){
            System.out.println("Insert Runtime Error: Queue Overflow");
            System.exit(1);
        }
        if (rear == size-1)
            rear = 0;
        else
            rear++;
        item[rear] = x;
    }
    
    public Object remove(){
        if (isEmpty()){
            System.out.println("Remove Runtime Error: Queue Underflow");
            System.exit(1);
        }
        if (front == size-1)
            front = 0;
        else
            front++;
        return item[front];
    }
    
    public Object query(){
        if (isEmpty()){
            System.out.println("Query Runtime Error: Queue Underflow");
            System.exit(1);
        }
        if (front == size-1)
            return item[0];
        else
            return item[front+1];
    }

    
    

}
// LineWriter.java

import java.io.*;

/* @author Richard Stegman
 * @version 2.1, 1/5/07
 * 
 * LineWriter provides simple methods for opening and writing to text files.
 * 
 * Example:
 * 
 *      LineWriter lw = new LineWriter(foo.txt");
 *      lw.println("This is a string.");
 *      lw.println();
 *      lw.println(108);
 *      lw.close(); 
 *
 */

public class LineWriter {
    private PrintWriter outFile;
    
    /*
     * LineWriter constructor. 
     * Creates a new file or overwrites an existing file.
     * @param fileName name of the file to be created
     */
    
    public LineWriter(String fileName) {
        try {
            FileWriter fw = new FileWriter(fileName);
            BufferedWriter bw = new BufferedWriter(fw);
            outFile = new PrintWriter(bw);
        }    
        catch (IOException e) {
            System.out.println("LineWriter cannot open output file: " + fileName);
            e.printStackTrace();
        }
    }

    /*
     * LineWriter constructor. 
     * Creates a new file. If the file exists can append to it.
     * @param fileName name of the file to be created
     * @param mode if equal to "a" opens in append mode
     */
    
    public LineWriter(String fileName, String mode) {
        try {
            FileWriter fw = new FileWriter(fileName, "a".equals(mode));
            BufferedWriter bw = new BufferedWriter(fw);
            outFile = new PrintWriter(bw);
        }    
        catch (IOException e) {
            System.out.println("LineWriter cannot open output file: " + fileName);
            e.printStackTrace();
        }
    }

    /**
     * Outputs a string and newline to the file.
     * @param s string to be output
     */
     
    public void println(String s) {
        outFile.println(s);
    }

    /**
     * Outputs a string to the file.
     * @param s string to be output
     */
     
    public void print(String s) {
        outFile.print(s);
    }

    /**
     * Outputs an integer and newline to the file.
     * @param i integer to be output
     */
     
    public void println(int i) {
        outFile.println(i);
    }

    /**
     * Outputs an integer to the file.
     * @param i integer to be output
     */
     
    public void print(int i) {
        outFile.print(i);
    }

    /**
     * Outputs a long and newline to the file.
     * @param l long to be output
     */
     
    public void println(long l) {
        outFile.println(l);
    }

    /**
     * Outputs a long to the file.
     * @param l long to be output
     */
     
    public void print(long l) {
        outFile.print(l);
    }

     /**
     * Outputs a short and newline to the file.
     * @param s short to be output
     */
     
    public void println(short s) {
        outFile.println(s);
    }

    /**
     * Outputs a short to the file.
     * @param s short to be output
     */
     
    public void print(short s) {
        outFile.print(s);
    }
    
    /**
     * Outputs a byte and newline to the file.
     * @param b byte to be output
     */
     
    public void println(byte b) {
        outFile.println(b);
    }

    /**
     * Outputs a byte to the file.
     * @param b byte to be output
     */
     
    public void print(byte b) {
        outFile.print(b);
    }
    
    /**
     * Outputs a boolean and newline to the file.
     * @param b boolean to be output
     */
     
    public void println(boolean b) {
        outFile.println(b);
    }

    /**
     * Outputs a boolean to the file.
     * @param b boolean to be output
     */
     
    public void print(boolean b) {
        outFile.print(b);
    }

    /**
     * Outputs a float and newline to the file.
     * @param f float to be output
     */
     
    public void println(float f) {
        outFile.println(f);
    }

    /**
     * Outputs a float to the file.
     * @param f float to be output
     */
     
    public void print(float f) {
        outFile.print(f);
    }

    /**
     * Outputs a double and newline to the file.
     * @param d double to be output
     */
     
    public void println(double d) {
        outFile.println(d);
    }

    /**
     * Outputs a double to the file.
     * @param d double to be output
     */
     
    public void print(double d) {
        outFile.print(d);
    }

    /**
     * Outputs a character and newline to the file.
     * @param c char to be output
     */
     
    public void println(char c) {
        outFile.println(c);
    }

    /**
     * Outputs a character to the file.
     * @param c char to be output
     */
     
    public void print(char c) {
        outFile.print(c);
    }

    /**
     * Outputs an object and newline to the file.
     * @param o object to be output
     */
     
    public void println(Object o) {
        outFile.println(o);
    }

    /**
     * Outputs an object to the file.
     * @param o object to be output
     */
     
    public void print(Object o) {
        outFile.print(o);
    }
    
    /**
     * Outputs a newline character to the file.
     */
     
    public void println() {
        outFile.println();
    }

    /**
     * Closes the file.
     */
     
    public void close() {
        outFile.flush();
        outFile.close();
    }
}

no, it is objQueue[0] that is null. When you initiate an Object[], each of the elements initially contain null. You still have to define the individual elements of the array.

Thanks a lot, declaring a new queue before moving them into the array fix the problem

this is a shot in the dark, but i am wondering what "declaring a new queue before moving them into the array" means code-wise... i am working on a similar project for seemingly the same class as this was for, and it would be nice to see this work... as is, it does not work.

Hi. This thread is already dead, it's 2 years old and has been solved! Maybe you would want to start a new discussion.

Edited 4 Years Ago by dimasalang

This question has already been answered. Start a new discussion instead.