}

func (ts *Timespec) setTimestamp(t timestamp) {
	ts.Sec = int64(t / 1e9)
	ts.Nsec = int64(t % 1e9)
}

type Timeval struct {
	Sec  int64
	Usec int64
}

func (tv *Timeval) timestamp() timestamp {
	return timestamp(tv.Sec*1e9) + timestamp(tv.Usec*1e3)
}

func (tv *Timeval) setTimestamp(t timestamp) {
	tv.Sec = int64(t / 1e9)

        Map<String, Set<String>> getKeepClassesByArtifact()
        void setKeepClassesByArtifact(Map<String, Set<String>> keepClasses)
// end::artifact-transform-minify[]
        @Input
        Long getTimestamp()
        void setTimestamp(Long timestamp)
// tag::artifact-transform-minify[]
    }

    @PathSensitive(PathSensitivity.NAME_ONLY)
    @InputArtifact
    abstract Provider<FileSystemLocation> getInputArtifact()

        snapshot.setTimestamp(timestamp);

        Versioning versioning = new Versioning();
        versioning.setSnapshot(snapshot);
        versioning.setLastUpdated(snapshot.getTimestamp().replace(".", ""));

        String timestampVersion = version.replace("SNAPSHOT", snapshot.getTimestamp() + "-" + snapshot.getBuildNumber());

        String version = null;
        Snapshot snapshot = versioning.getSnapshot();
        if (snapshot != null) {
            if (snapshot.getTimestamp() != null && snapshot.getBuildNumber() > 0) {
                String newVersion = snapshot.getTimestamp() + "-" + snapshot.getBuildNumber();
                version = baseVersion.replace(Artifact.SNAPSHOT_VERSION, newVersion);
            } else {

            snapshot = new Snapshot();
            snapshot.setBuildNumber(buildNumber != null ? buildNumber : getBuildNumber(recessive) + 1);
            snapshot.setTimestamp(utcDateFormatter.format(timestamp));

            Versioning versioning = new Versioning();
            versioning.setSnapshot(snapshot);
            versioning.setLastUpdatedTimestamp(timestamp);

            connection.prepareStatement(SELECT_LATEST_EXECUTION_TIMES).withCloseable { statement ->
                int idx = 0
                OperatingSystem.values().each { os ->
                    statement.setTimestamp(++idx, since)
                    List<String> channels = ['commits', 'experiments'].stream()
                        .collect { channel -> "${channel}${os.channelSuffix}-master".toString() }

    }

    public void store(final DictionaryFile<? extends DictionaryItem> dictFile, final File file) {
        getDictionaryFile(dictFile.getId()).ifPresent(currentFile -> {
            if (currentFile.getTimestamp().getTime() > dictFile.getTimestamp().getTime()) {
                throw new DictionaryException(dictFile.getPath() + " was updated.");
            }

            // TODO use stream

    public StyledTextOutputEvent withLogLevel(LogLevel logLevel) {
        return new StyledTextOutputEvent(getTimestamp(), getCategory(), logLevel, getBuildOperationId(), spans);
    }

    @Override
    public StyledTextOutputEvent withBuildOperationId(OperationIdentifier buildOperationId) {
        return new StyledTextOutputEvent(getTimestamp(), getCategory(), getLogLevel(), buildOperationId, spans);
    }

    @Override

public class UpdateNowEvent extends OutputEvent implements InteractiveEvent {

    private final long timestamp;

    public UpdateNowEvent(long timestamp) {
        this.timestamp = timestamp;
    }

    public long getTimestamp() {
        return timestamp;
    }

    @Override
    public String toString() {
        return UpdateNowEvent.class.getSimpleName() + " " + timestamp;
    }

    @Override

        long gcCountDelta = last.getCount() - first.getCount();
        // Time interval between the first event in the window and the last
        long timeDelta = TimeUnit.MILLISECONDS.toSeconds(last.getTimestamp() - first.getTimestamp());
        return (double)gcCountDelta / timeDelta;
    }

    private static long calculateAverageUsage(Collection<GarbageCollectionEvent> events) {
        long sum = 0;