Update the default time unit for durations based on data read from the file.

@param column column data
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);
         }
      }
   }
251414
public java.sql.Time getTime(String column) {
		return (java.sql.Time)getColumns().get(column);
	}
758461
public void update(Date lastScheduledExecutionTime, Date lastActualExecutionTime, Date lastCompletionTime) {
        this.lastScheduledExecutionTime = lastScheduledExecutionTime;
        this.lastActualExecutionTime = lastActualExecutionTime;
        this.lastCompletionTime = lastCompletionTime;
    }
1121738
public void addExecutionTime(long time) {
		totalTime.increaseByLong(time);
		lastRequest.setValueAsLong(time);
		minTime.setValueIfLesserThanCurrentAsLong(time);
		maxTime.setValueIfGreaterThanCurrentAsLong(time);

	}
465659
public void toggleColumn(final Column column) {
        if (_analysisJobBuilder.containsSourceColumn(column)) {
            _analysisJobBuilder.removeSourceColumn(column);
        } else {
            _analysisJobBuilder.addSourceColumn(column);
        }
    }
1144327
public void assignTimestamp(XEvent event, long time) {
		XAttributeTimestamp attr = (XAttributeTimestamp) ATTR_TIMESTAMP.clone();
		attr.setValueMillis(time);
		event.getAttributes().put(KEY_TIMESTAMP, attr);
	}
688241
public void modifyTimeBase(){
		String [] time_grid=new String[6];
		time_grid=normalizer.getTimeBase().split("-");
		
		String s = "";
		if(_tp.tunit[0] != -1)
			s += Integer.toString(_tp.tunit[0]);
		else
			s += time_grid[0];
		for(int i = 1; i < 6; i++){
			s += "-";
			if(_tp.tunit[i] != -1)
				s += Integer.toString(_tp.tunit[i]);
			else
				s += time_grid[i];
		}
		normalizer.setTimeBase(s);
	}
237565
public void tick(long duration, TimeUnit unit) {
        this.date = new Date(date.getTime() + unit.toMillis(duration));
    }
793366
public T setDuration(long duration, TimeUnit units) {
    checkNotNull(units);

    this.duration = units.toMillis(duration);

    return getThis();
  }
1188692
public void setDuration(int index, Duration value)
   {
      set(selectField(TaskFieldLists.CUSTOM_DURATION, index), value);
   }
1041855
public void setDuration(int index, Duration value)
   {
      set(selectField(AssignmentFieldLists.CUSTOM_DURATION, index), value);
   }
320184
public DJTimeSeriesChartBuilder addSerie(AbstractColumn column, String label) {
		getDataset().addSerie(column, label);
		return this;
	}
512872
def _setup_time(self, basemap):
        """"""
        # validate time column information
        if self.geom_type != 'point':
            raise ValueError('Cannot do time-based maps with data in '
                             '`{query}` since this table does not contain '
                             'point geometries'.format(
                                 query=self.orig_query))
        elif self.style_cols[self.time['column']] not in (
                'number', 'date', ):
            raise ValueError('Cannot create an animated map from column '
                             '`{col}` because it is of type {t1}. It must '
                             'be of type number or date.'.format(
                                 col=self.time['column'],
                                 t1=self.style_cols[self.time['column']]))

        # don't use turbo-carto for animated maps
        column = self.time['column']
        frames = self.time['frames']
        method = self.time['method']
        duration = self.time['duration']
        if (self.color in self.style_cols and
                self.style_cols[self.color] in ('string', 'boolean', )):
            self.query = minify_sql([
                'SELECT',
                '    orig.*, __wrap.cf_value_{col}',
                'FROM ({query}) AS orig, (',
                '    SELECT',
                '      row_number() OVER (',
                '        ORDER BY val_{col}_cnt DESC) AS cf_value_{col},',
                '      {col}',
                '    FROM (',
                '        SELECT {col}, count({col}) AS val_{col}_cnt',
                '        FROM ({query}) as orig',
                '        GROUP BY {col}',
                '        ORDER BY 2 DESC',
                '    ) AS _wrap',
                ') AS __wrap',
                'WHERE __wrap.{col} = orig.{col}',
            ]).format(col=self.color, query=self.orig_query)
            agg_func = '\'CDB_Math_Mode(cf_value_{})\''.format(self.color)
            self.scheme = {
                'bins': [str(i) for i in range(1, 11)],
                'name': (self.scheme.get('name') if self.scheme
                         else 'Bold'),
                'bin_method': '', }
        elif (self.color in self.style_cols and
              self.style_cols[self.color] in ('number', )):
            self.query = ' '.join([
                'SELECT *, {col} as value',
                'FROM ({query}) as _wrap'
            ]).format(col=self.color, query=self.orig_query)
            agg_func = '\'avg({})\''.format(self.color)
        else:
            agg_func = "'{method}(cartodb_id)'".format(
                method=method)
        self.torque_cartocss = cssify({
            'Map': {
                '-torque-frame-count': frames,
                '-torque-animation-duration': duration,
                '-torque-time-attribute': "'{}'".format(column),
                '-torque-aggregation-function': agg_func,
                '-torque-resolution': 1,
                '-torque-data-aggregation': ('cumulative'
                                             if self.time['cumulative']
                                             else 'linear'),
            },
        })
        self.cartocss = (self.torque_cartocss
                         + self._get_cartocss(basemap, has_time=True))
1258703
public static void setUtc(Date time) {
		setClock(Clock.fixed(time.toInstant(), ZoneId.of("UTC")));
	}
230220
protected function updateTimestamps()
    {
        $time = $this->freshTimestamp();

        if (! is_null($column = $this->getUpdatedAtColumn()) && ! $this->isDirty($column)) {
            $this->setAttribute($column, $time);
        }

        if (! $this->exists && ! is_null($column = $this->getCreatedAtColumn()) && ! $this->isDirty($column)) {
            $this->setAttribute($column, $time);
        }
    }
1209577
public static void updateTimer(Optional<Timer> timer, final long duration, final TimeUnit unit) {
    timer.transform(new Function<Timer, Timer>() {
      @Override
      public Timer apply(@Nonnull Timer input) {
        input.update(duration, unit);
        return input;
      }
    });
  }
41197
public static void addModificationTimeToAttributes(Map<String, byte[]> attributes, Clock clock) {
    attributes.put(FILE_MODIFICATION_TIMESTAMP_KEY, Longs.toByteArray(clock.currentTimeMillis()));
  }