Module: When

Included in:
TM::CalendarEra, TM::PeriodDuration, TM::TemporalPosition, TM::TemporalPosition, V::Event::Enumerator
Defined in:
lib/when_exe.rb,
lib/when_exe/inspect.rb,
lib/when_exe/version.rb,
lib/when_exe/basictypes.rb,
lib/when_exe/region/sun.rb,
lib/when_exe/tmduration.rb,
lib/when_exe/region/m17n.rb,
lib/when_exe/region/moon.rb,
lib/when_exe/region/pope.rb,
lib/when_exe/region/thai.rb,
lib/when_exe/region/bahai.rb,
lib/when_exe/region/mayan.rb,
lib/when_exe/region/roman.rb,
lib/when_exe/region/shire.rb,
lib/when_exe/region/world.rb,
lib/when_exe/region/french.rb,
lib/when_exe/region/indian.rb,
lib/when_exe/region/jewish.rb,
lib/when_exe/region/korean.rb,
lib/when_exe/region/ryukyu.rb,
lib/when_exe/region/chinese.rb,
lib/when_exe/region/iranian.rb,
lib/when_exe/region/islamic.rb,
lib/when_exe/region/martian.rb,
lib/when_exe/region/planets.rb,
lib/when_exe/region/tibetan.rb,
lib/when_exe/region/balinese.rb,
lib/when_exe/region/far_east.rb,
lib/when_exe/region/japanese.rb,
lib/when_exe/region/javanese.rb,
lib/when_exe/mini_application.rb,
lib/when_exe/region/christian.rb,
lib/when_exe/region/vietnamese.rb,
lib/when_exe/region/chinese_epoch.rb,
lib/when_exe/region/chinese_calendar.rb

Overview

ベトナム王位年号一覧表

（参考文献） コンサイス世界年表（三省堂） 歴代紀元編（台湾中華書局）

Defined Under Namespace

Modules: BasicTypes, CalendarTypes, Coordinates, EX, Ephemeris, Parts, RS, TM, TimeStandard, V

Constant Summary collapse

SourceURI = 
"http://hosi.org/When/"
DurationP1D =

Module Constants

TM::PeriodDuration.new([0,0,1])
DurationP1W = 
TM::PeriodDuration.new([0,0,7])
DurationP1M = 
TM::PeriodDuration.new([0,1,0])
DurationP1Y = 
TM::PeriodDuration.new([1,0,0])
TimeValue = 
TM::IndeterminateValue
UTF8 = 
'.UTF-8'
W31J = 
'.Windows-31J'
EUCJP = 
'.eucJP'
VERSION = 
"0.3.1"
CENTURY =

分解能定数

-4
DECADE = 
-3
YEAR = 
-2
MONTH = 
-1
WEEK = 
-0.5
DAY = 
0
HOUR = 
1
MINUTE = 
2
SECOND = 
3
STRING = 
5
SYSTEM = 
(Float::MANT_DIG*0.3).to_i

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.multi_thread ⇒ Boolean (readonly)

マルチスレッド対応の場合 true

Returns:

  • (Boolean) 


44
45
46
 
# File 'lib/when_exe.rb', line 44

def multi_thread
  @multi_thread
end

Class Method Details

._free_conv(calendars, dates, methods, output, options, &block) ⇒ Array

変換処理(実行部)

Parameters:

Returns:

  • (Array) —

    変換結果



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/when_exe/mini_application.rb', line 210

def _free_conv(calendars, dates, methods, output, options, &block)
  dates[0]     ||= When.now
  calendars[0] ||= When.Calendar('Gregorian')
  result = dates.map {|date|
    date = When.when?(date)
    list = calendars.dup
    (0...calendars.size).to_a.reverse.each do |i|
      case list[i]
      when When::TM::Calendar ; list.slice!(i) if options[:extent] && !list[i].domain.include?(date)
      when Class              ; 
      else
         eras = (date ^ list[i]).delete_if {|e| !e.leaf?}
         unless options[:go_back] == :All
           if options[:go_back] == :After
             eras = [eras[(eras.index {|e| e.calendar_era_name[3]}) || -1]]
           else
             eras.delete_if {|e| e.calendar_era_name[3]}
           end
         end
         list[i,1] = eras.map {|e| e.calendar_era}
      end
    end

    if methods.size == 0
      list.map {|calendar|
         calendar.kind_of?(Class) ?
         yield(calendar.new(date)) :
         yield(calendar ^ (calendar.rate_of_clock == date.rate_of_clock ? date.to_i : date))
      }
    else
      list.map {|calendar|
        date_for_calendar = calendar ^ (calendar.rate_of_clock == date.rate_of_clock ? date.to_i : date)
        methods.map {|method|
          date_for_calendar.send(method[0].to_sym, method[1], &block)
        }
      }
    end
  }
  result = result[0] while result.kind_of?(Array) && result.size == 1
  return result
end

._parse(args) ⇒ Array

引数読み込み

args [String] コマンドライン入力

Returns:

  • (Array) —

    ( calendars, dates, numbers, methods )

    calendars [Array<When::TM::Calendar or When::TM::CalendarEra>]
    dates [Array<When::TM::CalData or When::TM::DateAndTime>

    ]

    numbers [Array<Numeric>]
    methods [Array<String>

    メソッド名(‘week’, ‘month’, ‘year’) ]

    output [Array<Symbol, String>

    出力処理に使うメソッドのシンボルと引数 ]

    options [Hash{ :extent=>Boolean, :go_back=><:All || :Before(nil) || :After> } 


151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/when_exe/mini_application.rb', line 151

def _parse(args)
  calendars = []
  dates     = []
  numbers   = []
  methods   = []
  options   = {}
  output    = [:to_s]

  config    = When.config
  args.flatten.each do |arg|
    case arg
    when Numeric ; dates << arg ; numbers << arg
    when Hash    ; options.update(arg)
    when Range   ; arg.each {|d| dates << d}
    when Symbol  ; output = arg
    when String
      case arg
      when /^:(.+?)(?:\[(..)\])?$/             ; output  = [$1.to_sym, $2].compact
      when /^(year|month|week)(?:\[(..)\])?$/i ; methods << [$1.downcase + '_included', $2||'SU']
      when /^[-+\d]\d*$/                       ; dates   << arg.to_i ; numbers << arg.to_i
      when /^[-+.\d][.\d]*$/                   ; dates   << arg.to_f ; numbers << arg.to_f
      when /^now$/i                            ; dates   << When.now
      when /^today$/i                          ; dates   << When.today
      when /(^[-+\d])|\^/                      ; dates   << arg
      when /^\//
        arg[1..-1].scan(/./) do |c|
          c = c.upcase
          if config.key?(c)
            calendar = config[c]
            calendar = calendar.join(':') if calendar.kind_of?(Array)
            calendars << When.Calendar(calendar)
          elsif c == 'D'
            calendars << When::TM::JulianDate
          end
        end
      else
        begin
          calendars << ((arg == 'JulianDate') ? When::TM::JulianDate : When.Calendar(arg))
        rescue NameError, OpenURI::HTTPError
          dates << arg
        end
      end
    else
      dates << arg
    end
  end
  [calendars, dates, numbers, methods, output, options]
end

._setup_(options = {}) ⇒ void

This method returns an undefined value.

Initializations

Parameters:

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :local (When::TM::Clock, When::V::Timezone, When::Parts::Timezone) —

    デフォルトの地方時

  • :until (When::TM::IntervalLength) —

    V::Event::Enumerator の until

  • :alias (Hash{String=>String}) —

    Locale の読替パターン ({ 読替前のlocale=>読替後のlocale })

  • :order (Array<String>) —

    CalendarEra の検索順序 ([ IRI of When::TM::CalendarEra ])

  • :format (Hash{String=>Array, String}) —

    strftime で用いる記号の定義 ({ 記号=>[ 書式,項目名 ] or 記号列 })

  • :leap_seconds (Array<Array>) —

    閏秒の挿入記録 ([ [JD, TAI-UTC, (MJD, OFFSET)] ])

  • :multi_thread (Boolean) —

    マルチスレッド対応 (true: 対応, false/nil: 非対応)



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/when_exe.rb', line 59

def _setup_(options={})
  @multi_thread = options[:multi_thread]
  Parts::Resource._setup_
  Parts::Locale._setup_(options[:alias])
  TM::CalendarEra._setup_(options[:order])
  TM::Calendar._setup_
  TM::Clock._setup_(options[:local])
  TM::TemporalPosition._setup_(options[:format])
  V::Event._setup_(options[:until])
  V::Timezone._setup_
  Parts::Timezone._setup_
  TimeStandard._setup_(options[:leap_seconds])
end

.at(time, options = {}) ⇒ When::TM::DateAndTime

指定日時に対応する When::TM::TemporalPosition の生成 (When::TM::DateAndTime of specified Time)

Parameters:

  • time (::Time) —

    変換元の日時のTimeオブジェクト

  • time (Float) —

    1970-01-01T00:00:00Z からの経過秒数

  • options (Hash) (defaults to: {}) —

    暦法や時法などの指定

Returns:

See Also:



363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/when_exe.rb', line 363

def at(time, options={})
  options = options._attr if options.kind_of?(TM::TemporalPosition)
  options[:frame] ||= 'Gregorian'
  options[:frame]   = Resource(options[:frame], '_c:') if options[:frame].kind_of?(String)
  clock = TM::Clock.get_clock(options)
  jdt  = TM::JulianDate.universal_time(time.to_f * TM::IntervalLength::SECOND, {:frame=>clock})
  options[:clock]   = jdt.frame
  date = options[:frame].jul_trans(jdt, options)
  date = TM::CalDate.new(date.cal_date, options) if options[:precision] &&
                                                    options[:precision] <= DAY
  return date
end

.Calendar(calendar) ⇒ When::TM::Calendar

When::TM::Calendar の生成/参照

Parameters:

  • calendar (String) —

    暦法を表す文字列

Returns:



455
456
457
 
# File 'lib/when_exe.rb', line 455

def Calendar(calendar)
  Parts::Resource._instance(calendar, '_c:')
end

.CalendarEra(era) ⇒ When::TM::CalendarEra

When::TM::CalendarEra の生成/参照

Parameters:

  • era (String) —

    暦年代を表す文字列

Returns:



475
476
477
 
# File 'lib/when_exe.rb', line 475

def CalendarEra(era)
  Parts::Resource._instance(era, '_e:')
end

.CalendarNote(notes) ⇒ When::CalendarTypes::CalendarNote

When::CalendarTypes::CalendarNote の生成/参照

Parameters:

  • notes (String) —

    暦注リストを表す文字列

Returns:



465
466
467
 
# File 'lib/when_exe.rb', line 465

def CalendarNote(notes)
  Parts::Resource._instance(notes, '_n:')
end

.client(server, port, query) ⇒ JSON

Note:

mini_application

マイクロ・クライアントを実行する

Parameters:

  • server (String) —

    マイクロ・サーバのアドレス

  • port (#to_i) —

    つなぐポート番号

  • query (String) —

    問い合わせ文字列

Returns:

  • (JSON) —

    応答



94
95
96
97
98
99
 
# File 'lib/when_exe/mini_application.rb', line 94

def client(server, port, query)
  TCPSocket.open(server, port.to_i) do |socket|
    socket.puts(query)
    JSON.parse(socket.gets.force_encoding("UTF-8"))
  end
end

.Clock(clock) ⇒ When::TM::Clock

When::TM::Clock の生成/参照

Parameters:

  • clock (String) —

    時法を表す文字列

  • clock (Numeric) —

    秒を単位として表した時差(東経側を + とする)

  • clock (When::TM::Clock) —

    なにもせず clock をそのまま返す

Returns:

  • (When::TM::Clock) —

    clock に対応する When::TM::Clock オブジェクト



507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
 
# File 'lib/when_exe.rb', line 507

def Clock(clock)
  case clock
  when TM::Clock ; return clock
  when 'Z'       ; return utc
  when /^LMT|LAT|THS|MTC/ ; return Parts::Resource._instance('_c:' + clock)
  when Numeric   ; return utc if clock==0
  when String
    c = TM::Clock[clock] || V::Timezone[clock]
    return c if c
    clock, options = clock.split('?')
  else           ; raise TypeError, "Invalid Type: #{clock.class}"
  end
  iri  = "_tm:Clock?label=" + TM::Clock.to_hms(clock)
  iri += "&" + options if options
  Parts::Resource._instance(iri)
end

.config(path = File.expand_path($0) + '.config') ⇒ Object

設定ファイルを読み込む



32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/when_exe/mini_application.rb', line 32

def config(path=File.expand_path($0) + '.config')
  config = {}
  open(path, 'r') do |file|
    while (line=file.gets)
      next if line =~ /^\s*#/
      key, *value = line.chomp.split(':')
      value = value[0] if value.size <= 1
      config[key] = value
    end
  end
  config
rescue
  {}
end

.Duration(period, options = {}) ⇒ When::TM::Duration or Array<them>

When::TM::Duration の生成

Parameters:

  • period (String) —

    When.exe Standard Representation として解釈して生成する

  • period (Numeric) —

    When::TM::IntervalLength::SYSTEM 単位の値として解釈して生成する

  • period (Array) —

    要素を個別に解釈して生成したオブジェクトのArrayを返す

  • period (When::TM::Duration) —

    処理を行わず、そのまま返す

  • options (Hash) (defaults to: {}) —

    現時点では未使用

Returns:



413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
 
# File 'lib/when_exe.rb', line 413

def Duration(period, options={})
  case period
  when Array
    period.map {|e| Duration(e, options)}

  when TM::Duration
    period

  when 0
    TM::IntervalLength.new(0, 'day')

  when Numeric
    [TM::Duration::YEAR, TM::Duration::MONTH,  TM::Duration::WEEK, TM::Duration::DAY,
     TM::Duration::HOUR, TM::Duration::MINUTE, TM::Duration::SECOND].each do |unit|
      div, mod = period.divmod(unit)
      return TM::IntervalLength.new(div, TM::Duration::Unit.invert[unit]) if mod == 0
    end
    TM::IntervalLength.new(period, 'system')

  when String
    # IntervalLength
    args = TM::IntervalLength._to_array(period)
    return TM::IntervalLength.new(*args) if args

    # PeriodDuration
    sign, *args = TM::PeriodDuration._to_array(period)
    raise TypeError, "Argument 'period' is not a Duration" unless (sign)
    args << options
    duration = TM::PeriodDuration.new(*args)
    return (sign >= 0) ? duration : -duration

  else
    nil
  end
end

.era(key, epoch = nil, reverse = nil, options = {}) ⇒ Array<When::TM::CalendarEra>

Note:

ヒット数が不足している場合は、setup で指定した順序で When::TM::CalendarEra オブジェクトを生成しつつ読み込んで検索する。

When::TM::CalendarEra の検索

Parameters:

  • key (String, Regexp) —

    検索する暦年代または、暦年代にマッチする正規表現

  • epoch (Integer) (defaults to: nil) —

    年数を昇順にカウントする方式での暦元(0年)の通年(デフォルトは nil - 指定なし)

  • reverse (Integer) (defaults to: nil) —

    年数を降順にカウントする方式での暦元(0年)の通年(デフォルトは nil - 指定なし)

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :area (String) —

    暦年代の使用地域の指定(デフォルトは nil - 指定なし)

  • :period (String) —

    暦年代の使用時代の指定(デフォルトは nil - 指定なし)

  • :count (Integer) —

    何件ヒットするまで検索するかを指定(デフォルトは 1件)

  • the_others (String) —

    例えば When::TM::CalendarEra オブジェクトの epoch_of_use に ‘name’ などの 指定がある場合、:name に指定しておけば、検索での絞り込みに使用できる。

Returns:



495
496
497
 
# File 'lib/when_exe.rb', line 495

def era(*args)
  TM::CalendarEra._instance(*args)
end

.free_conv(*args, &block) ⇒ Array<Hash>, Array<Array<Numeric>>

Note:

暦法のIRI, When.exe Standard Expression, 最良近似分数列の分母分子などを文字列で指定

Note:

mini_application

日付の自由変換

Parameters:

  • args (Array<String>) —

    コマンドライン入力

  • block (Block) —

    ブロック

Returns:



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/when_exe/mini_application.rb', line 112

def free_conv(*args, &block)
  calendars, dates, numbers, methods, output, options = _parse(args)

  if numbers.size >= 2 && calendars.size == 0
    result = []
    When::Coordinates::Residue.new(numbers[0], numbers[1]).each { |v| result << v }
    return result
  end

  block ||= 
    if methods.size == 0
      lambda {|date| date.send(*output)}
    else
      lambda {|date, type|
        case type
        when When::YEAR  ; date.strftime("%Y")
        when When::MONTH ; date.strftime("%B %Y")
        when When::WEEK  ; nil
        when When::DAY   ; date[0]
        else             ; '-'
        end
      }
    end
  _free_conv(calendars, dates, methods, output, options, &block)
end

.M17n(source) ⇒ When::BasicTypes::M17n

When::BasicTypes::M17n の生成/参照

Parameters:

  • source (String) —

    多言語対応文字列のIRI

Returns:



566
567
568
 
# File 'lib/when_exe.rb', line 566

def M17n(source)
  Parts::Resource._instance(source, '_m:')
end

.m17n(source, namespace = nil, locale = nil, options = {}) ⇒ When::BasicTypes::M17n or Array<them>

When::BasicTypes::M17n の生成/参照

Parameters:

  • source (When::BasicTypes::M17n) —

    処理を行わず、そのままsourceを返す

  • source (String) —

    locale と 文字列の対応

  • source (Array) —

    要素を個別に解釈して生成したオブジェクトのArrayを返す

  • namespace (Hash) (defaults to: nil) —

    prefix の指定

  • locale (Array) (defaults to: nil) —

    locale の定義順序の指定

  • options (Hash) (defaults to: {}) —

    (see When::BasicTypes::M17n.new)

Returns:



581
582
583
584
585
586
587
588
589
590
591
 
# File 'lib/when_exe.rb', line 581

def m17n(source, namespace=nil, locale=nil, options={})
  case source
  when Array            ; BasicTypes::M17n.new(source, namespace, locale, options)
  when BasicTypes::M17n ; source
  when String
    return self[$1] if source =~ /^\s*\[((\.{1,2}|::)+[^\]]+)\]/ && self.kind_of?(When::Parts::Resource)
    return Parts::Resource[$1] if source =~ /^\s*\[::([^\]]+)\]/
    BasicTypes::M17n.new(source, namespace, locale, options)
  else ; raise TypeError, "Invalid Type: #{source.class}"
  end
end

.MonthName(name) ⇒ When::BasicTypes::M17n

月名

Parameters:

  • name (Numeric) —

    指定の月番号の月名を返します

  • name (String) —

    最初の3文字から決定した月名を返します。 一致する月名がない場合、名前の一致するその他のM17nを探して返します。 (name が M17n なら name 自身をそのまま返します)

Returns:



556
557
558
 
# File 'lib/when_exe.rb', line 556

def MonthName(name)
  When::BasicTypes::M17n.month_name(name)
end

.now(options = {}) ⇒ When::TM::DateAndTime

Note:

メソッド実行時の「現在日時」である。@indeterminated_position は設定しないので自動的に日時が進むことはない

現在日時に対応する When::TM::TemporalPosition の生成 (When::TM::DateAndTime of now)

Parameters:

  • options (Hash) (defaults to: {}) —

    暦法や時法などの指定

Returns:

See Also:



385
386
387
 
# File 'lib/when_exe.rb', line 385

def now(options={})
  When.at(Time.now, options)
end

.Pair(trunk, branch = nil) ⇒ When::Coordinates::Pair

When::Coordinates::Pair の生成

Parameters:

Returns:

See Also:



613
614
615
 
# File 'lib/when_exe.rb', line 613

def Pair(trunk, branch=nil)
  Coordinates::Pair._force_pair(trunk, branch)
end

.Residue(day) ⇒ When::Coordinates::Residue Also known as: day_of_week

曜日(剰余類)

Parameters:

  • day (Numeric) —

    月曜を 0 とする七曜(剰余類)を返します

  • day (String) —

    最初の3文字から決定した七曜(剰余類)を返します。 一致する七曜(剰余類)がない場合、名前の一致するその他の剰余類を探して返します。

Returns:



541
542
543
 
# File 'lib/when_exe.rb', line 541

def Residue(day)
  When::Coordinates::Residue.to_residue(day)
end

.Resource(iri, namespace = nil) ⇒ When::Parts::Resourc Also known as: IRI

When::Parts::Resource の生成/参照

Parameters:

  • iri (String) —

    IRI を表す文字列

  • namespace (String) (defaults to: nil) —

    デフォルトの namespace

Returns:

  • (When::Parts::Resourc) —

    iri (または namespace:iri) に対応する When::Parts::Resource オブジェクト



600
601
602
 
# File 'lib/when_exe.rb', line 600

def Resource(iri, namespace=nil)
  Parts::Resource._instance(iri, namespace)
end

.server(port) ⇒ void

Note:

mini_application

This method returns an undefined value.

マイクロ・サーバーを起動する

Parameters:

  • port (#to_i) —

    待ち受けるポート番号



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/when_exe/mini_application.rb', line 56

def server(port)
  config = When.config
  TCPServer.open(port.to_i) do |socket|
    puts Time.now._log_('%FT%X.%L') + ': Start'
    loop do
      Thread.start(socket.accept) do |client|
        query = client.gets.chomp.force_encoding("UTF-8")
        start = Time.now
        puts start._log_('%FT%X.%L') + ': Query - ' + When::Parts::Locale.translate(query, config['!'])
        begin
          client.puts JSON.generate(Array(free_conv(*query.split(/\s+/)))).to_s
          stop = Time.now
          puts stop._log_('%FT%X.%L') + ": Respond (%7.0f ms)" % (1000 * (stop.to_f - start.to_f))
        rescue => err
          puts Time.now._log_('%FT%X.%L') + ': error - ' + err.to_s
          client.puts JSON.generate({:error=>query}).to_s
        end
        client.close
      end
    end
  end
rescue Exception => e
  puts Time.now._log_('%FT%X.%L') + ': Exception - ' + e.to_s
ensure
  puts Time.now._log_('%FT%X.%L') + ': Done.'
end

.TemporalPosition(*args, options = {}) ⇒ When::TM::TemporalPosition

When::TM::TemporalPosition の生成

Parameters:

  • args (String or [String, Integer], Numeric, ...) —
    String

    年号

    Array<String, Integer>

    年号と 0 年の通年

    Numeric

    年月日時分秒(途中で打ち切り可)

  • options (Hash) (defaults to: {}) —

    暦法や時法などの指定

Options Hash (options):

  • :invalid (Symbol) —
    :raise 日時が存在しない場合例外発生
    :check 日時が存在しない場合 nil を返す
    その他/nil 日時が存在することを確認しない(デフォルト)

See Also:

Returns:

Raises:

  • (ArgumentError) —

    options[ :invalid ] が :raise で、日時が存在しない場合



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/when_exe.rb', line 315

def TemporalPosition(*args)
  # 引数の解釈
  options  = args[-1].kind_of?(Hash) ? args.pop.dup : {}
  validate = options.delete(:invalid)
  options  = TM::TemporalPosition._options(options)
  options[:frame]  ||= 'Gregorian'
  options[:frame]    = Resource(options[:frame], '_c:') if options[:frame].kind_of?(String)
  options[:era_name] = args.shift if args[0].kind_of?(String) || args[0].kind_of?(Array)

  # 時間位置の生成
  date = Array.new(options[:frame].indices.length+1) {args.shift}
  if (args.length > 0)
    options[:clock] ||= TM::Clock.local_time || utc
    time = Array.new(options[:clock].indices.length) {args.shift}
    position = TM::DateAndTime.new(date, time.unshift(0), options)
  else
    position = TM::CalDate.new(date, options)
  end
  return position unless [:raise, :check].include?(validate)

  # 時間位置の存在確認
  date[0] = -date[0] if position.calendar_era_name && position.calendar_era_name[2] # 紀元前
  date.each_index do |i|
    break unless date[i]
    next if Coordinates::Pair._force_pair(date[i]) == Coordinates::Pair._force_pair(position.cal_date[i])
    return nil if validate == :check
    raise ArgumentError, "Specified date not found: #{date}"
  end
  return position unless time
  time.each_index do |i|
    break unless time[i]
    next if Coordinates::Pair._force_pair(time[i]) == Coordinates::Pair._force_pair(position.clk_time.clk_time[i])
    return nil if validate == :check
    raise ArgumentError, "Specified time not found: #{time}"
  end
  return position
end

.today(options = {}) ⇒ When::TM::CalDate

Note:

メソッド実行時の「本日」である。@indeterminated_position は設定しないので自動的に日時が進むことはない

Note:

options で時間帯を指定しても「本日」の決定に使用するのみで、戻り値には反映されない

本日に対応する When::TM::CalDate の生成 (When::TM::CalDate of today)

Parameters:

  • options (Hash) (defaults to: {}) —

    暦法や時法などの指定

Returns:

See Also:



399
400
401
 
# File 'lib/when_exe.rb', line 399

def today(options={})
  now(options.merge({:precision=>DAY}))
end

.utc ⇒ When::CalendarTypes::UTC

When::CalendarTypes::UTC の生成/参照

Returns:



528
529
530
 
# File 'lib/when_exe.rb', line 528

def utc
  Parts::Resource._instance("_c:UTC")
end

.when?(specification, options = {}) ⇒ When::TM::TemporalPosition, ...

Generation of Temporal Objetct, duration or When::Parts::GeometricComplex

Parameters:

Returns:



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/when_exe.rb', line 281

def when?(specification, options={})

  # フォーマットごとの処理
  case specification
  when TM::TemporalPosition, Parts::GeometricComplex ; specification
  when TM::Position ; specification.any_other
  when Array        ; begin options = TM::TemporalPosition._options(options) ; specification.map {|e| when?(e, options)} end
  when /^today$/i   ; today(options)
  when /^now$/i     ; now(options)
  when /[\n\r]+/    ; when?(specification.split(/[\n\r]+/), options)
  when String       ; TM::TemporalPosition._instance(specification, options)
  when Numeric      ; TM::JulianDate.new(+specification, TM::TemporalPosition._options(options))
  else              ; Calendar(options[:frame] || 'Gregorian').jul_trans(specification, options)
  end
end