when_exe 0.2.100 → 0.3.1

data/lib/when_exe/parts/enumerator.rb

@@ -0,0 +1,472 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-2012 Takashi SUGA
+
+  You may use and/or modify this file according to the license described in the LICENSE.txt file included in this archive.
+=end
+
+#
+# 本ライブラリのための諸々の部品
+#
+module When::Parts
+
+  #
+  # v1.8.x のための互換性確保用
+  #
+  # @private
+  class Enumerator < ::Enumerator  ; end if Object.const_defined?(:Enumerator)
+
+  #
+  # 本ライブラリ用の Enumerator の雛形
+  #
+  class Enumerator
+
+    # @private
+    def self._options(args)
+      options  = args[-1].kind_of?(Hash) ? args.pop.dup : {}
+      options[:exdate] =
+        case options[:exdate]
+        when GeometricComplex ; options[:exdate].dup
+        when nil ; GeometricComplex.new()
+        else ; GeometricComplex.new(options[:exdate])
+        end
+      return options
+    end
+
+    # 生成元オブジェクト
+    # @return [Comparable]
+    attr_reader :parent
+
+    # オプション
+    # @return [Hash]
+    # @private
+    attr_accessor :options
+    protected :options=
+
+    # 除外要素
+    # @return [When::Parts::GeometricComplex]
+    attr_accessor :exdate
+    protected :exdate=
+
+    # 処理済み要素
+    # @return [When::Parts::GeometricComplex]
+    attr_accessor :processed
+    protected :processed=
+
+    # 最初の要素
+    # @return [Comparable]
+    attr_accessor :first
+    protected :first=
+
+    # 最後の要素
+    # @return [Comparable]
+    attr_accessor :last
+    protected :last=
+
+    # 繰り返し方向
+    # @return [Symbol]
+    #   [ :forward - 昇順 ]
+    #   [ :reverse - 降順 ]
+    attr_reader :direction
+
+    # 最大繰り返し回数
+    # @return [Integer]
+    attr_reader :count_limit
+
+    # 現在の繰り返し回数
+    # @return [Integer]
+    attr_reader :count
+
+    # 現在の要素
+    # @return [Comparable]
+    attr_accessor :current
+    protected :current=
+
+    # 現在のインデックス
+    # @return [Integer]
+    # @private
+    attr_reader :index
+
+    # with_object メソッドで渡すインスタンス
+    # @return [Comparable]
+    # @private
+    attr_accessor :object
+    protected :object=
+
+    #
+    # ブロックを評価する
+    #
+    # @return [rewind された self]
+    #
+    def each
+      return self unless block_given?
+      while (has_next?) do
+        if @index
+          yield(succ, @index)
+          @index += 1
+        elsif @object
+          yield(succ, @object)
+        else
+          yield(succ)
+        end
+      end
+      @index = @object = nil
+      rewind
+    end
+
+    #
+    # index をブロックに渡して評価する
+    #
+    # @param [Integer] offset index の初期値
+    #
+    # @return [When::Parts:Enumerator]
+    #   [ ブロックあり - rewind された self ]
+    #   [ ブロックなし - copy ]
+    #
+    def with_index(offset=0, &block)
+      if block_given?
+        @index = offset||@count
+        return each(block)
+      else
+        copy = _copy
+        copy.object = nil
+        copy.index  = offset||@count
+        return copy
+      end
+    end
+
+    #
+    # index をブロックに渡して評価する
+    #
+    # @param [Comparable] object ブロックに渡す Object
+    #
+    # @return [When::Parts:Enumerator]
+    #   [ ブロックあり - rewind された self ]
+    #   [ ブロックなし - copy ]
+    #
+    def with_object(object, &block)
+      if block_given?
+        @object = object
+        each(block)
+        return object
+      else
+        copy = _copy
+        copy.object = object
+        copy.index  = nil
+        return copy
+      end
+    end
+
+    #
+    # 巻き戻す
+    #
+    # @return [rewind された self]
+    #
+    def _rewind
+      @processed = @exdate.dup
+      @count     = 0
+      @current   = :first
+      succ
+      self
+    end
+    alias :rewind :_rewind
+
+    #
+    # 次の要素があるか?
+    #
+    # @return [Boolean]
+    #   [ true  - ある ]
+    #   [ false - ない ]
+    #
+    def has_next?
+      return (@current != nil)
+    end
+
+    #
+    # 次の要素を取り出す
+    #
+    # @return [Comparable] 次の要素
+    # @raise [StopIteration] 次の要素がない場合 rewind して例外を発生
+    #
+    def next
+      return succ if has_next?
+      rewind
+      raise StopIteration, "Iteration Stopped"
+    end
+
+    #
+    # 次の要素を取り出す
+    #
+    # @return [Comparable]
+    #   [ 次の要素あり - 次の要素 ]
+    #   [ 次の要素なし - nil ]
+    #
+    # @note
+    #   次の要素がない場合 rewind や、StopIteration例外発生は行わない
+    #
+    def succ
+      value = @current
+      if (@count_limit.kind_of?(Numeric) && @count >= @count_limit)
+        @current = nil
+      else
+        loop do
+          @current = _succ
+          break unless (@current)
+          next if (@current == :next)
+          @current = GeometricComplex.new(@current, @duration) if @duration
+          next if _exclude(@current)
+          case @direction
+          when :reverse
+            next if (@current > @first)
+            @current = nil if (@last && @current < @last)
+            break
+          else
+            next if (@current < @first)
+            @current = nil if (@last && @current > @last)
+            break
+          end
+        end
+        @count += 1
+        _exclude(@current) if (@current)
+      end
+      return value
+    end
+
+    # オブジェクトの生成
+    #
+    # @overload initialize(parent, range, count_limit=nil))
+    #   @param [Comparable] parent 生成元
+    #   @param [Range, When::Parts::GeometricComplex] range
+    #     [ 始点 - range.first ]
+    #     [ 終点 - range.last  ]
+    #   @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
+    #
+    #   @param [Comparable] parent 生成元
+    #   @param [When::TM::TemporalPosition] first 始点
+    #   @param [Symbol] direction
+    #     [ :forward - 昇順 ]
+    #     [ :reverse - 降順 ]
+    #   @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
+    #
+    def initialize(*args)
+      @options = self.class._options(args)
+      @exdate  = @options.delete(:exdate)
+      @exevent = @options.delete(:exevent)
+      @parent, *rest = args
+      _range(rest)
+      _rewind
+    end
+
+    private
+
+    def _range(args)
+      if (args[0].instance_of?(Range))
+        range, @count_limit, others = args
+        raise ArgumentError, "Too many arguments" if (others)
+        @first   = When.when?(range.first)
+        @last    = When.when?(range.last)
+        @exdate |= @last if (range.exclude_end?)
+        if (@first > @last)
+          @first, @last = @last, @first
+          @direction = :reverse
+        else
+          @direction = :forward
+        end
+      else
+        @first, @direction, @count_limit, others = args
+        raise ArgumentError, "Too many arguments" if (others)
+        raise ArgumentError, "Too few arguments"  unless (@first)
+        @direction ||= :forward
+        @last        = nil
+      end
+    end
+
+    def _exclude(value)
+      if @exevent
+        @exevent.each do |ev|
+          return true if ev.include?(value)
+        end
+      end
+      previous    = @processed._include?(value)
+      @processed |= value if previous == false
+      registered  = (previous==value) ? previous : value
+      registered  = registered.first if registered.kind_of?(GeometricComplex)
+      registered.events ||=[]
+      registered.events << self.parent
+      registered.events.uniq!
+      return previous != false
+    end
+
+    def _copy
+      copy = dup
+      copy.options   = @options.dup   if @options
+      copy.exdate    = @exdate.dup    if @exdate
+      copy.exevent   = @exevent.dup   if @exevent
+      copy.processed = @processed.dup if @processed
+      copy.first     = @first.dup     if @first
+      copy.last      = @last.dup      if @last
+      copy.current   = @current.dup   if @current.respond_to?(:dup)
+      copy.object    = @object.dup    if @object.respond_to?(:dup)
+      return copy
+    end
+
+    #
+    # 時間位置の Array を順に取り出す Enumerator
+    #
+    class Array < Enumerator
+
+      # 整列して、重複した候補を削除
+      #
+      # @param list [Array]
+      # @param [Symbol] direction
+      #   [ :forward - 昇順 ]
+      #   [ :reverse - 降順 ]
+      #
+      # @param [Array]
+      # @note
+      #   eql? はオーバーライドしない
+      #
+      def self._sort(list, direction)
+        list = list.sort
+        prev = nil
+        list.delete_if do |x|
+          if (x == prev)
+            true
+          else
+            prev = x
+            false
+          end
+        end
+        list.reverse! if (direction == :reverse)
+        return list
+      end
+
+      # 初期リスト
+      # @return [Array]
+      # @private
+      attr_accessor :initial_list
+      protected :initial_list=
+
+      # 現在リスト
+      # @return [Array]
+      # @private
+      attr_accessor :current_list
+      protected :current_list=
+
+      #
+      # 巻き戻す
+      #
+      # @return [rewind された self]
+      # @private
+      def _rewind
+        @current_list = @initial_list.dup
+        super
+      end
+
+      # オブジェクトの生成
+      #
+      # @overload initialize(parent, list, count_limit=nil))
+      #   @param [Comparable] parent 生成元
+      #   @param [Array<When::TM::TemporalPosition>] list 順に取り出す時間位置の Array
+      #   @param [Symbol] direction
+      #     [ :forward - 昇順 ]
+      #     [ :reverse - 降順 ]
+      #   @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
+      #
+      def initialize(*args)
+        parent, list, direction, *args = args
+        raise ArgumentError, "Too few arguments" unless list
+        @initial_list = self.class._sort(list, direction||:forward)
+        super(parent, @initial_list[0], direction, *args)
+      end
+
+      private
+
+      def _succ
+        return @current_list.shift
+      end
+
+      def _copy
+        copy = super
+        copy.initial_list = @initial_list.dup
+        copy.current_list = @current_list.dup
+        return copy
+      end
+    end
+
+    #
+    # 複数の下位 Enumerator の結果を順に取り出す Enumerator
+    #
+    class Integrated < Enumerator
+
+      #
+      # 下位 Enumerator
+      #
+      # @return [Array<When::Parts::Enumerator>]
+      #
+      attr_accessor :enumerators
+      protected :enumerators=
+
+      #
+      # 巻き戻す
+      #
+      # @return [rewind された self]
+      #
+      def rewind
+        @enumerators.each do |enum|
+          enum._rewind
+        end
+        super
+      end
+
+      # オブジェクトの生成
+      #
+      # @overload initialize(parent, enumerators, first, count_limit=nil))
+      #   @param [Comparable] parent 生成元
+      #   @param [Array<When::Parts::Enumerator>] list 順に取り出す下位 Enumeratorの Array
+      #   @param [When::TM::TemporalPosition] first 始点
+      #   @param [Symbol] direction
+      #     [ :forward - 昇順 ]
+      #     [ :reverse - 降順 ]
+      #   @param [Integer] count_limit 繰り返し回数(デフォルトは指定なし)
+      #
+      def initialize(*args)
+        parent, @enumerators, *rest = args
+        raise ArgumentError, "Too few arguments" unless @enumerators.kind_of?(::Array)
+        super(parent, *rest)
+      end
+
+      private
+
+      def _copy
+        copy = super
+        copy.enumerators = @enumerators.map {|e| e._copy}
+        return copy
+      end
+
+      def _succ
+        current  = nil
+        selected = nil
+        @enumerators.each_index do |i|
+          value = @enumerators[i].current
+          next unless (value)
+          if (current)
+            verify = current <=> value
+            case @direction
+            when :reverse ; next if (verify > 0)
+            else          ; next if (verify < 0)
+            end
+            if (verify == 0)
+              next if current.kind_of?(GeometricComplex) && current.include?(value)
+              #next if current.precision <= value.precision # TODO
+            end
+          end
+          current  = value
+          selected = i
+        end
+        @enumerators[selected].succ if (selected)
+        return current
+      end
+    end
+  end
+end