Class: When::TM::TemporalPosition

Inherits:
Object
  • Object
show all
Extended by:
When, Coordinates
Includes:
Comparable, When, Coordinates, Parts::Resource, IndeterminateValue, Conversion
Defined in:
lib/when_exe/tmposition.rb,
lib/when_exe/inspect.rb

Overview

「時間位置」の基底クラス

see gml schema

Direct Known Subclasses

CalDate, ClockTime, Coordinate, OrdinalPosition

Defined Under Namespace

Modules: Conversion

Constant Summary collapse

HashProperty = 
Position::HashProperty
AMPM = 
['AM', 'PM'].map {|half| When::Parts::Resource._instance('_m:CalendarFormats::' + half)}
Format = 
{
  'a' => ['%s',   'a'], 'A' => ['%s',   'A'], 'b' => ['%s',   'b'], 'B' => ['%s',   'B'],
  'c' => When::Parts::Resource._instance('_m:CalendarFormats::DateTime'),
  'C' => ['%02d', 'C'], 'd' => ['%02d', 'd'], 'D' => '%m/%d/%y',    'e' => ['%2d',  'd'],
  'E' => ['%s',   'E'], 'F' => ['%s',   'F'], 'G' => ['%d',   'G'], 'g' => ['%02d', 'g'],
  'h' => '%b',          'H' => ['%02d', 'H'], 'I' => ['%02d', 'I'], 'j' => ['%03d', 'j'],
  'k' => ['%2d',  'H'], 'l' => ['%2d',  'I'], 'm' => ['%02d', 'm'], 'M' => ['%02d', 'M'],
  'n' => '\n',          'p' => ['%s',   'p'], 'P' => ['%s',   'P'], 'r' => '%I:%M:%S %p',
  'R' => '%H:%M',       's' => ['%d',   's'], 'S' => ['%02d', 'S'], 't' => '\t',
  'T' => '%H:%M:%S',    'u' => ['%d',   'u'], 'U' => ['%02d', 'U'], 'V' => ['%02d', 'V'],
  'w' => ['%d',   'w'], 'W' => ['%02d', 'W'],
  'x' => When::Parts::Resource._instance('_m:CalendarFormats::Date'),
  'X' => When::Parts::Resource._instance('_m:CalendarFormats::Time'),
  'y' => ['%02d', 'y'], 'Y' => ['%4d',  'Y'], 'z' => ['%s',   'z'], 'Z' => ['%s',   'Z'],
  '+' => '%a %b %d %T %z %Y'
}

Constants included from Coordinates

Coordinates::Bahai, Coordinates::CommonResidue, Coordinates::DefaultDateIndices, Coordinates::DefaultDayIndex, Coordinates::DefaultTimeIndices, Coordinates::IndianCities, Coordinates::Javanese, Coordinates::MATCH, Coordinates::Mayan, Coordinates::PERIOD, Coordinates::PERIOD_NAME, Coordinates::PRECISION, Coordinates::PRECISION_NAME, Coordinates::Tibetan, Coordinates::VALUE, Coordinates::Yi

Constants included from When

CENTURY, DAY, DECADE, DurationP1D, DurationP1M, DurationP1W, DurationP1Y, EUCJP, HOUR, MINUTE, MONTH, MinusInfinity, PlusInfinity, SECOND, STRING, SYSTEM, SourceURI, When::TimeValue, UTF8, VERSION, W31J, WEEK, YEAR

Constants included from Parts::Resource

Parts::Resource::LabelProperty

Constants included from IndeterminateValue

IndeterminateValue::After, IndeterminateValue::Before, IndeterminateValue::I, IndeterminateValue::Max, IndeterminateValue::Min, IndeterminateValue::Now, IndeterminateValue::S, IndeterminateValue::Unknown

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes included from Parts::Resource

#_pool, #child, #keys, #locale, #namespace

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Coordinates

to_deg, to_dms

Methods included from When

Calendar, CalendarEra, CalendarNote, Clock, Duration, M17n, MonthName, Pair, Residue, Resource, TemporalPosition, at, client, config, era, free_conv, m17n, now, server, today, utc, when?

Methods included from Conversion

#julian_date, #tm_position

Methods included from Parts::Resource

_decode, _encode, _extract_prefix, _parse, _path_with_prefix, _replace_tags, #each, #enum_for, #hierarchy, #included?, #iri, #leaf?, #m17n, #map, #parent, #registered?

Methods included from Parts::Resource::Pool

#[]=, #_pool, #_setup_, #pool_keys

Methods included from Parts::Resource::Synchronize

#synchronize

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object (private)

Note:

When::TM::TemporalPosition で定義されていないメソッドは 処理を @frame (type: When::TM::Calendar or When::TM::Clock) に委譲する

その他のメソッド



1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
 
# File 'lib/when_exe/tmposition.rb', line 1018

def method_missing(name, *args, &block)
  
  return _method_missing(name, *args, &block) if When::Parts::MethodCash::Escape.key?(name)
  self.class.module_eval %Q{
    def #{name}(*args, &block)
      @frame.send("#{name}", self, *args, &block)
    end
  } unless When::Parts::MethodCash.escape(name)
  @frame.send(name, self, *args, &block)
end

Class Attribute Details

.format ⇒ Object

strftime で用いる書式のハッシュ



167
168
169
 
# File 'lib/when_exe/inspect.rb', line 167

def format
  @format
end

Instance Attribute Details

#events ⇒ Array<When::Parts::Enumerator>

この時間位置と関連付けられたイベント - additional attribute

Returns:



229
230
231
 
# File 'lib/when_exe/tmposition.rb', line 229

def events
  @events
end

#frame ⇒ When::TM::ReferenceSystem

この時間位置と関連付けられた時間参照系 (relation - Reference)

The time reference system associated with the temporal position being described

Returns:



223
224
225
 
# File 'lib/when_exe/tmposition.rb', line 223

def frame
  @frame
end

#indeterminated_position ⇒ When::TM::IndeterminateValue (readonly) Also known as: indeterminatedPosition

この時間位置の意味づけ

Returns:



214
215
216
 
# File 'lib/when_exe/tmposition.rb', line 214

def indeterminated_position
  @indeterminated_position
end

#location ⇒ When::Coordinates::Spatial

その他の属性 - additional attribute

Returns:



262
263
264
 
# File 'lib/when_exe/tmposition.rb', line 262

def location
  @location
end

#options ⇒ Hash (readonly)

その他の属性 - additional attribute

Returns:

  • (Hash) —

    { String=>Object }



244
245
246
 
# File 'lib/when_exe/tmposition.rb', line 244

def options
  @options
end

#precision ⇒ Numeric

Note:

precision より resolution の方が分解能の意味にふさわしいが ISO19108 で別の意味に用いられているため resolution とした。

この時間位置の分解能 - additional attribute

Returns:



238
239
240
 
# File 'lib/when_exe/tmposition.rb', line 238

def precision
  @precision
end

#query ⇒ Hash

その他の属性 - additional attribute

Returns:

  • (Hash) —

    { String=>When::BasicTypes::M17n }



256
257
258
 
# File 'lib/when_exe/tmposition.rb', line 256

def query
  @query
end

#trans ⇒ Hash

その他の属性 - additional attribute

Returns:

  • (Hash) —

    { String=>Object }



250
251
252
 
# File 'lib/when_exe/tmposition.rb', line 250

def trans
  @trans
end

Class Method Details

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

Note:

options の中身は本メソッドによって更新されることがある。

Note:

:tz は ‘Asia/Tokyo’など時間帯を表す文字列をキーにして、登録済みのWhen::V::Timezone, When::Parts::Timezoneを検索して使用する。 :clock はWhen::TM::Clock, When::V::Timezone, When::Parts::Timezoneオブジェクトをそのまま使用するか ‘+09:00’などの文字列をWhen::TM::Clock化して使用する。 :tz の方が :clock よりも優先される。

Temporal Objetct の生成

Parameters:

  • specification (String) —

    When.exe Standard Representation

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

    下記の通り

Options Hash (options):

  • :frame (When::TM::ReferenceSystem) —

    暦法の指定

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

    時法の指定

  • :tz (String) —

    時法の指定(時間帯を指定する場合 :clock の替わりに用いることができる)

  • :abbr (Array<Numeric>) —

    ISO8601上位省略形式のためのデフォルト日付(省略時 指定なし)

  • :extra_year_digits (Integer) —

    ISO8601拡大表記のための年の構成要素拡大桁数(省略時 1桁)

  • :wkst (String) —

    ISO8601週日形式のための暦週開始曜日(省略時 ‘MO’)

  • :precision (Integer) —

    生成するオブジェクトの分解能

  • :time_standard (When::TimeStandard::TimeStandard) —

    時刻系の指定(省略時 When::TimeStandard::UnversalTime)

  • :location (When::Ephemeris::Spatial) —

    観測地の指定(省略時 指定なし)

  • :era_name (String) —

    暦年代

  • :trans (Hash) —

    暦年代の上下限

    • :count => 条件に合致する暦年代のうち何番目を採用するか

    • :lower => 暦年代適用の下限

      true            - epoch_of_use の始め(省略時)
:reference_date - 参照事象の日付

    • :upper => 暦年代適用の上限

      true            - epoch_of_use の終わり(省略時)
:reference_date - 参照事象の日付
  • :query (Hash) —

    暦年代の絞込み条件

    • :area => area による暦年代絞込み

    • :period => period による暦年代絞込み

    • :name => name による暦年代絞込み(epoch の attribute使用可)

Returns:



306
307
308
309
310
311
312
313
314
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
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
 
# File 'lib/when_exe/tmposition.rb', line 306

def _instance(specification, options={})

  # Suffix - Frame specification
  rfc5545form, frame, *rest = specification.split(/\^{1,2}/)
  return rest.inject(_instance(rfc5545form + '^' + frame, options)) {|p,c| When.Resource(c, '_c:').jul_trans(p)} if rest.size > 0

  options[:frame] = When.Resource(frame, '_c:') if (frame)

  # Prefix - RFC 5545 Options
  if (rfc5545form =~ /^([^:]+[^-:\d]):([^:].+)$/)
    rfc5545option, iso8601form = $~[1..2]
    rfc5545option.split(/;/).each do |eq|
      key, value = eq.split(/=/, 2)
      case key
      when 'VALUE' ; options[:precision] = value
      when 'TZID'  ; options[:clock] = 
        case When::V::Timezone[value]
        when Array ; When::V::Timezone[value][-1]
        when nil   ; When::Parts::Timezone.new(value)
        else       ; When::V::Timezone[value]
        end
      else         ; options[key]    = value
      end
    end
  else
    iso8601form = rfc5545form
  end
  options = options.dup

  # IndeterminateValue
  if (iso8601form.sub!(/\/After$|^Before\/|^Now$|^Unknown$|^[-+]Infinity$/i, ''))
    options[:indeterminated_position] = When::TimeValue::S[$&.sub(/\//,'')]
    case options[:indeterminated_position]
    when When::TimeValue::Now,
         When::TimeValue::Unknown,
         When::TimeValue::Max,
         When::TimeValue::Min
      return self.new(self._options(options))
    end
  end

  # each specification
  splitted = iso8601form.split(/\//)
  if (splitted[0] =~ /^R(\d+)?$/)
    repeat = $1 ? $1.to_i : true
    splitted.shift
  end
  case splitted.length
  when 1
  when 2
    if (splitted[0] !~ /^[-+]?P/ && splitted[1] =~ /^\d/ && splitted[1].length < splitted[0].length)
      splitted[1] = splitted[0][0..(splitted[0].length-splitted[1].length-1)] + splitted[1]
    end
  else
    raise ArgumentError, "Irregal ISO8601 Format: #{iso8601form}"
  end
  options = self._options(options)
  element = splitted.map { |v| _date_time_or_duration(v, options.dup) }

  # total result
  case repeat
  when nil
    case element[1]
    when nil
      return element[0]
    when Duration
      case element[0]
      when Duration ; raise TypeError, "Duplicate Duration: #{element[0]} and #{element[1]}"
      when self     ; return When::Parts::GeometricComplex.new(*element)
      else          ; return When::Parts::GeometricComplex.new(element[0].first, element[1])
      end
    when self
      case element[0]
      when Duration ; return When::Parts::GeometricComplex.new([[element[1]-element[0],false], [element[1],true ]])
      when self     ; return When::Parts::GeometricComplex.new(element[0]..element[1])
      else          ; return When::Parts::GeometricComplex.new(element[0].first..element[1])
      end
    else
      case element[0]
      when Duration ; return When::Parts::GeometricComplex.new([[element[1].first-element[0],false],
                                                                [element[1].last-element[0]-1,true ]])
      when self     ; return When::Parts::GeometricComplex.new(element[0]...element[1].last)
      else          ; return When::Parts::GeometricComplex.new(element[0].first...element[1].last)
      end
    end
  when 0            ; return []
  when Integer      ; return [element[0]] * repeat unless element[1]
  end

  case element[1]
  when Duration
    case element[0]
    when Duration   ; raise TypeError, "Duplicate Duration: #{element[0]} and #{element[1]}"
    else            ; duration = element[1]
    end
  when self
    case element[0]
    when Duration   ; duration = -element[0]
    when self       ; duration =  element[1] - element[0]
    else            ; duration =  element[1] - element[0].first
    end
  else
    case element[0]
    when Duration   ; duration = -element[0]
    when self       ; duration =  element[1].first - element[0]
    else            ; duration =  element[1].first - element[0].first
    end
  end
  base = element[0].kind_of?(Duration) ? element[1] : element[0]

  if repeat.kind_of?(Integer)
    result = case base
             when self  ; (1..repeat-1).inject([base]) {|a,i| a << (a[-1] + duration) }
             else       ; (1..repeat-1).inject([base]) {|a,i| a << When::Parts::GeometricComplex.new(
                                                                    a[-1].first+duration...a[-1].last+duration)}
             end
    result.reverse! if duration.sign < 0
    return result

  else
    duration = -duration if duration.sign < 0
    return case base
           when self    ; When::V::Event.new({'rrule'=>{'FREQ'=>duration}, 'dtstart'=>base})
           else         ; When::V::Event.new({'rrule'=>{'FREQ'=>duration}, 'dtstart'=>base.first,
                                                                           'dtend'  =>base.last})
           end
  end
end

._options(options) ⇒ Object

option の正規化



437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
 
# File 'lib/when_exe/tmposition.rb', line 437

def _options(options)
  query = options.dup
  main  = {}
  clock = Clock.get_clock_option(query)
  main[:clock] = clock if clock
  [:indeterminated_position, :frame, :events, :precision,
   :era_name, :era, :abbr, :extra_year_digits, :wkst, :time_standard, :location].each do |key|
    main[key] = query.delete(key) if (query.key?(key))
  end
  long = query.delete(:long)
  lat  = query.delete(:lat)
  alt  = query.delete(:alt)
  main[:location] ||= "_l:long=#{long||0}&lat=#{lat||0}&alt=#{alt||0}" if long && lat
  trans = query.delete(:trans) || {}
  [:lower, :upper, :count].each do |key|
    trans[key] = query.delete(key) if (query.key?(key))
  end
  query = query.merge(query.delete(:query)) if (query.key?(:query))
  main[:query] = query if (query.size > 0)
  main[:trans] = trans if (trans.size > 0)
  return main
end

._setup_(format = nil) ⇒ void

Note:

format の指定がない場合、format は Format(モジュール定数)と解釈する

This method returns an undefined value.

When::TM::TemporalPosition Class のグローバルな設定を行う

Parameters:

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

    strftime で用いる記号の定義



177
178
179
 
# File 'lib/when_exe/inspect.rb', line 177

def _setup_(format=nil)
  @format = format ? Format.merge(format) : Format
end

._verify(source, target) ⇒ Object

比較



462
463
464
465
 
# File 'lib/when_exe/tmposition.rb', line 462

def _verify(source, target)
  return source.universal_time <=> target.universal_time if source.time_standard.equal?(target.time_standard)
  return source.dynamical_time <=> target.dynamical_time
end

Instance Method Details

#+(other) ⇒ When::TM::TemporalPosition

加算

Parameters:

Returns:



681
682
683
684
685
686
687
688
689
690
691
692
 
# File 'lib/when_exe/tmposition.rb', line 681

def +(other)
  case other
  when Integer        ; self + PeriodDuration.new(other, When::DAY)
  when Numeric        ; self + IntervalLength.new(other, 'day')
  when PeriodDuration ; _plus(other)
  when Duration       ; @frame.kind_of?(Calendar) ? @frame.jul_trans(JulianDate.dynamical_time(dynamical_time + other.duration), self._attr) :
                                                                     JulianDate.dynamical_time(dynamical_time + other.duration,  self._attr)
  else                ; raise TypeError, "The right operand should be Numeric or Duration"
  end
rescue RangeError
  (@frame ^ self) + other
end

#+@ ⇒ Float

ユリウス日時(実数)

Returns:

  • (Float) —

    dynamical time での経過日数を, ユリウス日と1970-01-01T00:00:00TTで時計あわせしたもの



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

def +@
  JulianDate._t_to_d(dynamical_time)
end

#-(other) ⇒ When::TM::TemporalPosition, When::TM::Duration

減算

Parameters:

Returns:



701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
 
# File 'lib/when_exe/tmposition.rb', line 701

def -(other)
  case other
  when TimeValue      ; self.time_standard.rate_of_clock == other.time_standard.rate_of_clock && [@precision, other.precision].min <= When::DAY ?
                          PeriodDuration.new(self.to_i - other.to_i, When::DAY) :
                          IntervalLength.new((self.dynamical_time - other.dynamical_time) / Duration::SECOND, 'second')
  when Integer        ; self - PeriodDuration.new(other, When::DAY)
  when Numeric        ; self - IntervalLength.new(other, 'day')
  when PeriodDuration ; _plus(-other)
  when Duration       ; @frame.kind_of?(Calendar) ? @frame.jul_trans(JulianDate.dynamical_time(dynamical_time - other.duration), self._attr) :
                                                                     JulianDate.dynamical_time(dynamical_time - other.duration,  self._attr)
  else                ; raise TypeError, "The right operand should be Numeric, Duration or TemporalPosition"
  end
rescue RangeError
  (@frame ^ self) - other
end

#<=>(other) ⇒ Integer

大小比較

Parameters:

  • other (When::TM::TemporalPosition) —

    チェックされる日時

  • other (Numeric) —

    チェックされる日時の universal time(self と同じtime_standardとみなす)

Returns:

  • (Integer) —

    (-1, 0, 1)

    分解能の低い方にあわせて比較を行う

    Ex. when?('2011-03') <=> when?('2011-03-10') -> 0



822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
 
# File 'lib/when_exe/tmposition.rb', line 822

def <=>(other)
  other = other.first if other.kind_of?(Range)
  return universal_time <=> other if other.kind_of?(Numeric)

  [self.indeterminated_position, other.indeterminated_position].each do |position|
    prec = SYSTEM if [TimeValue::Min, TimeValue::Max].include?(position)
  end
  prec   = [self.precision, other.precision].min unless prec

  case prec
  when DAY    ; return self.to_i <=> other.to_i
  when SYSTEM ; return TemporalPosition._verify(self, other)
  end

  if prec < DAY && respond_to?(:most_significant_coordinate) &&
             other.respond_to?(:most_significant_coordinate) && @frame.equal?(other.frame)
    result = most_significant_coordinate <=> other.most_significant_coordinate
    return result unless result == 0 && @cal_date.length + prec > 1
    (@cal_date.length + prec - 2).times do |i|
      result = @cal_date[i+1] <=> other.cal_date[i+1]
      return result unless result == 0
    end
    @cal_date[prec - 1] <=> other.cal_date[prec - 1]
  else
    source = (prec >= self.precision ) ? self  : self.floor(prec)
    target = (prec >= other.precision) ? other : other.floor(prec)
    return source.to_i <=> target.to_i if prec <= DAY
    TemporalPosition._verify(source, target)
  end
end

#==(other) ⇒ Boolean

オブジェクトの同値

Parameters:

  • other (比較先)

Returns:

  • (Boolean) —
    true - 同値
    false - 非同値 


805
806
807
808
809
 
# File 'lib/when_exe/tmposition.rb', line 805

def ==(other)
  (self <=> other) == 0
rescue
  false
end

#[](index) ⇒ Numeric

要素の参照

Parameters:

  • index (Integer, String) —

    参照する要素の指定

Returns:



670
671
672
673
 
# File 'lib/when_exe/tmposition.rb', line 670

def [](index)
  return value(index) if index.kind_of?(String) || !index.respond_to?(:inject)
  index.inject([]) {|list, i| list << value(i) }
end

#^(other, leaf = true, &block) ⇒ Array of (element^self) for all When::Parts::Resource registered elements, ...

条件を満たすオブジェクトの抽出

Parameters:

Returns:

  • (Array of (element^self) for all When::Parts::Resource registered elements) —

    (If other is Module)

  • (Array of (self^element) for elemnt of other which belong to the specified module or class) —

    (If other is [Array])

  • (Enumerator which generates temporal position sequence begins from self with the specified duration) —

    (If other is [When::TM::Duration])

  • (Array of temporal position using the specified calendar as a frame) —

    (If other is [When::TM::Calendar])

  • (Array of temporal position using the specified calendar era as a calendarEraName) —

    (If other is [When::TM::CalendarEra])



914
915
916
 
# File 'lib/when_exe/tmposition.rb', line 914

def ^(other, leaf=true, &block)
  scan(other, leaf, &block)
end

#_attr ⇒ Object

属性の Hash



932
933
934
935
936
937
938
939
940
 
# File 'lib/when_exe/tmposition.rb', line 932

def _attr
  attributes = {}
  [:frame, :events, :precision, :options, :trans, :query].each do |key|
    attributes[key] = instance_variable_get("@#{key}")
  end
  attributes[:location]      = location
  attributes[:time_standard] = time_standard
  return attributes.delete_if {|k,v| !v}
end

#_notes(options = {}) ⇒ Array<Array<Hash{:note=>note, :value=>value}>>

Note:

When::TM::TemporalPosition の場合、events に暦注名の入ったその暦注に該当する日付である。 (例) Christian クラス で easter を計算した場合、当該年の復活祭の日付オブジェクトが返る。 暦注サブクラスの場合、要素が増えたり、:note の暦注要素の型が変わったりすることがある。

時間位置オブジェクトの暦注を取得

Parameters:

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

    { :notes => String } という Hash の指定と等価

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

    { :indices => Integer } という Hash の指定と等価

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

    下記のとおり

Options Hash (options):

Returns:

  • (Array<Array<Hash{:note=>note, :value=>value}>>) —
    note [String, When::BasicTypes::M17n, When::Coordinates::Residue

    暦注名 ]

    value [String, When::BasicTypes::M17n, When::Coordinates::Residue, When::TM::TemporalPosition

    暦注の値 ]



478
479
480
 
# File 'lib/when_exe/inspect.rb', line 478

def _notes(options={})
  _calendar_note(options).notes(self, options)
end

#_to_h(options = {}) ⇒ Hash

時間位置オブジェクトの内容を Hash 化

Parameters:

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

    { :notes => String } という Hash の指定と等価

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

    { :indices => Integer } という Hash の指定と等価

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

    下記のとおり

Options Hash (options):

Returns:

  • (Hash) —

    • :sdn 日の通し番号 - ユリウス通日(Integer)

    • :calendar calendar_name の結果 - Array<暦法または暦年代(, 付属情報..)>

    • :notes Hash (の Array (の Array)) - _notes(options)

    clock が定義されている場合、さらに下記も出力する

    • :clock 時計(When::TM::Clock, When::V::Timezone, When::Parts::Timezone)

    • :clk_time to_clock_time の結果 - ( 日, 時, 分, 秒 )

    • :dynamical dynamical_time / 秒

    • :universal universal_time / 秒



546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/when_exe/inspect.rb', line 546

def _to_h(options={})
  hash = super.update({
    :sdn      => to_i,
    :calendar => calendar_name,
    :notes    => _notes(options)
  })

  hash.update({
    :clock     => clock,
    :clk_time  => to_clock_time,
    :dynamical => dynamical_time * clock.second,
    :universal => universal_time * clock.second
  }) if clock
  hash
end

#_to_s ⇒ Object 



573
 
# File 'lib/when_exe/inspect.rb', line 573

alias :_to_s :to_s

#calendar_name ⇒ Array<Class>

暦法名

Returns:

  • (Array<Class>) —

    Class 暦法のクラスオブジェクト



187
188
189
 
# File 'lib/when_exe/inspect.rb', line 187

def calendar_name
  [self.class]
end

#clock_name ⇒ Array<String>

時法名

Returns:



196
197
198
 
# File 'lib/when_exe/inspect.rb', line 196

def clock_name
  [When::Parts::Resource._path_with_prefix(clock)]
end

#copy(options = {}) ⇒ When::TM::TemporalPosition

属性を変更したコピーを作る

Parameters:

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

    { 属性=>属性値 }

Returns:



924
925
926
927
928
 
# File 'lib/when_exe/tmposition.rb', line 924

def copy(options={})
  position = self.dup
  position._copy(options)
  position
end

#dynamical_time ⇒ Numeric

外部時間

Returns:

  • (Numeric) —

    1970-01-01T00:00:00TT からの terrestrial time の経過時間 / 128秒



561
562
563
564
565
566
567
568
569
 
# File 'lib/when_exe/tmposition.rb', line 561

def dynamical_time
  return @dynamical_time if @dynamical_time && @indeterminated_position != Now
  @dynamical_time = 
    case @indeterminated_position
    when Max ; +Float::MAX/4
    when Min ; -Float::MAX/4
    else     ; time_standard.to_dynamical_time(universal_time)
    end
end

#floor(digit = DAY, precision = digit) ⇒ When::TM::TemporalPosition

下位桁の切り捨て

Parameters:

  • digit (Integer) (defaults to: DAY) —

    これより下の桁を切り捨てる(省略すると When::DAY)

  • precision (Integer) (defaults to: digit) —

    切り捨て結果の分解能

Returns:



772
773
774
 
# File 'lib/when_exe/tmposition.rb', line 772

def floor(digit=DAY, precision=digit)
  self
end

#has_next? ⇒ Boolean

前後の日時を取得可能か?

Returns:

  • (Boolean) —
    true - 可能
    false - 不可 


760
761
762
 
# File 'lib/when_exe/tmposition.rb', line 760

def has_next?
  When::Coordinates::PERIOD_NAME[@precision] != nil
end

#has_time? ⇒ Boolean

分解能が時刻を持つか

Returns:

  • (Boolean) 


780
781
782
 
# File 'lib/when_exe/tmposition.rb', line 780

def has_time?
  (@precision > 0)
end

#include?(date) ⇒ Boolean

指定の日時を含むか?

Parameters:

Returns:

  • (Boolean) —
    true - 含む
    false - 含まない 


792
793
794
795
 
# File 'lib/when_exe/tmposition.rb', line 792

def include?(date)
  return false if self.precision > date.precision
  return self == date
end

#is?(options = nil) ⇒ Boolean

指定の日時が指定イベントに該当するか?

Parameters:

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

    { :notes => String } または { :notes => String } または { :value => String } という Hash の指定と等価 (指定の event が存在する場合は前者、指定の notes が存在する場合は中央、しない場合は後者)

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

    { :indices => Integer } という Hash の指定と等価

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

    下記のとおり

Options Hash (options):

Returns:

  • (Boolean) —
    true - 該当する
    false - 該当しない 


514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'lib/when_exe/inspect.rb', line 514

def is?(options=nil)
  calendar_note = _calendar_note(options)
  event = 
    case options
    when String ; options
    when Hash   ; options.delete(:event)
    else        ; calendar_note.event
    end
  event.to_s =~ /^([^\d]+)/ && calendar_note.respond_to?($1.downcase) ?
    calendar_note.include?(self, event) :
    calendar_note.note?(self,  options)
end

#month_included(ord, wkst, opt, block) ⇒ Range, ...

Note:

引数 ord, wkst, opt はそのクラスで位置づけを判断するため、引数の順序は任意(省略も可)

含まれる月

Parameters:

  • ord (Numeric, Range) —

    月の番号(default: 今月) 今月を 0 とする月番号(Integer) または月番号の範囲(Range)

    -1 - 先月
 0 - 今月
+1 - 来月
  • wkst (String) —

    週の開始曜日(defaultはなし)

  • wkst (When::CalendarTypes::CalendarNote) —

    暦注オブジェクト

  • wkst (Array<When::CalendarTypes::CalendarNote, String>) —

    暦注オブジェクトとそのイベントメソッド名 (暦注オブジェクトは、そのIRI文字列を指定しても良い)

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

    上位繰り返し範囲(ユリウス通日…ユリウス通日)

Returns:

  • (Range) —

    含まれる月を範囲として表現する Range (block 指定なし)

  • (Array) —

    含まれる月の各日をブロックに渡した結果の Array (block 指定あり, wkst なし)

  • (Array<Array>) —

    含まれる月の各日をブロックに渡した結果の 七曜表(block 指定あり, wkst あり)



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
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
 
# File 'lib/when_exe/inspect.rb', line 295

def month_included(*args, &block)
  first, length, wkst, opt = _range(args)
  if wkst
    (first...(first+length)).map {|i|
      begun = self.floor(MONTH,DAY) + When::TM::PeriodDuration.new([0,i,0])
      ended = begun                 + DurationP1M
      ended = ended.prev until begun.cal_date[MONTH-1] == ended.cal_date[MONTH-1]
      if ended.to_i <= begun.to_i
        ended = begun
        loop do
          succ  = ended.succ
          break unless succ.frame.equal?(begun.frame)
          ended = succ
        end
      end
      dates = [begun]
      loop do
        current = dates[-1].week_included(wkst)
        if current.last.to_i > ended.to_i
          dates[-1] = ended
          break (dates.map {|date| date.week_included(wkst, {:Range=>begun.to_i..ended.to_i}, &block)}).
                unshift(yield(begun, MONTH)).compact
        elsif wkst.kind_of?(When::Coordinates::Residue)
          dates << dates[-1] + wkst.duration
        else
          it = wkst.enum_for(dates[-1], :forward)
          begin
            date = it.next
          end while date.to_i == dates[-1].to_i
          date = date.to_cal_date unless date.instance_of?(TM::CalDate)
          dates << date
        end
      end
    }
  else
    begun = self.floor(MONTH,DAY) + When::TM::PeriodDuration.new([0, first,  0])
    ended = begun                 + When::TM::PeriodDuration.new([0, length, 0])
    loop do
      last = ended.prev
      break unless last.cal_date[MONTH-1] == ended.cal_date[MONTH-1]
      ended = last
    end
    if block_given?
      (begun...ended).map do |date|
        yield(date)
      end
    else
      begun...ended
    end
  end
end

#note?(options = {}) ⇒ Boolean

暦注の一致 or 不一致

Parameters:

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

    { :notes => String } または { :value => String } という Hash の指定と等価 (指定の notes が存在する場合は前者、しない場合は後者)

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

    { :indices => Integer } という Hash の指定と等価

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

    下記のとおり

Options Hash (options):

Returns:

  • (Boolean) —
    true - 暦注が一致
    false - 暦注が不一致 


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

def note?(options={})
  _calendar_note(options).note?(self, options)
end

#notes(options = {}) ⇒ Array<Array<Hash{:note=>note, :value=>value}>>

時間位置オブジェクトの暦注を取得し value を暦注の値 (String, When::BasicTypes::M17n or When::Coordinates::Residue)とする Hash で表現

Parameters:

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

    { :notes => String } という Hash の指定と等価

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

    { :indices => Integer } という Hash の指定と等価

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

    下記のとおり

Options Hash (options):

Returns:

  • (Array<Array<Hash{:note=>note, :value=>value}>>) —
    note [String, When::BasicTypes::M17n

    暦注名 ]

    value [String, When::BasicTypes::M17n, When::Coordinates::Residue

    暦注の値 ]



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

def notes(options={})
  _m17n_form(_notes(options), options.kind_of?(Hash) ? options : {})
end

#period ⇒ When::TM::PeriodDuration

分解能に対応する Duration

Returns:

Raises:

  • (ArgumentError) 


721
722
723
724
725
726
 
# File 'lib/when_exe/tmposition.rb', line 721

def period
  return @period if @period
  period_name = When::Coordinates::PERIOD_NAME[@precision]
  raise ArgumentError, "Presicion not defined" unless period_name
  @period = When.Duration(period_name)
end

#prev ⇒ When::TM::TemporalPosition

前の日時

Returns:



734
735
736
737
738
 
# File 'lib/when_exe/tmposition.rb', line 734

def prev
  @precision==When::DAY ? _force_euqal_day(-1) : self-period
rescue RangeError
  (When.Calendar('Gregorian') ^ self) - period
end

#rate_of_clock ⇒ Numeric

時間の歩度

Returns:



534
535
536
 
# File 'lib/when_exe/tmposition.rb', line 534

def rate_of_clock
  time_standard.rate_of_clock
end

#reference_label ⇒ When::BasicTypes::M17n

参照ラベル

Returns:



205
206
207
 
# File 'lib/when_exe/inspect.rb', line 205

def reference_label
  [When::BasicTypes::M17n.new(self.class.to_s.split(/::/)[-1])]
end

#scan(other, leaf = false, &block) ⇒ Array of (element^self) for all When::Parts::Resource registered elements, ...

条件を満たすオブジェクトの抽出

Parameters:

Returns:

  • (Array of (element^self) for all When::Parts::Resource registered elements) —

    (If other is Module)

  • (Array of (self^element) for elemnt of other which belong to the specified module or class) —

    (If other is [Array])

  • (Enumerator which generates temporal position sequence begins from self with the specified duration) —

    (If other is [When::TM::Duration])

  • (Array of temporal position using the specified calendar as a frame) —

    (If other is [When::TM::Calendar])

  • (Array of temporal position using the specified calendar era as a calendarEraName) —

    (If other is [When::TM::CalendarEra])



865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
 
# File 'lib/when_exe/tmposition.rb', line 865

def scan(other, leaf=false, &block)
  list = []
  case other
  when Numeric, TemporalPosition, Position
    raise TypeError, "Operand should not be Numeric or (Temporal)Position"

  when Module
    objects = []
    ObjectSpace.each_object(other) do |object|
      objects << object if object.registered?
    end
    objects.each do |object|
      element = (object ^ self)
      if element && !(leaf && element.respond_to?(:leaf?) && !element.leaf?)
        list << element
        yield(element) if block_given?
      end
    end
    return list

  when Array
    return other.map {|v| scan(v, leaf, &block)}

  else
    if other.respond_to?(:_enumerator)
      enumerator = other._enumerator(self)
      return enumerator unless block_given?
      return enumerator.each(&block)
    end

    element = (other ^ self)
    if element && !(leaf && element.respond_to?(:leaf?) && !element.leaf?)
      list << element
      yield(element) if block_given?
    end
    if (other.respond_to?(:child) && other.child)
      other.child.each do |object|
        list += scan(object, leaf, &block)
      end
    end
    return list
  end
end

#strftime(pattern, locale = nil) ⇒ When::BasicTypes::M17n

指定の書式による多言語対応文字列化 - pattern で指定した書式で多言語対応文字列化する

Parameters:

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

    書式

  • locale (String, Array<String>) (defaults to: nil) —

    文字列化を行う locale の指定(デフォルト : オブジェクト生成時に保持している locale すべて)

Returns:



619
620
621
622
623
624
 
# File 'lib/when_exe/inspect.rb', line 619

def strftime(pattern, locale=nil)
  pattern = m17n([pattern]*self.keys.length, nil, nil, {:locale=>self.keys}) if pattern.instance_of?(String)
  pattern._printf([], locale) do |k, *t|
    _strftime(k, pattern, [''])
  end
end

#succ ⇒ When::TM::TemporalPosition Also known as: next

次の日時

Returns:



746
747
748
749
750
 
# File 'lib/when_exe/tmposition.rb', line 746

def succ
  @precision==When::DAY ? _force_euqal_day(+1) : self+period
rescue RangeError
  (When.Calendar('Gregorian') ^ self) + period
end

#term(designator, locale = nil, d = 0, e = 3) ⇒ designator に依存

strftime で扱う項の値を取得する

Parameters:

  • designator (String) —

    項目名

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

    文字列化を行う場合の locale の指定(デフォルト to_s(代表値))

  • d (Integer) (defaults to: 0) —

    日付が‘年月日’、時刻が‘時分秒’でない表現のための桁位置変更指示

    年月に付く場合 - 大きいほうに位置をずらす
    分秒に付く場合 - 小さいほうに位置をずらす
  • e (Integer) (defaults to: 3) —

    月の省略名の文字数

Returns:

  • (designator に依存) 


637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
 
# File 'lib/when_exe/inspect.rb', line 637

def term(designator, locale=nil, d=0, e=3)
  designator = When::Parts::Locale.translate(designator,locale)
  case designator
                                                          # 現在のロケールにおける曜日の省略名
  when 'a' ; When.Resource('_co:CommonResidue::Abbr_Day')[to_i % 7].translate(locale)
                                                          # 現在のロケールにおける曜日の完全な名前
  when 'A' ; When.Resource('_co:CommonResidue::Week')[to_i % 7].label.translate(locale)
  when 'b' ; (name(MONTH-d).translate(locale))[/^.{1,#{e}}/] # 現在のロケールにおける月の省略名
  when 'B' ; (name(MONTH-d).translate(locale))            # 現在のロケールにおける月の完全な名前
  when 'C' ; year(d).div(100)                             # 世紀 (西暦年の上 2 桁)
  when 'd' ; day(d)                                       # 月内通算日
  when 'E' ; Array(calendar_era_name)[0].translate(locale)# 年号
  when 'F' ; floor(DAY).to_m17n.translate(locale)         # ISO 8601 形式の日付フォーマット
  when 'G' ; cwyear(d)                                    # ISO 8601 週単位表記の年
  when 'g' ; cwyear(d) % 100                              # ISO 8601 週単位表記の年の下2桁
  when 'H' ; hour(d)                                      # 24 時間表記での時
  when 'I' ; (hour(d)-1) % 12 + 1                         # 12 時間表記での時
  when 'j' ; yday(d)                                      # 年の初めから通算の日数
  when 'm' ; month(d)                                     # 月
  when 'M' ; minute(d)                                    # 分
  when 'p' ; (AMPM[hour(d).to_i.div(12)].translate(locale)).upcase   # 現在のロケールにおける「午前」「午後」に相当する文字列
  when 'P' ; (AMPM[hour(d).to_i.div(12)].translate(locale)).downcase # 前項を小文字で表記
  when 's' ; universal_time / Duration::SECOND      # 紀元 (1970-01-01T00:00:00Z) からの秒数
  when 'S' ; second(d)                                    # 秒 (10 進数表記)
  when 'u' ; cwday                                        # 週の何番目の日か(月曜日を 1 とする)
  when 'U' ; yweek(6, 7, d)                               # 年の初めからの通算の週番号(日曜日始まり)
  when 'V' ; cweek(d)                                     # ISO 8601 形式での年の始めからの週番号
  when 'w' ; wday                                         # 週の何番目の日 か(日曜日を 0 とする)
  when 'W' ; yweek(0, 7, d)                               # 年の初めからの通算の週番号(月曜日始まり)
  when 'y' ; year(d) % 100                                # 西暦の下2桁 (世紀部分を含まない年)
  when 'Y' ; year(d)                                      # 世紀部分を含めた ( 4 桁の) 西暦年
  when 'z' ; clock.to_basic                               # +hhmm や -hhmm の形式のタイムゾーン
  when 'Z' ; When::Parts::Locale.translate(clock.tzname[0],locale) # タイムゾーンまたはゾーン名または省略名
  else     ; designator
  end
end

#time_standard ⇒ When::TimeStandard

時刻系

Returns:



522
523
524
525
526
527
528
 
# File 'lib/when_exe/tmposition.rb', line 522

def time_standard
  return @time_standard if @time_standard.kind_of?(When::TimeStandard)
  @time_standard ||= clock.time_standard if respond_to?(:clock) && clock
  @time_standard ||= frame.time_standard if frame
  @time_standard ||= 'UniversalTime'
  @time_standard   = When.Resource(@time_standard, '_t:')
end

#to_clock_time ⇒ When::TM::ClokTime

When::TM::ClockTime オブジェクトへの変換

Returns:

  • (When::TM::ClokTime)

Raises:

  • (TypeError) 


621
622
623
624
625
626
 
# File 'lib/when_exe/tmposition.rb', line 621

def to_clock_time
  raise TypeError, "Clock not assigned" unless clock
  clk_time = clock.to_clk_time(universal_time - (to_i - JulianDate::JD19700101)*Duration::DAY)
  clk_time.clk_time[0] += to_i
  return clk_time
end

#to_date(option = {}) ⇒ ::Date

標準ライブラリの Date オブジェクトへの変換

Parameters:

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

    時間の歩度が1.0でない場合のための option see _instance

Returns:



651
652
653
654
 
# File 'lib/when_exe/tmposition.rb', line 651

def to_date(option={})
  return JulianDate.dynamical_time(dynamical_time, option).to_date unless time_standard.rate_of_clock == 1.0
  ::Date.jd(to_i, ::Date::GREGORIAN)
end

#to_date_time(option = {:frame=>When.utc}) ⇒ ::DateTime

標準ライブラリの DateTime オブジェクトへの変換

Parameters:

  • option (Hash) (defaults to: {:frame=>When.utc}) —

    時間の歩度が1.0でない場合のための option see _instance

Returns:

  • (::DateTime)

Raises:

  • (TypeError) 


635
636
637
638
639
640
641
642
 
# File 'lib/when_exe/tmposition.rb', line 635

def to_date_time(option={:frame=>When.utc})
  return JulianDate.dynamical_time(dynamical_time, option).to_date_time unless time_standard.rate_of_clock == 1.0
  raise TypeError, "Clock not assigned" unless clock
  Rational
  offset   = Rational(-(clock.universal_time/Duration::SECOND).to_i, (Duration::DAY/Duration::SECOND).to_i)
  clk_time = clock.to_clk_time(universal_time - (to_i - JulianDate::JD19700101)*Duration::DAY).clk_time
  ::DateTime.jd(to_i, clk_time[1], clk_time[2], clk_time[3].to_i, offset, ::Date::GREGORIAN)
end

#to_date_uri ⇒ String

URI要素化(日付のみ) - 日付の部分をURI表現の要素として用いる形式に変換

Returns:



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

def to_date_uri(*args)
  _to_uri(to_s(*args).sub(/T([-+][\d:]+|Z|MTC)$/,''))
end

#to_f ⇒ Float

ユリウス日時(実数)

Returns:

  • (Float) —

    universal time での経過日数を, ユリウス日と1970-01-01T00:00:00Zで時計あわせしたもの



577
578
579
 
# File 'lib/when_exe/tmposition.rb', line 577

def to_f
  JulianDate._t_to_d(universal_time)
end

#to_i ⇒ Integer

ユリウス日(整数)

Returns:

  • (Integer) —

    -4712-01-01T12:00:00Z からの経過日数に対応する通番(当該時間帯での午前0時に1進める)



587
588
589
590
591
592
 
# File 'lib/when_exe/tmposition.rb', line 587

def to_i
  sd  = universal_time
  sd -= @frame.universal_time if @frame.kind_of?(Clock)
  div, mod = sd.divmod(Duration::DAY)
  div + JulianDate::JD19700101
end

#to_m17n ⇒ When::BasicTypes::M17n

多言語対応文字列化 - When.exe Standard Representation により多言語対応文字列化する

Returns:



568
569
570
571
 
# File 'lib/when_exe/inspect.rb', line 568

def to_m17n(*args)
  return m17n(I[@indeterminated_position]) if [Unknown, Max, Min].include?(@indeterminated_position)
  return m17n(_to_s)
end

#to_residue(remainder, divisor) ⇒ When::Coordinates::Residue

剰余類化

Parameters:

  • remainder (Numeric) —

    剰余

  • divisor (Integer) —

    法(>0)

Returns:



603
604
605
 
# File 'lib/when_exe/tmposition.rb', line 603

def to_residue(remainder, divisor)
  When::Coordinates::Residue.new(remainder, divisor, {'day'=>to_i})
end

#to_s ⇒ String

文字列化 - When.exe Standard Representation により文字列化する

Returns:



581
582
583
 
# File 'lib/when_exe/inspect.rb', line 581

def to_s(*args)
  to_m17n(*args).to_s
end

#to_time ⇒ ::Time

組み込みライブラリの Time オブジェクトへの変換

Returns:



660
661
662
 
# File 'lib/when_exe/tmposition.rb', line 660

def to_time
  time_standard.to_time_object(universal_time)
end

#to_uri ⇒ String

URI要素化 - URI表現の要素として用いる形式に変換

Returns:



591
592
593
 
# File 'lib/when_exe/inspect.rb', line 591

def to_uri(*args)
  _to_uri(to_s(*args))
end

#universal_time ⇒ Numeric

内部時間

Returns:

  • (Numeric) —

    1970-01-01T00:00:00Z からの Universal Time, Coordinated の経過時間 / 128秒

    暦法によっては、異なる意味を持つことがある



546
547
548
549
550
551
552
553
 
# File 'lib/when_exe/tmposition.rb', line 546

def universal_time
  case @indeterminated_position
  when Now ; time_standard.from_time_object(Time.now)
  when Max ; +Float::MAX/4
  when Min ; -Float::MAX/4
  else     ; raise NameError, "Temporal Reference System is not defined"
  end
end

#week_included(ord, wkst, opt, block) ⇒ Range, Array

Note:

引数 ord, wkst, opt はそのクラスで位置づけを判断するため、引数の順序は任意(省略も可)

含まれる週

Parameters:

  • ord (Numeric, Range) —

    週の番号(default: 今週) 今週を 0 とする週番号(Integer) または週番号の範囲(Range)

    -1 - 先週
 0 - 今週
+1 - 来週
  • wkst (String) —

    週の開始曜日(defaultは 月曜)

  • wkst (When::CalendarTypes::CalendarNote) —

    暦注オブジェクト

  • wkst (Array<When::CalendarTypes::CalendarNote, String>) —

    暦注オブジェクトとそのイベントメソッド名 (暦注オブジェクトは、そのIRI文字列を指定しても良い)

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

    上位繰り返し範囲(ユリウス通日…ユリウス通日)

Returns:

  • (Range) —

    含まれる週を範囲として表現する Range (block 指定なし)

  • (Array) —

    含まれる週の各日をブロックに渡した結果の Array (block 指定あり)



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/when_exe/inspect.rb', line 230

def week_included(*args)
  begin
    first, length, wkst, opt = _range(args, 'MO')
    case wkst
    when When::Coordinates::Residue
      today = self.floor
      begun = today.succ & wkst >> first-1
      unless @frame.equal?(begun.frame)
        begun  = (@frame ^ today).succ & wkst >> first-1
        middle = today
      end
      ended  = begun.succ & wkst >> length-1
    else
      begun = ended = nil
      if first <= 0
        it = wkst.enum_for(self.floor, :reverse)
        (1-first).times do
          begun = it.next
        end
      else
        it = wkst.enum_for(self.floor, :forward)
        first.times do
          begun = it.next
        end
      end
      it = wkst.enum_for(begun, :forward)
      (length+1).times do
        ended = it.next
      end
    end
    range = middle && block_given? ? [begun...middle, middle...ended] : [begun...ended]

  rescue RangeError
    range = [(@frame ^ self).week_included(*args)]
  end

  return range[0] unless block_given?

  (range.inject([]) {|s,r| s + r.map { |date|
    yield(date, !opt.key?(:Range) || opt[:Range].include?(date.to_i) ? DAY : nil)
  }}).unshift(yield(range[0].first, WEEK)).compact
end

#month_included(ord, wkst, opt, block) ⇒ Range, ...

Note:

引数 ord, wkst, opt はそのクラスで位置づけを判断するため、引数の順序は任意(省略も可)

含まれる年

Parameters:

  • ord (Numeric, Range) —

    年の番号(default: 今年) 今年を 0 とする年番号(Integer) または年番号の範囲(Range)

    -1 - 先年
 0 - 今年
+1 - 来年
  • wkst (String) —

    週の開始曜日(defaultはなし)

  • wkst (When::CalendarTypes::CalendarNote) —

    暦注オブジェクト

  • wkst (Array<When::CalendarTypes::CalendarNote, String>) —

    暦注オブジェクトとそのイベントメソッド名 (暦注オブジェクトは、そのIRI文字列を指定しても良い)

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

    上位繰り返し範囲(ユリウス通日…ユリウス通日)

Returns:

  • (Range) —

    含まれる年を範囲として表現する Range (block 指定なし)

  • (Array) —

    含まれる年の各日をブロックに渡した結果の Array (block 指定あり, wkst なし)

  • (Array<Array>) —

    含まれる年の各日をブロックに渡した結果の 七曜表(block 指定あり, wkst あり)



369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
 
# File 'lib/when_exe/inspect.rb', line 369

def year_included(*args, &block)
  first, length, wkst, opt = _range(args)
  if wkst
    (first...(first+length)).map {|i|
      begun   = _force_euqal_year(i)
      ended   = _force_euqal_year(i+1)
      current = begun
      result  = [yield(begun, YEAR)]
      while current < ended do
        result << current.month_included(wkst, &block)
        current += DurationP1M
      end
      result.compact
    }
  else
    begun = _force_euqal_year(first)
    ended = _force_euqal_year(first+length)
    if block_given?
      (begun...ended).map do |date|
        yield(date)
      end
    else
      begun...ended
    end
  end
end