// checking the same contracts via the state pattern
class PortState implements IPort {

    private int values[]; 

    private IPort state; // State Pattern: OpenPort | ClosedPort

    PortState(int values[]) { 
        this.values = values; 
        state = new ClosedPort(); 
    }

    // -------------------------------------------------------------------------

    public void open() { 
        state.open(); 
    }

    public int read() {
        return state.read();
    }

    public boolean out_of_intsP() {
        return state.out_of_intsP(); 
    }

    public void close() {
        state.close();
    }   

    // implementing an open port
    private class OpenPort implements IPort {

        int ptr = 0; 

        public void open() { 
            System.out.println("can't call open on open file"); 
            System.exit(-1); 
        }

        public int read() {
            preRead();          
            int r = values[ptr]; 
            ptr++; 
            return r; 
        }

        public boolean out_of_intsP() {
            return (ptr >= values.length); 
        }

        public void close() {
            state = new ClosedPort(); 
        }       
        // checking the precondition for read
        private boolean preRead() { 
            if (ptr < values.length)
                return true; 
            System.out.println("precondition violation"); 
            System.exit(-1); 
            return false; 
        }
    }

    // implementing a closed port
    private class ClosedPort implements IPort {

        public void open() { 
            state = new OpenPort(); 
        }

        public int read() {
            Ouch(); return -1; 
        }

        public boolean out_of_intsP() {
            Ouch(); return false; 
        }

        public void close() {
            Ouch(); 
        }       

        private void Ouch() {
            System.out.println("sequence contract violation");
            System.exit(-1); 
        }
    }

}