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, RootDir, 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

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_deg_225, to_dms

Methods included from When

Calendar, CalendarEra, CalendarNote, Clock, Duration, Location, M17n, MonthName, Pair, Residue, Resource, TemporalPosition, Wikipedia, 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, _instantiate, _parse, _path_with_prefix, _replace_tags, _simplify_path, base_uri, #each, #enum_for, #hierarchy, #included?, #iri, #leaf?, #m17n, #map, #parent, #registered?, root_dir

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) に委譲する

その他のメソッド



1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
 
# File 'lib/when_exe/tmposition.rb', line 1028

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

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::Parts::Timezone::Baseオブジェクトをそのまま使用するか ‘+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::Parts::Timezone::Base, 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 で用いる記号の定義



185
186
187
 
# File 'lib/when_exe/inspect.rb', line 185

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

._setup_info ⇒ Hash

設定情報を取得する

Returns:

  • (Hash) —

    設定情報



193
194
195
 
# File 'lib/when_exe/inspect.rb', line 193

def _setup_info
  {: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

.format ⇒ Object

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



198
199
200
 
# File 'lib/when_exe/inspect.rb', line 198

def format
  @format ||= Format
end

Instance Method Details

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

加算

Parameters:

Returns:



685
686
687
688
689
690
691
692
693
694
695
696
 
# File 'lib/when_exe/tmposition.rb', line 685

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:



705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
 
# File 'lib/when_exe/tmposition.rb', line 705

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



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
852
853
854
855
 
# File 'lib/when_exe/tmposition.rb', line 826

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 - 非同値 


809
810
811
812
813
 
# File 'lib/when_exe/tmposition.rb', line 809

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

#[](index) ⇒ Numeric

要素の参照

Parameters:

  • index (Integer, String) —

    参照する要素の指定

Returns:



674
675
676
677
 
# File 'lib/when_exe/tmposition.rb', line 674

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])



918
919
920
 
# File 'lib/when_exe/tmposition.rb', line 918

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

#_attr ⇒ Object

属性の Hash



936
937
938
939
940
941
942
943
944
 
# File 'lib/when_exe/tmposition.rb', line 936

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

    暦注の値 ]



505
506
507
 
# File 'lib/when_exe/inspect.rb', line 505

def _notes(options={})
  _calendar_note(options).notes(self, options)
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 に依存) 


651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
 
# File 'lib/when_exe/inspect.rb', line 651

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

#_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::Parts::Timezone::Base)

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

    • :dynamical dynamical_time / 秒

    • :universal universal_time / 秒



573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'lib/when_exe/inspect.rb', line 573

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 



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

alias :_to_s :to_s

#calendar_name ⇒ Array<Class>

暦法名

Returns:

  • (Array<Class>) —

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



208
209
210
 
# File 'lib/when_exe/inspect.rb', line 208

def calendar_name
  [self.class]
end

#caret_frame ⇒ String

Note:

暦年代付きかまたは frame がグレゴリオ暦の場合は空文字列を返す

caret 付きの frame 名

Returns:



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

def caret_frame
  prefix = When::Parts::Resource.base_uri + 'CalendarTypes/'
  path   = frame.iri
  return '' if @calendar_era_name || path == prefix + 'Gregorian'
  path   = path[prefix.length..-1] if path.index(prefix) == 0
  '^^' + path
end

#clock_name(prefix = true) ⇒ Array<String>

時法名

Parameters:

  • prefix (Boolean) (defaults to: true) —

    true ならIRI の先頭部分を簡約表現にする

Returns:



218
219
220
 
# File 'lib/when_exe/inspect.rb', line 218

def clock_name(prefix=true)
  [clock.iri(prefix)]
end

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

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

Parameters:

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

    { 属性=>属性値 }

Returns:



928
929
930
931
932
 
# File 'lib/when_exe/tmposition.rb', line 928

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:



776
777
778
 
# File 'lib/when_exe/tmposition.rb', line 776

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

#has_next? ⇒ Boolean

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

Returns:

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


764
765
766
 
# File 'lib/when_exe/tmposition.rb', line 764

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

#has_time? ⇒ Boolean

分解能が時刻を持つか

Returns:

  • (Boolean) 


784
785
786
 
# File 'lib/when_exe/tmposition.rb', line 784

def has_time?
  (@precision > 0)
end

#include?(date) ⇒ Boolean

指定の日時を含むか?

Parameters:

Returns:

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


796
797
798
799
 
# File 'lib/when_exe/tmposition.rb', line 796

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 - 該当しない 


541
542
543
544
545
546
547
548
549
550
551
552
 
# File 'lib/when_exe/inspect.rb', line 541

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::CalendarNote) —

    暦注オブジェクト

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

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

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

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

Returns:

  • (Range) —

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

  • (Array) —

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

  • (Array<Array>) —

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



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
 
# File 'lib/when_exe/inspect.rb', line 317

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 - 暦注が不一致 


523
524
525
 
# File 'lib/when_exe/inspect.rb', line 523

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

    暦注の値 ]



478
479
480
481
482
483
484
485
 
# File 'lib/when_exe/inspect.rb', line 478

def notes(options={})
  form_options = options.kind_of?(Hash) ? options : {}
  form_options[:method] = :to_m17n unless form_options.key?(:method)
  persistence = options.delete(:persistence) if options.kind_of?(Hash)
  retrieved   = When::CalendarNote::Notes.retrieve(persistence, self.to_i)
  return retrieved unless retrieved == false
  When::CalendarNote::Notes.register(_m17n_form(_notes(options), form_options), persistence, self.to_i)
end

#period ⇒ When::TM::PeriodDuration

分解能に対応する Duration

Returns:

Raises:

  • (ArgumentError) 


725
726
727
728
729
730
 
# File 'lib/when_exe/tmposition.rb', line 725

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:



738
739
740
741
742
 
# File 'lib/when_exe/tmposition.rb', line 738

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:



227
228
229
 
# File 'lib/when_exe/inspect.rb', line 227

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])



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
908
909
910
911
 
# File 'lib/when_exe/tmposition.rb', line 869

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:



633
634
635
636
637
638
 
# File 'lib/when_exe/inspect.rb', line 633

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:



750
751
752
753
754
 
# File 'lib/when_exe/tmposition.rb', line 750

def succ
  @precision==When::DAY ? _force_euqal_day(+1) : self+period
rescue RangeError
  (When.Calendar('Gregorian') ^ self) + period
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 = {}, start = _default_start) ⇒ ::Date

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

Parameters:

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

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

  • start (Integer) (defaults to: _default_start) —

    ::DateTime オブジェクトのグレゴリオ改暦日(ユリウス通日)

Returns:



655
656
657
658
 
# File 'lib/when_exe/tmposition.rb', line 655

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

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

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

Parameters:

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

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

  • start (Integer) (defaults to: _default_start) —

    ::DateTime オブジェクトのグレゴリオ改暦日(ユリウス通日)

Returns:

  • (::DateTime)

Raises:

  • (TypeError) 


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

def to_date_time(option={:frame=>When.utc}, start=_default_start)
  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, start)
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:



595
596
597
598
 
# File 'lib/when_exe/inspect.rb', line 595

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:



608
609
610
 
# File 'lib/when_exe/inspect.rb', line 608

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

#to_time ⇒ ::Time

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

Returns:



664
665
666
 
# File 'lib/when_exe/tmposition.rb', line 664

def to_time
  time_standard.to_time_object(universal_time)
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::CalendarNote) —

    暦注オブジェクト

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

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

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

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

Returns:

  • (Range) —

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

  • (Array) —

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



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/when_exe/inspect.rb', line 252

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::CalendarNote) —

    暦注オブジェクト

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

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

  • opt (Hash) —

    下記の通り

  • block (Block)

Options Hash (opt):

  • :Range (Range) —

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

Returns:

  • (Range) —

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

  • (Array) —

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

  • (Array<Array>) —

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



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
 
# File 'lib/when_exe/inspect.rb', line 391

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