package bluej.terminal;

import java.awt.Toolkit;

import threadchecker.OnThread;
import threadchecker.Tag;




| A type-ahead input buffer for the BlueJ terminal. Implemented with
| a circular array.
|
| @author  Michael Kolling
| @version $Id: InputBuffer.java 12537 2014-10-10 13:05:36Z nccb $
|
@OnThread(Tag.Any)
public final class InputBuffer
{       
private char[] buffer;
   
   private int bufferNextFull = 0;    
   private int bufferNextFree = 0;    
   private int bufferSize;
   
   private boolean eofMark = false;
    
   
   public static char EOF_CHAR = '\u0004'; 

   
   public InputBuffer(int size)
   {        
      buffer = new char[size];
       
      bufferSize = size;     
      }

   
   public synchronized boolean putChar(char ch)
   {
      if (isFull()) {
         Toolkit.getDefaultToolkit().beep();
           
         return false;         
         }
       

      else {
           
      buffer[bufferNextFree] = ch;
      bufferNextFree = advance(bufferNextFree);
           
      return true;         
      }     
   }

   
public synchronized boolean putString(String input)
   {        
   boolean putAny = false;
       
   for (char c : input.toCharArray())
       {            
      
      
      putAny = putChar(c) || putAny;         
      }
       
   return putAny;     
   }

   
public synchronized boolean backSpace()
   {
   if (!isEmpty()) {
      bufferNextFree = backwards(bufferNextFree);
           
      return true;         
      }
       

   else {
   Toolkit.getDefaultToolkit().beep();
           
   return false;         
   }     
}

   
public synchronized char getChar()
   {        
   

   while (isEmpty()) {            
      try {
      wait();                     
      } catch(InterruptedException e) {                
      
      
      
      
      return '\n';             
      }         
   }

       
char ch = buffer[bufferNextFull];
bufferNextFull = advance(bufferNextFull);
       

if (eofMark) {            
   eofMark = false;
   putChar(EOF_CHAR); 
   
   
   notifyReaders();         
   }
       
return ch;     
}
    
   



| Signal that an EOF condition should be emulated by the terminal.
|
public synchronized void signalEOF()
   {        
   
   
   if (! isFull())
   putChar(EOF_CHAR);
       
   else{ eofMark = true;
      }
   notifyReaders();     
   }

   
public synchronized void notifyReaders()
   {
   notify();     
   }

   
public synchronized boolean isEmpty()
   {        
   return bufferNextFull == bufferNextFree;     
   }

   

private boolean isFull()
   {
   return advance(bufferNextFree) == bufferNextFull;     
   }
    
   
private int advance(int pos)
   {
   return (++pos) % bufferSize;     
   }

   
private int backwards(int pos)
   {        
   pos--;
   return (pos < 0 ? bufferSize - 1 : pos);     
   } 
}