Retrieves the timephased breakdown of the planned overtime work for this
resource assignment.

@return timephased planned work
508344
public List<TimephasedWork> getTimephasedOvertimeWork()
   {
      if (m_timephasedOvertimeWork == null && m_timephasedWork != null && getOvertimeWork() != null)
      {
         double perDayFactor = getRemainingOvertimeWork().getDuration() / (getRemainingWork().getDuration() - getRemainingOvertimeWork().getDuration());
         double totalFactor = getRemainingOvertimeWork().getDuration() / getRemainingWork().getDuration();

         perDayFactor = Double.isNaN(perDayFactor) ? 0 : perDayFactor;
         totalFactor = Double.isNaN(totalFactor) ? 0 : totalFactor;

         m_timephasedOvertimeWork = new DefaultTimephasedWorkContainer(m_timephasedWork, perDayFactor, totalFactor);
      }
      return m_timephasedOvertimeWork == null ? null : m_timephasedOvertimeWork.getData();
   }
793855
public Duration getDurationVariance()
   {
      Duration variance = (Duration) getCachedValue(TaskField.DURATION_VARIANCE);
      if (variance == null)
      {
         Duration duration = getDuration();
         Duration baselineDuration = getBaselineDuration();

         if (duration != null && baselineDuration != null)
         {
            variance = Duration.getInstance(duration.getDuration() - baselineDuration.convertUnits(duration.getUnits(), getParentFile().getProjectProperties()).getDuration(), duration.getUnits());
            set(TaskField.DURATION_VARIANCE, variance);
         }
      }
      return (variance);
   }
124756
public long getMinTime() {
    lock.lock();
    try {
      if (printMinMax) {
        return previousIntervalMinMax.minTime;
      }
      return minMax.minTime;
    } finally {
      lock.unlock();
    }
  }
223871
public List<TimephasedCost> getTimephasedBaselineCost(int index)
   {
      return m_timephasedBaselineCost[index] == null ? null : m_timephasedBaselineCost[index].getData();
   }
725583
public Duration getWorkVariance()
   {
      Duration variance = (Duration) getCachedValue(ResourceField.WORK_VARIANCE);
      if (variance == null)
      {
         Duration work = getWork();
         Duration baselineWork = getBaselineWork();
         if (work != null && baselineWork != null)
         {
            variance = Duration.getInstance(work.getDuration() - baselineWork.convertUnits(work.getUnits(), getParentFile().getProjectProperties()).getDuration(), work.getUnits());
            set(ResourceField.WORK_VARIANCE, variance);
         }
      }
      return (variance);
   }
519758
public com.google.api.ads.admanager.axis.v201902.ForecastBreakdownOptions getBreakdown() {
        return breakdown;
    }
348270
public Duration getUptime()
	{
		final DateTime startup = getStartupDate();
		if (null != startup)
		{
			return Duration.elapsed(Time.valueOf(startup.toDate()));
		}
		return Duration.NONE;
	}
1295666
public Duration getWork(Date startDate, Date endDate, TimeUnit format)
   {
      DateRange range = new DateRange(startDate, endDate);
      Long cachedResult = m_workingDateCache.get(range);
      long totalTime = 0;

      if (cachedResult == null)
      {
         //
         // We want the start date to be the earliest date, and the end date
         // to be the latest date. Set a flag here to indicate if we have swapped
         // the order of the supplied date.
         //
         boolean invert = false;
         if (startDate.getTime() > endDate.getTime())
         {
            invert = true;
            Date temp = startDate;
            startDate = endDate;
            endDate = temp;
         }

         Date canonicalStartDate = DateHelper.getDayStartDate(startDate);
         Date canonicalEndDate = DateHelper.getDayStartDate(endDate);

         if (canonicalStartDate.getTime() == canonicalEndDate.getTime())
         {
            ProjectCalendarDateRanges ranges = getRanges(startDate, null, null);
            if (ranges.getRangeCount() != 0)
            {
               totalTime = getTotalTime(ranges, startDate, endDate);
            }
         }
         else
         {
            //
            // Find the first working day in the range
            //
            Date currentDate = startDate;
            Calendar cal = Calendar.getInstance();
            cal.setTime(startDate);
            Day day = Day.getInstance(cal.get(Calendar.DAY_OF_WEEK));
            while (isWorkingDate(currentDate, day) == false && currentDate.getTime() < canonicalEndDate.getTime())
            {
               cal.add(Calendar.DAY_OF_YEAR, 1);
               currentDate = cal.getTime();
               day = day.getNextDay();
            }

            if (currentDate.getTime() < canonicalEndDate.getTime())
            {
               //
               // Calculate the amount of working time for this day
               //
               totalTime += getTotalTime(getRanges(currentDate, null, day), currentDate, true);

               //
               // Process each working day until we reach the last day
               //
               while (true)
               {
                  cal.add(Calendar.DAY_OF_YEAR, 1);
                  currentDate = cal.getTime();
                  day = day.getNextDay();

                  //
                  // We have reached the last day
                  //
                  if (currentDate.getTime() >= canonicalEndDate.getTime())
                  {
                     break;
                  }

                  //
                  // Skip this day if it has no working time
                  //
                  ProjectCalendarDateRanges ranges = getRanges(currentDate, null, day);
                  if (ranges.getRangeCount() == 0)
                  {
                     continue;
                  }

                  //
                  // Add the working time for the whole day
                  //
                  totalTime += getTotalTime(ranges);
               }
            }

            //
            // We are now at the last day
            //
            ProjectCalendarDateRanges ranges = getRanges(endDate, null, day);
            if (ranges.getRangeCount() != 0)
            {
               totalTime += getTotalTime(ranges, DateHelper.getDayStartDate(endDate), endDate);
            }
         }

         if (invert)
         {
            totalTime = -totalTime;
         }

         m_workingDateCache.put(range, Long.valueOf(totalTime));
      }
      else
      {
         totalTime = cachedResult.longValue();
      }

      return convertFormat(totalTime, format);
   }
602337
public long getElapsedMilliseconds() {
		long elapsed;
		if (running) {
			elapsed = (System.nanoTime() - startTime);
		} else {
			elapsed = (stopTime - startTime);
		}
		return elapsed / nsPerMs;
	}
483076
public com.google.api.ads.admanager.axis.v201808.ForecastBreakdownEntry[] getBreakdownEntries() {
        return breakdownEntries;
    }
911737
private TimerTask getTimerTask() {
    final TimeBasedReportingMetric<T> lockObject = this;
    final TimerTask recurringReporting = new TimerTask() {
      @Override
      public void run() {
        synchronized (lockObject) {
          preTrackingEventMethod();
          notifyManager();
          postTrackingEventMethod();
        }
      }
    };
    return recurringReporting;
  }
1043573
public ZonedDateTime getTime() {
        if (null == time) {
            ZonedDateTime now = ZonedDateTime.now();
            time = new ObjectPropertyBase<ZonedDateTime>(now) {
                @Override protected void invalidated() {
                    zoneId = get().getZone();
                    fireTileEvent(RECALC_EVENT);
                    if (!isRunning() && isAnimated()) {
                        long animationDuration = getAnimationDuration();
                        timeline.stop();
                        final KeyValue KEY_VALUE = new KeyValue(currentTime, now.toEpochSecond());
                        final KeyFrame KEY_FRAME = new KeyFrame(javafx.util.Duration.millis(animationDuration), KEY_VALUE);
                        timeline.getKeyFrames().setAll(KEY_FRAME);
                        timeline.setOnFinished(e -> fireTileEvent(FINISHED_EVENT));
                        timeline.play();
                    } else {
                        currentTime.set(now.toEpochSecond());
                        fireTileEvent(FINISHED_EVENT);
                    }
                }
                @Override public Object getBean() { return Tile.this; }
                @Override public String getName() { return "time"; }
            };
        }
        return time.get();
    }
565367
public double getAverageFiringTime() {
        long fires = this.agendaStats.getConsolidatedStats().matchesFired.get();
        long time = this.agendaStats.getConsolidatedStats().firingTime.get();
        // calculating the average and converting it from nano secs to milli secs
        return fires > 0 ? (((double) time / (double) fires) / (double) NANO_TO_MILLISEC) : 0;
    }
97956
public Number getOvertimeCost()
   {
      Number cost = (Number) getCachedValue(AssignmentField.OVERTIME_COST);
      if (cost == null)
      {
         Number actual = getActualOvertimeCost();
         Number remaining = getRemainingOvertimeCost();
         if (actual != null && remaining != null)
         {
            cost = NumberHelper.getDouble(actual.doubleValue() + remaining.doubleValue());
            set(AssignmentField.OVERTIME_COST, cost);
         }
      }
      return (cost);
   }
648269
public Granularity getGranularity() {
        Interval interval = getInterval();
        if (interval != null) {
            return interval.getStartGranularity();
        } else {
            return null;
        }
    }
284145
public long getLastAccessedTime() {
        if (!_iSess.isValid())
            throw new IllegalStateException();
        long value = 0;
        if (_iSess != null) {
            value = _iSess.getLastAccessedTime();
        }
        return value;
    }
284077
public ZonedDateTime getEndZonedDateTime() {
        if (zonedEndDateTime == null) {
            zonedEndDateTime = ZonedDateTime.of(endDate, endTime, zoneId);
        }

        return zonedEndDateTime;
    }