When

     # File when.rb, line 294
294:   def Calendar(calendar)
295:     Parts::IRI._instance(calendar, '_c:')
296:   end

     # File when.rb, line 282
282:   def CalendarEra(*args)
283:     TM::CalendarEra._instance(*args)
284:   end

     # File when.rb, line 307
307:   def Clock(clock)
308:     case clock
309:     when 'Z'       ; return utc
310:     when TM::Clock ; return clock
311:     when String
312:       c = TM::Clock[clock] || V::Timezone[clock]
313:       return c if c
314:       Parts::IRI._instance("_tm:Clock?label=" + clock)
315:     else           ; raise TypeError, "Invalid Type: #{clock.class}"
316:     end
317:   end

     # File when.rb, line 236
236:   def Duration(period, options={})
237:     case period
238:     when Array
239:       return period.map {|e| Duration(e, options)}
240: 
241:     when TM::Duration
242:       return period
243: 
244:     else
245:       # IntervalLength
246:       args = TM::IntervalLength._to_array(period)
247:       return TM::IntervalLength.new(*args) if args
248: 
249:       # PeriodDuration
250:       sign, *args = TM::PeriodDuration._to_array(period)
251:       raise TypeError, "Argument 'period' is not a Duration" unless (sign)
252:       args << options
253:       duration = TM::PeriodDuration.new(*args)
254:       return (sign >= 0) ? duration : -duration
255:     end
256:   end

     # File when.rb, line 334
334:   def IRI(iri, namespace=nil)
335:     Parts::IRI._instance(iri, namespace)
336:   end

     # File when.rb, line 347
347:   def M17n(source, namespace=nil, locale=nil)
348:     case source
349:     when Array            ; BasicTypes::M17n.new(source, namespace, locale)
350:     when BasicTypes::M17n ; source
351:     when String
352:       return Parts::IRI[$1] if source =~ /^\s*\[::([^\]]+)\]/
353:       BasicTypes::M17n.new(source, namespace, locale)
354:     else ; raise TypeError, "Invalid Type: #{source.class}"
355:     end
356:   end

     # File when.rb, line 365
365:   def Pair(pair, branch=nil)
366:     return Coordinates::Pair._force_pair(pair, branch)
367:   end

     # File when.rb, line 152
152:   def TemporalPosition(*args)
153:     # 引数の解釈
154:     options  = args[1].kind_of?(Hash) ? args.pop.dup : {}
155:     validate = options.delete(:validate)
156:     validate = true if validate == nil
157:     options[:frame]  ||= 'Gregorian'
158:     options[:frame]    = IRI(options[:frame], '_c:') if options[:frame].kind_of?(String)
159:     options[:era_name] = args.shift if args[0].kind_of?(String) || args[0].kind_of?(Array)
160: 
161:     # 時間位置の生成
162:     date = Array.new(options[:frame].indices.length+1) {args.shift}
163:     if (args.length > 0)
164:       options[:clock] ||= TM::Clock.local_time || utc
165:       time = Array.new(options[:clock].indices.length) {args.shift}
166:       position = TM::DateAndTime.new(date, time.unshift(0), options)
167:     else
168:       position = TM::CalDate.new(date, options)
169:     end
170:     return position unless validate
171: 
172:     # 時間位置の存在確認
173:     date[0] = -date[0] if position.calendar_era_name && position.calendar_era_name[2] # 紀元前
174:     date.each_index do |i|
175:       break unless date[i]
176:       raise ArgumentError, "Specified date not found: #{date}" unless Coordinates::Pair._force_pair(date[i]) ==
177:                                                                       Coordinates::Pair._force_pair(position.cal_date[i])
178:     end
179:     return position unless time
180:     time.each_index do |i|
181:       break unless time[i]
182:       return nil unless Coordinates::Pair._force_pair(time[i]) ==
183:                         Coordinates::Pair._force_pair(position.clk_time.clk_time[i])
184:     end
185:     return position
186:   end

     # File when.rb, line 198
198:   def now(options={})
199:     options = options._attr if options.kind_of?(TM::TemporalPosition)
200:     options[:frame] ||= 'Gregorian'
201:     options[:frame]   = IRI(options[:frame], '_c:') if options[:frame].kind_of?(String)
202:     clock = options[:clock] || TM::Clock.local_time || utc
203:     jdt  = TM::JulianDate.new(Time.now.to_f * TM::IntervalLength::SECOND, {:frame=>clock})
204:     options[:clock]   = jdt.frame
205:     date = options[:frame].jul_trans(jdt, options)
206:     date = TM::CalDate.new(date.cal_date, options) if options[:precision] &&
207:                                                       options[:precision] <= Coordinates::DAY
208:     return date
209:   end

     # File when.rb, line 379
379:   def setup(options={})
380:     Parts::IRI.setup
381:     Parts::Locale.setup(options[:alias])
382:     TM::CalendarEra.setup(options[:order])
383:     TM::Clock.setup(options[:local])
384:     TM::TemporalPosition.setup(options[:format])
385:     V::Event.setup(options[:until])
386:     V::Timezone.setup
387:     Ephemeris::TimeStandard.setup(options[:leap_seconds])
388:   end

     # File when.rb, line 221
221:   def today(options={})
222:     now(options.merge({:precision=>Coordinates::DAY}))
223:   end

     # File when.rb, line 320
320:   def utc
321:     Parts::IRI._instance("_c:UTC")
322:   end

     # File when.rb, line 112
112:   def when?(specification, options={})
113: 
114:     # フォーマットごとの処理
115:     case specification
116:     when TM::TemporalPosition, Parts::GeometricComplex
117:       return specification
118: 
119:     when Numeric
120:       return TM::JulianDate.new((+specification - (TM::JulianDate::JD19700101-0.5))*TM::IntervalLength::DAY,
121:                                  TM::TemporalPosition._options(options))
122: 
123:     when Array
124:       options = TM::TemporalPosition._options(options)
125:       return specification.map {|e| when?(e, options)}
126: 
127:     when String
128:       return when?(specification.split(/[\n\r]+/), options) if specification =~ /[\n\r]+/
129:       return TM::TemporalPosition._instance(specification, options)
130: 
131:     else
132:       return nil
133:     end
134:   end