when_exe 0.2.100 → 0.3.1

data/lib/when_exe/parts/geometric_complex.rb

@@ -0,0 +1,379 @@
+# -*- coding: utf-8 -*-
+=begin
+  Copyright (C) 2011-2013 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
+
+  #
+  # 任意個の端点から構成する [Range] の subclass
+  #
+  class GeometricComplex < Range
+
+    include Comparable
+
+    # 範囲の反転
+    # @return [Boolean]
+    #   [ true  - 反転する   ]
+    #   [ false - 反転しない ]
+    #
+    # @note
+    #   無限の過去(-Infinity)を範囲に含むか否かと同値である
+    #
+    attr_reader :reverse
+
+    #
+    # When::Parts::GeometricComplex を構成する端点の Array
+    #
+    # @return [Array<Array<Comparable, Boolean>>]
+    #   -  Comparable - 端点
+    #   -  Boolean
+    #        @reverse == true の場合
+    #          true  - 範囲に含まない
+    #          false - 範囲に含む
+    #        @reverse == false の場合
+    #          true  - 範囲に含む
+    #          false - 範囲に含まない
+    #
+    # @example +[[3,true],[4,false]] は Range(3+...4)に対応する
+    #
+    attr_reader :node
+
+    # 最小の端点
+    #
+    # @param [Comparable] default 端点が-∞の場合に返すべき値(指定がなければ nil)
+    #
+    # @return [Comparable] 最小の端点
+    #
+    # @note
+    #   含むか否かに関わらず、最小の端点を返す。
+    #   default が指定されているが有効な区間がない場合、nil を返す。
+    #
+    def first(default=nil)
+      return (@node.length==0) ? nil : @node[0][0] unless default # 互換性
+      if reverse
+        return default
+      else
+        (@node.length==0) ? nil : @node[0][0]
+      end
+    end
+    alias :begin :first
+
+    # 最大の端点
+    #
+    # @param [Comparable] default 端点が+∞場合に返すべき値(指定がなければ nil)
+    #
+    # @return [Comparable] 最大の端点
+    #
+    # @note
+    #   含むか否かに関わらず、最大の端点を返す
+    #   default が指定されているが有効な区間がない場合、nil を返す
+    #
+    def last(default=nil)
+      return (@node.length==0) ? nil : @node[-1][0] unless default # 互換性
+      if reverse
+        return (@node.length[0]==0) ? default : @node[-1][0]
+      else
+        return nil if (@node.length==0)
+        return (@node.length[0]==1) ? default : @node[-1][0]
+      end
+    end
+    alias :end :last
+
+    # 端点が範囲に含まれるか?
+    #
+    # @param [Integer] index 端点の番号(デフォルト : -1 - 最大の端点)
+    #
+    # @return [Boolean]
+    #   [ true  - 含まれる   ]
+    #   [ false - 含まれない ]
+    #
+    def exclude_end?(index=-1)
+      (@node.length==0) ? nil : !@node[index][1] ^ @reverse
+    end
+
+    # 分解能
+    #
+    # @return [Integer] 最小の端点の分解能を返す
+    #
+    # @note
+    #   分解能がない場合は、When::SYSTEM を返す
+    #
+    def precision
+      @node[0] && @node[0][0].respond_to?(:precision) ? @node[0][0].precision : Coordinates::SYSTEM
+    end
+
+    # 範囲を反転する
+    #
+    # @return [When::Parts::GeometricComplex]
+    #
+    def -@
+      GeometricComplex.new(self, true)
+    end
+
+    # 最小の端点と other を比較する
+    #
+    # @param [Comparable] other 比較対象
+    #
+    # @return [Integer] 比較結果を 負, 0, 正の値で返す
+    #
+    def <=>(other)
+      first <=> other
+    end
+
+    # 和集合
+    #
+    # @param [Range, When::Parts::GeometricComplex] other
+    #
+    # @return [When::Parts::GeometricComplex] self と other の和集合を返す
+    #
+    def |(other)
+      other = GeometricComplex.new(other) unless other.kind_of?(GeometricComplex)
+      return self if self.reverse && self.node.length==0
+      return other | self if !self.reverse && other.reverse
+      copy = self.node.dup
+      ref  = other.node.dup
+      max  = _max(copy.shift.dup, ref.shift.dup) if (other.reverse)
+      rev  = max ? false : @reverse
+      while (ref.length > 0) do
+        first, last, *ref = ref
+        updated  = _upper(copy, first, rev)
+        updated += _lower(copy, last, rev) if last
+        copy = updated
+      end
+      copy = _lower(copy, max, true) if max
+      return GeometricComplex.new(copy, self.reverse)
+    end
+
+    # ISO19108 の TM オブジェクトに変換する
+    #
+    # @param [Hash] options When::TM::TemporalPosition の生成を行う場合に使用する
+    #   (see {When::TM::TemporalPosition._instance})
+    #
+    # @return [When::TM::Node, When::TM::Edge, When::TM::TopologicalComplex]
+    #
+    def to_tm_object(options={})
+      return nil unless !@reverse && @node.length>0 && @node.length[0]==0
+      objects    = []
+      primitives = @node.dup
+      while (primitives) do
+        first, last, primitives = primitives
+        if (first[0].eql?(last[0]))
+          objects = When::TM::Node.new(When::TM::Instant.new(When.when?(first[0],options)))
+        else
+          objects = When::TM::Edge.new(When::TM::Node.new(When::TM::Instant.new(When.when?(first[0],options))),
+                                       When::TM::Node.new(When::TM::Instant.new(When.when?(last[0],options))))
+        end
+      end
+      return objects[0] if objects.length==1
+      return When::TM::TopologicalComplex.new(objects)
+    end
+
+    # 範囲に含まれるか?
+    #
+    # @param [Comparable] other 判断する Comparable
+    #
+    # @return [Boolean]
+    #   [ true  - 範囲に含まれる   ]
+    #   [ false - 範囲に含まれない ]
+    #
+    # @note 制限事項
+    #   When::TM::TopologicalComplex どうしの包含判定は、和集合がもとの範囲と等しいか
+    #   で判断している。分解能が When::SYSTEM でない場合、論理的には等しいものが、
+    #   内部表現が異なるために等しくないとみなされる事があり、その場合 true であるべき
+    #   ものを false と誤判断する。実行速度上の制約もあり、現時点では対策しない。
+    #
+    def include?(other)
+      if (other.kind_of?(Comparable) && !other.kind_of?(GeometricComplex))
+        return (_include_point?(other) != false)
+      else
+        other = GeometricComplex.new(other) unless other.kind_of?(GeometricComplex)
+        return _include_range?(other)
+      end
+    end
+    alias :=== :include?
+
+    # Enumerator._exclude 専用
+    # @private
+    def _include?(other)
+      if (other.kind_of?(Comparable) && !other.kind_of?(GeometricComplex))
+        return _include_point?(other)
+      else
+        other = GeometricComplex.new(other) unless other.kind_of?(GeometricComplex)
+        return _include_range?(other) && _include_point?(other.first)
+      end
+    end
+
+    # オブジェクトの生成
+    #
+    # @overload initialize(range, reverse=false)
+    #   @param [Range] range
+    #
+    # @overload initialize(point, reverse=false)
+    #   range = Range(point..point) と同じ
+    #   @param [Comparable] point 
+    #
+    # @overload initialize(first, last, reverse=false)
+    #   range = Range(first...last) と同じ
+    #   @param [Comparable] first
+    #   @param [Comparable] last
+    #
+    # @overload initialize(first, duration, reverse=false)
+    #   range = Range(first...(first+duration)) と同じ
+    #   @param [Comparable] first
+    #   @param [When::TM::Duration] duration
+    #
+    # @overload initialize(other, reverse=false)
+    #   もとの When::Parts::GeometricComplex のコピー
+    #   @param [When::Parts::GeometricComplex] other  
+    #
+    # @overload initialize(node, reverse=false)
+    #   指定した node 構造の When::Parts::GeometricComplex を生成
+    #   @param [Array<Array<Comparable, Boolean>>] note
+    #     - Comparable - 端点
+    #     - Boolean
+    #         @reverse == true の場合
+    #           true  - 範囲に含まない
+    #           false - 範囲に含む
+    #         @reverse == false の場合
+    #           true  - 範囲に含む
+    #           false - 範囲に含まない
+    # @note
+    #   すべての呼び出しパターンに共通の最終引数 reverse を付けることができる
+    #     reverse [Boolean]
+    #       true  - 反転する
+    #       false - 反転しない
+    #
+    def initialize(*args)
+
+      @reverse = (args[-1]==true || args[-1]==false) ? args.pop : false
+
+      case args[0]
+      when GeometricComplex
+        @node     = args[0].node
+        @reverse ^= args[0].reverse
+        super(self.first, self.last, exclude_end?) if self.first && self.last
+        return
+
+      when Array
+        @node = args[0]
+        super(self.first, self.last, exclude_end?) if self.first && self.last
+        return
+
+      when Range
+        first = [args[0].first, true]
+        last  = [args[0].last, !args[0].exclude_end?]
+
+      when Comparable
+        first, last, rest = args
+        raise ArgumentError, "Too many argument: #{rest}" if rest
+        first = [first, true]
+        case last
+        when Comparable         ; last = [last, false]
+        when When::TM::Duration ; last = [first[0] + last, false]
+        when nil                ; last = first
+        else ; raise TypeError, "Irregal GeometricComplex Type for last element: #{last.class}"
+        end
+
+      when nil ;
+      else ; raise TypeError, "Irregal GeometricComplex Type: #{first.class}"
+      end
+
+      first, last = last, first if (first && last && first[0] > last[0])
+      @node = []
+      @node << first if first
+      @node << last  if last
+      super(self.first, self.last, exclude_end?) if first && last
+    end
+
+    private
+
+    def _include_range?(other)
+      union = self | other
+      return false unless self.node == union.node
+      return self.reverse == union.reverse
+    end
+
+    def _include_point?(other)
+      @node.each_index do |i|
+        current = @node[i]
+        verify  = other <=> current[0]
+        if (verify < 0)
+          return false if ((i[0]==0) ^ @reverse)
+          return @node[[0,i-1].max][0]
+        elsif (verify == 0)
+          return false unless (@reverse ^ current[1])
+          return current[0]
+        end
+      end
+      return  (@reverse ? nil : false) if @node.length==0
+      return false if ((@node.length[0]==0) ^ @reverse)
+      return @node[-1][0]
+    end
+
+    def _upper(node, point, reverse)
+      node  = node.dup
+      point = point.dup
+      point[1] = !point[1] if reverse
+      node.each_index do |i|
+        if (_verify(point, node[i], reverse) <= 0)
+          node[i..-1] = ((i[0]==0) ^ reverse) ? [point] : []
+          return node
+        end
+      end
+      node.push(point) if (node.length[0]==0) ^ @everse
+      return node
+    end
+
+    def _lower(node, point, reverse)
+      node  = node.dup
+      point = point.dup
+      point[1] = !point[1] if reverse
+      (node.length-1).downto(0) do |i|
+        if (_verify(point, node[i], reverse) >= 0)
+          node[0..i] = ((i[0]==1) ^ reverse) ? [point] : []
+          return node
+        end
+      end
+      node.unshift(point) if (node.length[0]==0) ^ reverse
+      return node
+    end
+
+    def _verify(point, node, reverse)
+      verify = point[0] <=> node[0]
+      return verify unless verify == 0
+      if point[0].respond_to?(:precision) && node[0].respond_to?(:precision)
+        point[0] = node[0] if point[0].precision >= node[0].precision
+      end
+      if reverse
+        point[1] &= node[1]
+      else
+        point[1] |= node[1]
+      end
+      return verify
+    end
+
+    def _max(p1, p2)
+      p1[1] = !p1[1]
+      p2[1] = !p2[1]
+      verify = p1[0] <=> p2[0]
+      return p1 if (verify>0)
+      return p2 if (verify<0)
+      p1[1] |= p2[1]
+      return p1
+    end
+
+    # その他のメソッド
+    #   When::Parts::GeometricComplex で定義されていないメソッドは
+    #   処理を first (type: When::TM::(Temporal)Position) に委譲する
+    #
+    def method_missing(name, *args, &block)
+      first.send(name.to_sym, *args, &block)
+    end
+  end
+end

data/lib/when_exe/parts/locale.rb

@@ -0,0 +1,513 @@
+# -*- 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
+
+  #
+  # Multilingualization(M17n) 対応モジュール
+  #
+  #   When::BasicTypes::M17n の実装のうち When::BasicTypes 内部で
+  #   定義すべきでない部分を切り出してモジュールとしている
+  #
+  module Locale
+
+    # Locale 読み替えの初期設定
+    Alias = {'alias'=>'ja', '日本語'=>'ja', '英語'=>'en'}
+
+    # 漢字の包摂
+    DefaultUnification = {
+      '煕' => '熙',
+      '廣' => '広',
+      '寶' => '宝',
+      '國' => '国',
+      '應' => '応',
+      '觀' => '観',
+      '龜' => '亀',
+      '齊' => '斉',
+      '靈' => '霊',
+      '攝' => '摂',
+      '壽' => '寿',
+      '萬' => '万',
+      '廢' => '廃',
+      '顯' => '顕',
+      '會' => '会',
+      '聰' => '聡',
+      '總' => '総',
+      '證' => '証',
+      '禮' => '礼',
+      '竜' => '龍',
+    }
+
+    # @private
+    Escape = '__!_ESCAPE_%2C_!__'
+
+    class << self
+
+      # When::Parts::Locale Module のグローバルな設定を行う
+      #
+      # @param [Hash] aliases
+      #   Locale の読み替えパターンを Hash で指定する。
+      #   aliases の指定がない場合、aliases は Alias(モジュール定数)と解釈する。
+      #
+      def _setup_(aliases=nil)
+        @aliases = aliases || Alias
+      end
+
+      # 特定 locale に対応した文字列の取得
+      #
+      # @param [String] source もとにする String または M17n
+      #
+      # @param[String] loc locale の指定 ( lang[-|_]country.encode )
+      #   [ lang    - 言語               ]
+      #   [ country - 国(省略可)         ]
+      #   [ encode  - 文字コード(省略可) ]
+      #
+      # @return [String] loc に対応した文字列
+      #
+      # @note source が Hash や Array の場合、その構成要素を変換して返す
+      #
+      def translate(source, loc='')
+        return source unless loc
+        case source
+        when Hash
+          result = {}
+          source.each_pair do |key, value|
+            result[translate(key, loc)] = translate(value, loc)
+          end
+          return result
+        when Array
+          return source.map {|value| translate(value, loc)}
+        when Locale
+          return source.translate(loc)
+        when String
+          return source.encode($1) if loc =~ /\.(.+)$/
+        end
+        source
+      end
+
+      # 包摂リストに登録されている文字を包摂する
+      #
+      # @param [When::Parts::Locale] source 文字を包摂しようとする国際化文字列
+      # @param [String] source 文字を包摂しようとする文字列
+      # @param [Regexp] source 文字を包摂しようとする正規表現
+      # @param [Hash] pattern 包摂ルール
+      #
+      # @return [When::Parts::Locale] 文字を包摂した国際化文字列
+      # @return [String] 文字を包摂した文字列
+      # @return [Regexp] 文字を包摂した正規表現
+      #
+      def ideographic_unification(source, pattern=DefaultUnification)
+        case source
+        when When::Parts::Locale
+          source.ideographic_unification(pattern)
+        when Regexp
+          Regexp.compile(ideographic_unification(source.source.encode('UTF-8'), pattern), source.options)
+        when String
+          source.gsub(/./) do |c|
+            pattern[c] ? pattern[c] : c
+          end
+        else
+          source
+        end
+      end
+
+      # 文字列で表現された namespace 指定を Hash に変換する
+      # @private
+      def _namespace(source=nil)
+        case source
+        when Hash ; return source
+        when nil  ; return {}
+        when String
+          namespace = {}
+          source = $1 if (source=~/\A\s*\[?(.+?)\]?\s*\z/m)
+          source.split(/[\n\r,]+/).each do |v|
+            v.strip!
+            next if (v=~/^#/)
+            pair = [''] + v.split(/\s*=\s*/, 2)
+            namespace[pair[-2]] = pair[-1]
+          end
+          return namespace
+        else ; raise TypeError, "Irregal Namespace Type"
+        end
+      end
+
+      # locale 指定を Array に変換する
+      # @private
+      def _locale(source=nil)
+        # default の Locale
+        return [[nil, '', nil]] unless source
+
+        # source の配列化
+        if source.kind_of?(String)
+          source = $1 if (source=~/\A\s*\[?(.+?)\]?\s*\z/m)
+          source = source.split(/[\n\r,]+/)
+        end
+
+        # 各Localeの展開
+        source.map {|v|
+          if v.kind_of?(String)
+            v = v.strip
+            next if (v=~/^#/)
+            (v =~ /^(\*)?(.*?)(?:\s*=\s*(.+))?$/) ? $~[1..3] : [[nil, '', nil]]
+          else
+            v
+          end
+        }.compact
+      end
+
+      # 文字列 [.., .., ..] を分割する
+      # @private
+      def _split(line)
+        line  = line.dup
+        b = d = s = 0
+        (line.length-1).downto(0) do |i|
+          bs = 0
+          (i-1).downto(0) do |k|
+            break unless (line[k,1] == '\\')
+            bs += 1
+          end
+          next if (bs[0] == 1)
+          case line[i,1]
+          when "'" ; s  = 1-s  if (d == 0)
+          when '"' ; d  = 1-d  if (s == 0)
+          when ']' ; b += 1 if  (d+s == 0)
+          when '[' ; b -= 1 if  (d+s == 0 && b > 0)
+          when ',' ; line[i,1] = Escape if (b+d+s == 0)
+          end
+        end
+        return (line =='') ? [''] : line.split(Escape, -1)
+      end
+
+      # locale 指定を解析して Hash の値を取り出す
+      # @private
+      def _hash_value(hash, locale, default='')
+        locale = locale.sub(/\..*/, '').sub(/-/,'_')
+        return hash[locale] if (hash[locale])
+        return _hash_value(hash, _alias[locale], default) if (_alias[locale])
+        language = locale.sub(/_.*/, '')
+        return hash[language] if (hash[language])
+        return hash[default]
+      end
+
+      private
+
+      def _alias
+        @aliases || Alias
+      end
+    end
+
+    # ローケール指定時の文字列
+    #
+    # @return [Hash]
+    attr_reader :names
+
+    # 有効なローケール指定
+    #
+    # @return [Array<String>]
+    attr_reader :keys
+
+    # 有効な文字列 - additional attribute
+    #
+    # @return [Array<String>]
+    attr_reader :values
+
+    # 文字列の説明 - additional attribute
+    #
+    # @return [Hash] { anyURI }
+    attr_reader :link
+
+    # Rails 用 I18n 定義へのアクセス・キー
+    #
+    # @return [String]
+    attr_reader :access_key
+    protected :access_key
+
+    # 特定 locale に対応した文字列の取得
+    #
+    # @param [String] loc locale の指定 ( lang[-|_]country.encode )
+    #   [ lang    - 言語               ]
+    #   [ country - 国(省略可)         ]
+    #   [ encode  - 文字コード(省略可) ]
+    #
+    # @return [String] loc に対応した文字列
+    #
+    def translate(loc='')
+      return to_s unless loc
+      lang, code = loc.split(/\./)
+      result = _label_value(loc)
+      return result if !code || @names.member?(loc)
+      return result.encode(code)
+    end
+    alias :/ :translate
+
+    # 特定 locale に対応した reference URI の取得
+    #
+    # @param [String] loc locale の指定
+    #
+    # @return [String] loc に対応した reference URI
+    #
+    def reference(loc='')
+      loc ||= ''
+      return Locale._hash_value(@link, loc)
+    end
+
+    # 部分文字列
+    #
+    # @param [Range] range String#[] と同様の指定方法で範囲を指定する
+    #
+    # @return [When::Parts::Locale] 指定範囲に対応した部分文字列
+    #
+    def [](range)
+      dup._copy({
+        :label => to_s[range],
+        :names => @names.keys.inject({}) {|l,k|
+          l[k] =  @names[k][range]
+          l
+        }
+      })
+    end
+
+    # 文字列の一致
+    #
+    # @param [String, Regexp] regexp マッチする正規表現
+    #
+    # @return [Integer] マッチした位置のindex(いずれかの locale でマッチが成功した場合)
+    # @return [nil]     すべての locale でマッチに失敗した場合
+    #
+    def =~(regexp)
+      @keys.each do |key|
+        index = (@names[key] =~ regexp)
+        return index if index
+      end
+      return nil
+    end
+
+    # 文字列の連結
+    #
+    # @param [String, When::Toos::Locale] other 連結する文字列
+    #
+    # @return [When::Toos::Locale] 連結された文字列
+    #
+    def +(other)
+      names = {}
+      case other
+      when Locale
+        (@names.keys + other.names.keys).uniq.each do |key|
+          names[key] = _label_value(key) + other._label_value(key)
+        end
+      else
+        @names.keys.each do |key|
+          names[key] = _label_value(key) + other.to_s
+        end
+      end
+      return dup._copy({:names=>names, :label=>to_s + other.to_s})
+    end
+
+    # 書式指定による文字列化
+    #
+    # @param [Array<Object>] other 文字列化する Object の Array
+    # @param [Array<String>] locale 文字列化を行う locale の指定(デフォルト : すべて)
+    #
+    # @return [When::Toos::Locale] 文字列化された Object
+    #
+    def _printf(other, locale=nil)
+      # 処理する配列
+      terms = other.kind_of?(Array) ? [self] + other : [self, other]
+
+      # locale key の配列
+      if locale == []
+        keys = []
+      else
+        keys = terms.inject([]) {|k,t|
+          k += t.keys if t.kind_of?(Locale)
+          k
+        }.uniq
+        if locale
+          locale = [locale] unless locale.kind_of?(Array)
+          keys   = locale | (locale & keys)
+        end
+      end
+      keys << nil if keys.include?('')
+
+      # names ハッシュ
+      names = keys.inject({}) {|l,k|
+        l[k] = When::Coordinates::Pair._format(
+                 (block_given? ? yield(k, *terms) : terms).map {|t|
+                   t.kind_of?(Locale) ? t.translate(k) : t
+                 }
+               )
+        l
+      }
+
+      # 生成
+      # @private
+      dup._copy({
+        :label => keys.include?('') ? names.delete(nil) : (names[''] = names[keys[0]]),
+        :names => names
+      })
+    end
+    alias :% :_printf
+
+    # ローケールの更新
+    #
+    # @param [Hash] options 下記の通り
+    # @option options [String] カントリーコード 表現文字列
+    # @option options [Hash]   :link            { カントリーコード => 参照URL文字列 }
+    # @option options [String] :code_space      規格や辞書を特定するコードスペースのURL文字列
+    # @option options [String] :label           代表文字列
+    # @note Hashキーはすべて Optional で、存在するもののみ更新します
+    #
+    # @return [self] 更新された Object
+    #
+    def update(options={})
+      options = options.dup
+      @link.update(options.delete(:link))       if (options.key?(:link))
+      @code_space = options.delete(:code_space) if (options.key?(:code_space))
+      self[0..-1] = options.delete(:label)      if (options.key?(:label))
+      unless (options.empty?)
+        @names.update(options)
+        @keys     = @names.keys.sort
+        @values   = @names.values.sort.reverse
+      end
+      return self
+    end
+
+    # 包摂リストに登録されている文字を包摂する(自己破壊)
+    #
+    # @param [Hash] pattern 包摂ルール
+    #
+    # @return [When::Parts::Locale] self
+    # @private
+    def ideographic_unification!(pattern=DefaultUnification)
+      names = {}
+      @names.each_pair do |key, value|
+        names[key] = Locale.ideographic_unification(value, pattern)
+      end
+      @names  = names
+      @values = @names.values.sort.reverse
+      self[0..-1] = Locale.ideographic_unification(self.to_s[0..-1], pattern)
+      return self
+    end
+    protected :ideographic_unification!
+
+    # 包摂リストに登録されている文字を包摂する(自己保存)
+    #
+    # @param [Hash] pattern 包摂ルール
+    #
+    # @return [When::Parts::Locale] 包摂結果
+    #
+    def ideographic_unification(pattern=DefaultUnification)
+      dup.ideographic_unification!(pattern)
+    end
+
+    # 閏の表記を扱うための書式付整形
+    # @private
+    def prefix(other, locale=nil)
+      return self.dup unless other
+      other = m17n(other) unless other.kind_of?(Locale)
+      other._printf(self, locale) do |k, *t|
+        t[0]  = t[0].translate(k)
+        t[0] += "%s" unless t[0] =~ /%[-+]?[.\d]*s/
+        t
+      end
+    end
+
+    protected
+
+    # @private
+    def _copy(options={})
+      if (options.key?(:names))
+        @names    = options[:names]
+        @keys     = @names.keys.sort
+        @values   = @names.values.compact.sort.reverse
+      end
+      @link       = options[:link]       if (options.key?(:link))
+      @code_space = options[:code_space] if (options.key?(:code_space))
+      @access_key = options[:access_key] if (options.key?(:access_key))
+      self[0..-1] = options[:label]      if (options.key?(:label))
+      return self
+    end
+
+    # @private
+    def _copy_all(other)
+      _copy({:names      => other.names,
+             :link       => other.link,
+             :code_space => other.code_space,
+             :access_key => other.access_key,
+             :label      => other.to_s
+            })
+    end
+
+    # locale 指定を解析して @names の値を取り出す
+    # @private
+    def _label_value(locale)
+      label = Locale._hash_value(@names, locale, nil)
+      return label if label
+      addition = When::BasicTypes::M17n._get_locale(locale, @access_key)
+      return @names[''] unless addition
+      update(addition)
+      return Locale._hash_value(@names, locale)
+    end
+
+    private
+
+    def _names(names, namespace, default_locale)
+
+      # names, link の組み立て
+      @names = {}
+      @link  = {}
+
+      if (names.kind_of?(String))
+        unless (names=~/\A\s*\[(.+?)\]\s*\z/m)
+          names      = names.strip
+          @names[''] = names
+          @keys      = ['']
+          @values    = [names]
+          return names
+        end
+        names = $1.split(/[\n\r,]+/)
+      end
+
+      mark     = []
+      asterisk = []
+      default_locale  = default_locale.dup
+      names.each do |v|
+        v.strip!
+        case v
+        when '', /^#/ ;
+        when /^\/(.+)/; @access_key = $1
+        when /^(\*)?(?:([^=%]*?)\s*:)?\s*(.+?)\s*(=\s*(.+?)?)?$/
+          asterisk[0], locale, name, assignment, ref = $~[1..5]
+          asterisk[1], locale, default_ref = default_locale.shift unless locale
+          locale ||= ''
+          ref    ||= default_ref unless (assignment)
+          ref    ||= ''
+          mark[0]  = locale if asterisk[0]
+          mark[1]  = locale if asterisk[1]
+          mark[2]  = locale unless mark[2]
+          @names[locale] = name
+          if (ref =~ /^(.+):/)
+            prefix = namespace[$1]
+            ref.sub!(/^.+:/, prefix) if (prefix)
+          end
+          ref += URI.encode(name) if (ref =~ /[\/#:]$/)
+          @link[locale] = ref
+        else ; raise ArgumentError, "Irregal locale format"
+        end
+      end
+
+      # keys, values の準備
+      @keys   = @names.keys.sort
+      @values = @names.values.sort.reverse
+
+      return @names[mark[0] || mark[1] || mark[2]]
+    end
+  end
+end