ファイルライターを切り替える。

@param nowTime 切替時刻
427431
private void switchWriter(long nowTime)
    {
        closeRenameTmp2BaseFile();

        // 次のファイル名称に用いる時刻を算出する。
        // ファイル出力の間が空いた時のために切り替えた時刻にあわせて次のファイル名用時刻を算出する。
        long nextBaseTime = TimeIntervalFormatUtil.generateNextFileBaseTime(nowTime,
                this.nextSwitchTime, this.switchTimeInterval, this.switchTimeUnit);

        this.currentOutputUri = generateOutputFileBase(this.outputDirUri,
                this.config.getFileNameHeader(), this.config.getFileNameBody(), this.dateFormat,
                nextBaseTime);

        this.nextSwitchTime = nextBaseTime
                + this.config.getFileSwitchIntervalUnit().toMillis(this.switchTimeInterval);

        updateWriter();
    }
791304
protected void updateFade (float time)
    {
        if (_fadeMode == FadeMode.NONE) {
            return;
        }
        float alpha = Math.min((_fadeElapsed += time) / _fadeInterval, 1f);
        _source.setGain(_gain * (_fadeMode == FadeMode.IN ? alpha : (1f - alpha)));
        if (alpha == 1f) {
            if (_fadeMode == FadeMode.OUT) {
                stop();
            } else if (_fadeMode == FadeMode.OUT_DISPOSE) {
                dispose();
            }
            _fadeMode = FadeMode.NONE;
        }
    }
1069214
@Override
    public void accept(long current) {
        if (isDone()) return;

        long now = clock.millis();
        if (current > total) current = total;
        int pts_w = terminalWidthSupplier.getAsInt() - 23 - title.length();

        fraction = ((double) current) / ((double) total);
        int pct = (int) (fraction * 100);
        int pts = (int) (fraction * pts_w);

        if (current < total) {
            if (now - last_update < 73 && pct == last_pct && pts == last_pts) {
                return;
            }

            int remaining_pts = pts_w - pts;

            long     duration_ms = now - start;
            Duration remaining   = null;
            // Progress has actually gone forward, recalculate total time.
            if (duration_ms > 3000) {
                long remaining_ms;
                if (expected_done_ts == 0L || pct > last_pct) {
                    long assumed_total = (long) (((double) duration_ms) / fraction);
                    remaining_ms = max(0L, assumed_total - duration_ms);
                    expected_done_ts = now + remaining_ms;
                } else {
                    remaining_ms = max(0L, expected_done_ts - now);
                }
                remaining = Duration.of(remaining_ms, ChronoUnit.MILLIS);
            }

            if (now >= (spinner_update + 100)) {
                spinner_pos = (spinner_pos + 1) % spinner.spinner.length;
                spinner_update = now;
            }

            if (pts < pts_w) {
                updater.formatln("%s: [%s%s%s%s%s] %3d%% %s%s%s%s",
                                 title,

                                 Color.GREEN,
                                 Strings.times(spinner.done.toString(), pts),
                                 Color.YELLOW,
                                 Strings.times(spinner.remain.toString(), remaining_pts),
                                 Color.CLEAR,

                                 pct,

                                 new Color(Color.YELLOW, Color.BOLD),
                                 spinner.spinner[spinner_pos],
                                 Color.CLEAR,
                                 remaining == null ? "" : " + " + format(remaining));
            } else {
                updater.formatln("%s: [%s%s%s] 100%% %s%s%s%s",
                                 title,

                                 Color.GREEN,
                                 Strings.times(spinner.done.toString(), pts),
                                 Color.CLEAR,

                                 new Color(Color.YELLOW, Color.BOLD),
                                 spinner.spinner[spinner_pos],
                                 Color.CLEAR,
                                 remaining == null ? "" : " + " + format(remaining));
            }
            last_pct = pct;
            last_pts = pts;
            last_update = now;
        } else {
            updater.formatln("%s: [%s%s%s] 100%% %s%s%s @ %s",
                             title,

                             Color.GREEN,
                             Strings.times(spinner.done.toString(), pts_w),
                             Color.CLEAR,

                             new Color(Color.GREEN, Color.BOLD),
                             spinner.complete,
                             Color.CLEAR,
                             format(Duration.of(now - start, ChronoUnit.MILLIS)));
            last_update = Long.MAX_VALUE;
            last_pct = 100;
        }
    }
1365876
function getTimeString (now) {
  var year = "" + now.getFullYear();
  var month = "" + (now.getMonth() + 1); if (month.length == 1) { month = "0" + month }
  var day = "" + now.getDate(); if (day.length == 1) { day = "0" + day }
  var hour = "" + now.getHours(); if (hour.length == 1) { hour = "0" + hour }
  var minute = "" + now.getMinutes(); if (minute.length == 1) { minute = "0" + minute }
  var second = "" + now.getSeconds(); if (second.length == 1) { second = "0" + second }
  var ms = "" + now.getMilliseconds(); while (ms.length < 3) { ms = "0"+ms }
  return year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second + "." + ms;
}
1334475
@Override
    public synchronized void updateLastAccessTime(long accessTime) {
        if (_lastAccessedTime == 0) { // newly created session object
            _lastAccessedTime = accessTime;
        } else {
            _lastAccessedTime = _currentAccessTime;
        }
        _currentAccessTime = accessTime;
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[UPDATE_LAST_ACCESS_TIME], "" + accessTime);
        }
    }
762720
private void updateDurationTimeUnit(FastTrackColumn column)
   {
      if (m_durationTimeUnit == null && isDurationColumn(column))
      {
         int value = ((DurationColumn) column).getTimeUnitValue();
         if (value != 1)
         {
            m_durationTimeUnit = FastTrackUtility.getTimeUnit(value);
         }
      }
   }
1369389
protected synchronized void increment(long now) {
		pointer++;
		if (pointer >= timestamps.length) {
			pointer = 0;
		}
		timestamps[pointer] = now;
		max = now;

		int next = pointer + 1;
		if (next >= timestamps.length) {
			next = 0;
		}
		min = timestamps[next];
	}
717341
public PythonWindowedStream time_window(Time size, Time slide) {
		return new PythonWindowedStream<TimeWindow>(this.stream.timeWindow(size, slide));
	}
627396
public void setMorphTime(float time) {
		for (int i=0;i<figures.size();i++) {
			Figure figure = (Figure) figures.get(i);
			MorphShape shape = (MorphShape) figure.getShape();
			shape.setMorphTime(time);
		}
	}
736677
public void tick (long now)
    {
        if (!_enabled) {
            return;
        }

        // Initialize the starting time if necessary
        if (_start == Long.MIN_VALUE) {
            _start = now - Math.round(_duration * _complete);
        }

        // Initialize the timestamp of the rendering error if necessary
        if (_renderOffsetTime == Long.MIN_VALUE) {
            _renderOffsetTime = now;
        }

        // If the timer was just unpaused, handle the updates that
        // need a timestamp
        if (_processUnpause) {
            _processUnpause = false;
            _start += now - _lastUpdate;
        }

        // Update the completion and triggers when the timer is running
        if (running())
        {
            // Figure out how what percent the timer has completed
            _lastUpdate = now;
            _complete = ((float) (_lastUpdate - _start)) / _duration;

            // Handle warning trigger if necessary
            if (triggeredWarning()) {
                handleWarning();
            }

            // Handle completion trigger if necessary
            if (triggeredCompleted()) {
                handleCompleted();
            }
        }

        // Add error to the render completion percent if the interpolation
        // hasn't finished yet
        _renderComplete = _complete;
        if (_renderOffsetTime + _transitionTime > now) {
            _renderComplete += _renderOffset *
                (1f - (now - _renderOffsetTime) / (float) _transitionTime);
            _renderComplete = Math.max(0f, Math.min(1f, _renderComplete));
        }

        // Possibly orce a repaint if the render level changed (highly
        // probable but not guaranteed)
        if (_renderComplete != _paintComplete)
        {
            // Always force a repaint when changing to or from a boundary
            if (_renderComplete <= 0f || _paintComplete <= 0f ||
                _renderComplete >= 1f || _paintComplete >= 1f)
            {
                invalidate();
            }

            // Also force a repaint if the completion state sufficiently
            // changed
            else if (Math.abs(_renderComplete - _paintComplete) >
                     _changeThreshold)
            {
                invalidate();
            }
        }
    }
1098340
public void setHideTime(boolean enable, final boolean useDarkTheme) {
        if(enable && !shouldHideTime) {
            // hide the time spinner and show a button to show it instead
            timeSpinner.setVisibility(GONE);
            ImageButton timeButton = (ImageButton) LayoutInflater.from(getContext()).inflate(R.layout.time_button, null);
            timeButton.setImageResource(useDarkTheme ? R.drawable.ic_action_time_dark : R.drawable.ic_action_time_light);
            timeButton.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    setHideTime(false, useDarkTheme);
                }
            });
            this.addView(timeButton);
        } else if(!enable && shouldHideTime) {
            timeSpinner.setVisibility(VISIBLE);
            this.removeViewAt(2);
        }
        shouldHideTime = enable;
    }
444465
public void updateLastTimeSMPPLinkUpdated() {
		lastTimeSMPPLinkUpdated = System.currentTimeMillis();
		if(logger.isDebugEnabled())
			logger.debug("Updated Last Client " + channel.getRemoteAddress().toString() + " Enquire Link time update " + lastTimeSMPPLinkUpdated);
	}
998409
void refresh(long now) {
    refreshCandidateSpeculativeMaps(now);
    refreshCandidateSpeculativeReduces(now);
    refreshTaskCountsAndWaitTime(TaskType.MAP, now);
    refreshTaskCountsAndWaitTime(TaskType.REDUCE, now);
  }
227987
public void time(Runnable event) {
        long startTime = this.clock.getTick();
        try {
            event.run();
        } finally {
            update(this.clock.getTick() - startTime);
        }
    }
1225330
protected void setTimeoutTime(int time) {
        int timeout = time;
        if (timeout == TCPRequestContext.NO_TIMEOUT) {
            this.timeoutTime = TCPRequestContext.NO_TIMEOUT;
            this.timeoutInterval = 0;
        } else {
            if (timeout == TCPRequestContext.USE_CHANNEL_TIMEOUT) {
                timeout = getConfig().getInactivityTimeout();
            }
            if (timeout != ValidateUtils.INACTIVITY_TIMEOUT_NO_TIMEOUT) {
                this.timeoutTime = System.currentTimeMillis() + timeout;
                this.timeoutInterval = timeout;
            } else {
                this.timeoutTime = TCPRequestContext.NO_TIMEOUT;
                this.timeoutInterval = 0;
            }
        }
    }
1273149
void start(long currentTime) {
        this.readyTime = currentTime;
        this.startTime = this.readyTime + this.delayTime;
        this.endTime = this.startTime + getDuration();
        this.status = TweenAnimationStatus.RUNNING;
    }
291565
public static final void setTimes(FileTime lastModifiedTime, FileTime lastAccessTime, FileTime createTime, Path... files) throws IOException
    {
        for (Path file : files)
        {
            BasicFileAttributeView view = Files.getFileAttributeView(file, BasicFileAttributeView.class);
            view.setTimes(lastModifiedTime, lastAccessTime, createTime);
        }
    }