TP03 - EJ5 - Clase Queue

import java.lang.reflect.Array;
import java.util.Iterator;

    public class Queue<ELEMENT> implements Iterable<ELEMENT> {

        //region Constants

        protected final static Integer defaulDimension = 10;

        //endregion

        //region Attributes

        protected Class<?> elementClass;
        protected ELEMENT [] data;
        protected int head;
        protected int tail;
        protected int count;

        //endregion

        //region Constructors

        public Queue() {
            this(Queue.defaulDimension);
        }

        // from https://stackoverflow.com/questions/529085/how-to-create-a-generic-array-in-java
        @SuppressWarnings("unchecked")
        public Queue(int dimension, ELEMENT... dummy) {
            if (dummy.length > 0) {
                throw new IllegalArgumentException("No se debe facilitar valores para dummy");
            }
            elementClass = dummy.getClass().getComponentType();
            this.data = (ELEMENT []) Array.newInstance(this.elementClass, dimension);
            this.head = 0;
            this.tail = 0;
            this.count = 0;
        }
        //endregion

        //region Queue Internal Methods
        protected int next(int pos) {
            if (++pos >= this.data.length) {
                pos = 0;
            }
            return pos;
        }
        //endregion


        //region Queue Methods

        // Operacion EnQueue en la teoría de Estructura de Datos
        //
        // Inserts the specified element into this queue if it is possible to do so
        // immediately without violating capacity restrictions, returning true upon
        // success and throwing an IllegalStateException if no space is currently
        // available.
        public boolean add(ELEMENT vector) {

            if (this.size() >= this.data.length) {
                throw new IllegalStateException("Cola llena ...");
            }

            this.data[this.tail] = vector;
            this.tail = this.next(this.tail);
            ++this.count;

            return true;
        }

        // Operacion peek en la teoría de Estructura de Datos
        //
        // Retrieves, but does not remove, the head of this queue. This method differs
        // from peek only in that it throws an exception if this queue is empty.
        public ELEMENT vector() {

            if (this.size() <= 0) {
                throw new IllegalStateException("Cola vacía ...");
            }

            return this.data[this.head];
        }




        //region Override Object basic methods

        @Override
        public String toString() {

            if (this.size() <=0) {
                return "";
            }

            // from https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/StringBuilder.html
            StringBuilder sb = new StringBuilder();
            sb.append("[" + this.data[this.head].toString());

            for (int cta = 1, pos = this.next(this.head); cta < this.size(); ++cta, pos = this.next(pos)) {
                sb.append(", " + this.data[pos].toString());
            }

            sb.append("]");
            return sb.toString();
        }
        //endregion


        //region Collection Methods



        public int size() {
            return this.count;
        }

        public ELEMENT[] toArray() {
            if (this.size() <= 0) {
                throw new IllegalStateException("Cola vacía ...");
            }

//          ELEMENT [] result = (ELEMENT []) new Object[this.size()];
            ELEMENT [] result = (ELEMENT []) Array.newInstance(this.elementClass, this.size());
            for(int i = 0, pos = this.head, cta = this.size(); cta > 0; ++i, pos = this.next(pos), --cta) {
                result[i] = this.data[pos];
            }
            return result;
        }
        //endregion


        //region Iterable Methods

        @Override
        public Iterator<ELEMENT> iterator() {
            return new QueueIterator(this);
        }

        private class QueueIterator implements Iterator<ELEMENT> {

            //region Attributes

            private Queue<ELEMENT> itQueue;
            private int itCount;
            private int itPos;

            //endregion

            //region Constructor

            public QueueIterator(Queue<ELEMENT> queue) {
                this.itQueue = queue;
                this.itCount = this.itQueue.size();
                this.itPos = this.itQueue.head;
            }

            //endregion

            @Override
            public boolean hasNext() {
                return this.itCount > 0;
            }

            @Override
            public ELEMENT next() {
                if ( !this.hasNext() ) {
                    throw new RuntimeException("Error en el iterador de la cola...");
                }
                ELEMENT item = this.itQueue.data[this.itPos];
                this.itPos = this.itQueue.next(this.itPos);
                --this.itCount;
                return item;
            }
        }



}