public class GilbertIteratorBlockingQueue implements Iterator<Position> {

    static Logger logger = LogManager.getLogger(GilbertIteratorBlockingQueue.class);

    Producer producer;
    int size;
    BlockingQueue<Position> queue;
    Position position = Position.DUMMY;
    int state = 0;

    public GilbertIteratorBlockingQueue(int size) {
        if (size<4){
            throw new IllegalArgumentException("The dimension of 'Gilbert' curve cannot be less than 4 x 4!");
        }
        this.size = size;
        queue = new ArrayBlockingQueue<>(1024);
        producer = new Producer();
        new Thread(producer).start();
    }


    class Producer implements Runnable {

        static final int u = 1;
        int glx;
        int gly;
        int level;

        public Producer() {
            level = log2up(size);
            int clp2size = clp2(size);
            if (clp2size > size) {
                logger.warn("Warning! The real dimension of iterator's space has been extended to {}x{} pixels", clp2size, clp2size);
            }
            state = 1;
        }

        public void run() {
            try {
                moveto(0, 0);
                a(level);
                queue.put(Position.DUMMY);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }

        void linerel(int x, int y) throws InterruptedException {
            glx += x;
            gly += y;
            queue.put(new Position(glx, gly));
        }

        void moveto(int x, int y) throws InterruptedException {
            glx = x;
            gly = y;
            queue.put(new Position(glx, gly));
        }

        // Elements of curve
        void a(int i) throws InterruptedException {
            if (i > 0) {
                d(i - 1);
                linerel(+u, 0);
                a(i - 1);
                linerel(0, u);
                a(i - 1);
                linerel(-u, 0);
                c(i - 1);
            }
        }

        void b(int i) throws InterruptedException {
            if (i > 0) {
                c(i - 1);
                linerel(-u, 0);
                b(i - 1);
                linerel(0, -u);
                b(i - 1);
                linerel(u, 0);
                d(i - 1);
            }
        }

        void c(int i) throws InterruptedException {
            if (i > 0) {
                b(i - 1);
                linerel(0, -u);
                c(i - 1);
                linerel(-u, 0);
                c(i - 1);
                linerel(0, u);
                a(i - 1);
            }
        }

        void d(int i) throws InterruptedException {
            if (i > 0) {
                a(i - 1);
                linerel(0, u);
                d(i - 1);
                linerel(u, 0);
                d(i - 1);
                linerel(0, -u);
                b(i - 1);
            }
        }


    }

    @Override
    public boolean hasNext() {
        if (state == 2){
            return false;
        }
        try {
            position = queue.take();
            if (position == Position.DUMMY) {
                state = 2;
                return false;
            }
        } catch (InterruptedException e) {
            logger.error(e);
        }
        return true;
    }

    @Override
    public Position next() {
        return position;
    }
}

  /**
    * mayton >> В топку Груви. Решил взять Scala. Экспериментирую. Пока не могу понять что нужно
    * Iterable? Collection? Stream? Списки в стили Lisp вида 1 :: 2 :: nil ...
    *
    * Даллее идет проба пера...
    */
  def getPosition(size:Int) : Position = {
    new Position(0,0)
  }

  /**
    * mayton >> Это гребаный список. Но мне нужен ленивый мать его список через yield...
    */
  def getPositionList(size:Int) : List[Position] = {
    List(new Position(0,0))
  }

  /**
    * mayton >> Итератор...
    */
  def getPositionIterator(size:Int) : Iterable[Position] = {
    List(new Position(0,0)).toIterable
  }

  /**
    * Это украдено у Хорсмана 'Scala'.... типа конструирование бесконечных списков
    * в стиле Лиспа. Здесь насколько я понял определена бесконечноая последовательность
    * целых начиная с n
    */
  def numsFrom(n:Int) : Stream[Int] = {
    n #:: numsFrom(n+1)
  }

  /**
    * Но у меня рекурретная формула. Мне больше подходит шаблон yield return
    * Как совокуплять эти хеши с двоеточиями в алгоритме - ХЗ ненадежно
    *
    * пробуем...
    *
    * Здесь Scala plugin ругнулся и предложил сделать варианты:
    * 1) add 'Collection BreakOut' argument
    * 2) change Stream[Int] to
    *
    * ну ладно пробуем...
    */
  //def numsFrom2(n:Int) : Stream[Int] = {
    //for(i <- n to Int.MaxValue) yield n
  //}

  def numsFrom2(n:Int) : Stream[Int] = {
    (for(i <- n to Int.MaxValue) yield n)(collection.breakOut)
  }

  def numsFrom3(n:Int) : IndexedSeq[Int] = {
    for(i <- n to Int.MaxValue) yield n
  }

  // Хм... странно следкющий пример не компилится
  // [ERROR] Illegal star of statement yield 1
  //                                   ^
  def numsFrom4(n:Int) : IndexedSeq[Int] = {
    yield 1
    yield 2
  }