Quelle md_time.c Sprache: C

/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <stdio.h>

#include <apr_lib.h>
#include <apr_strings.h>
#include <apr_time.h>

#include "md.h"
#include "md_time.h"

apr_time_t md_timeperiod_length(const md_timeperiod_t *period)
{
    return (period->start < period->end)? (period->end - period->start) : 0;
}

int md_timeperiod_contains(const md_timeperiod_t *period, apr_time_t time)
{
    return md_timeperiod_has_started(period, time)
        && !md_timeperiod_has_ended(period, time);
}

int md_timeperiod_has_started(const md_timeperiod_t *period, apr_time_t time)
{
    return (time >= period->start);
}

int md_timeperiod_has_ended(const md_timeperiod_t *period, apr_time_t time)
{
    return (time >= period->start) && (time <= period->end);
}

apr_interval_time_t md_timeperiod_remaining(const md_timeperiod_t *period, apr_time_t time)
{
    if (time < period->start) return md_timeperiod_length(period);
    if (time < period->end) return period->end - time;
    return 0;
}

char *md_timeperiod_print(apr_pool_t *p, const md_timeperiod_t *period)
{
    char tstart[APR_RFC822_DATE_LEN];
    char tend[APR_RFC822_DATE_LEN];

    apr_rfc822_date(tstart, period->start);
    apr_rfc822_date(tend, period->end);
    return apr_pstrcat(p, tstart, " - ", tend, NULL);
}

static const char *duration_print(apr_pool_t *p, int roughly, apr_interval_time_t duration)
{
    const char *s = "", *sep = "";
    long days = (long)(apr_time_sec(duration) / MD_SECS_PER_DAY);
    int rem = (int)(apr_time_sec(duration) % MD_SECS_PER_DAY);

    s = roughly? "~" : "";
    if (days > 0) {
        s = apr_psprintf(p, "%s%ld days", s, days);
        if (roughly) return s;
        sep = " ";
    }
    if (rem > 0) {
        int hours = (rem / MD_SECS_PER_HOUR);
        rem = (rem % MD_SECS_PER_HOUR);
        if (hours > 0) {
            s = apr_psprintf(p, "%s%s%d hours", s, sep, hours);
        if (roughly) return s;
            sep = " ";
        }
        if (rem > 0) {
            int minutes = (rem / 60);
            rem = (rem % 60);
            if (minutes > 0) {
                s = apr_psprintf(p, "%s%s%d minutes", s, sep, minutes);
                if (roughly) return s;
                sep = " ";
            }
            if (rem > 0) {
                s = apr_psprintf(p, "%s%s%d seconds", s, sep, rem);
                if (roughly) return s;
                sep = " ";
            }
        }
    }
    else if (days == 0) {
        s = "0 seconds";
        if (duration != 0) {
            s = apr_psprintf(p, "%d ms", (int)apr_time_msec(duration));
        }
    }
    return s;
}

const char *md_duration_print(apr_pool_t *p, apr_interval_time_t duration)
{
    return duration_print(p, 0, duration);
}

const char *md_duration_roughly(apr_pool_t *p, apr_interval_time_t duration)
{
    return duration_print(p, 1, duration);
}

static const char *duration_format(apr_pool_t *p, apr_interval_time_t duration)
{
    const char *s = "0";
    int units = (int)(apr_time_sec(duration) / MD_SECS_PER_DAY);
    int rem = (int)(apr_time_sec(duration) % MD_SECS_PER_DAY);

    if (rem == 0) {
        s = apr_psprintf(p, "%dd", units);
    }
    else {
        units = (int)(apr_time_sec(duration) / MD_SECS_PER_HOUR);
        rem = (int)(apr_time_sec(duration) % MD_SECS_PER_HOUR);
        if (rem == 0) {
            s = apr_psprintf(p, "%dh", units);
        }
        else {
            units = (int)(apr_time_sec(duration) / 60);
            rem = (int)(apr_time_sec(duration) % 60);
            if (rem == 0) {
                s = apr_psprintf(p, "%dmi", units);
            }
            else {
                units = (int)(apr_time_sec(duration));
                rem = (int)(apr_time_msec(duration) % 1000);
                if (rem == 0) {
                    s = apr_psprintf(p, "%ds", units);
                }
                else {
                    s = apr_psprintf(p, "%dms", (int)(apr_time_msec(duration)));
                }
            }
        }
    }
    return s;
}

const char *md_duration_format(apr_pool_t *p, apr_interval_time_t duration)
{
    return duration_format(p, duration);
}

apr_status_t md_duration_parse(apr_interval_time_t *ptimeout, const char *value,
                               const char *def_unit)
{
    char *endp;
    apr_int64_t n;

    n = apr_strtoi64(value, &endp, 10);
    if (errno) {
        return errno;
    }
    if (!endp || !*endp) {
        if (!def_unit) def_unit = "s";
    }
    else if (endp == value) {
        return APR_EINVAL;
    }
    else {
        def_unit = endp;
    }

    switch (*def_unit) {
    case 'D':
    case 'd':
        *ptimeout = apr_time_from_sec(n * MD_SECS_PER_DAY);
        break;
    case 's':
    case 'S':
        *ptimeout = (apr_interval_time_t) apr_time_from_sec(n);
        break;
    case 'h':
    case 'H':
        /* Time is in hours */
        *ptimeout = (apr_interval_time_t) apr_time_from_sec(n * MD_SECS_PER_HOUR);
        break;
    case 'm':
    case 'M':
        switch (*(++def_unit)) {
        /* Time is in milliseconds */
        case 's':
        case 'S':
            *ptimeout = (apr_interval_time_t) n * 1000;
            break;
        /* Time is in minutes */
        case 'i':
        case 'I':
            *ptimeout = (apr_interval_time_t) apr_time_from_sec(n * 60);
            break;
        default:
            return APR_EGENERAL;
        }
        break;
    default:
        return APR_EGENERAL;
    }
    return APR_SUCCESS;
}

static apr_status_t percentage_parse(const char *value, int *ppercent)
{
    char *endp;
    apr_int64_t n;

    n = apr_strtoi64(value, &endp, 10);
    if (errno) {
        return errno;
    }
    if (*endp == '%') {
        if (n < 0) {
            return APR_BADARG;
        }
        *ppercent = (int)n;
        return APR_SUCCESS;
    }
    return APR_EINVAL;
}

apr_status_t md_timeslice_create(md_timeslice_t **pts, apr_pool_t *p,
                                 apr_interval_time_t norm, apr_interval_time_t len)
{
    md_timeslice_t *ts;

    ts = apr_pcalloc(p, sizeof(*ts));
    ts->norm = norm;
    ts->len = len;
    *pts = ts;
    return APR_SUCCESS;
}

const char *md_timeslice_parse(md_timeslice_t **pts, apr_pool_t *p,
                               const char *val, apr_interval_time_t norm)
{
    md_timeslice_t *ts;
    int percent = 0;

    *pts = NULL;
    if (!val) {
        return "cannot parse NULL value";
    }

    ts = apr_pcalloc(p, sizeof(*ts));
    if (md_duration_parse(&ts->len, val, "d") == APR_SUCCESS) {
        *pts = ts;
        return NULL;
    }
    else {
        switch (percentage_parse(val, &percent)) {
            case APR_SUCCESS:
                ts->norm = norm;
                ts->len = apr_time_from_sec((apr_time_sec(norm) * percent / 100L));
                *pts = ts;
                return NULL;
            case APR_BADARG:
                return "percent must be less than 100";
        }
    }
    return "has unrecognized format";
}

const char *md_timeslice_format(const md_timeslice_t *ts, apr_pool_t *p) {
    if (ts->norm > 0) {
        int percent = (int)(((long)apr_time_sec(ts->len)) * 100L
                            / ((long)apr_time_sec(ts->norm)));
        return apr_psprintf(p, "%d%%", percent);
    }
    return duration_format(p, ts->len);
}

md_timeperiod_t md_timeperiod_slice_before_end(const md_timeperiod_t *period,
                                               const md_timeslice_t *ts)
{
    md_timeperiod_t r;
    apr_time_t duration = ts->len;

    if (ts->norm > 0) {
        int percent = (int)(((long)apr_time_sec(ts->len)) * 100L
                            / ((long)apr_time_sec(ts->norm)));
        apr_time_t plen = md_timeperiod_length(period);
        if (apr_time_sec(plen) > 100) {
            duration = apr_time_from_sec(apr_time_sec(plen) * percent / 100);
        }
        else {
            duration = plen * percent / 100;
        }
    }
    r.start = period->end - duration;
    r.end = period->end;
    return r;
}

int md_timeslice_eq(const md_timeslice_t *ts1, const md_timeslice_t *ts2)
{
    if (ts1 == ts2) return 1;
    if (!ts1 || !ts2) return 0;
    return (ts1->norm == ts2->norm) && (ts1->len == ts2->len);
}

md_timeperiod_t md_timeperiod_common(const md_timeperiod_t *a, const md_timeperiod_t *b)
{
    md_timeperiod_t c;

    c.start = (a->start > b->start)? a->start : b->start;
    c.end = (a->end < b->end)? a->end : b->end;
    if (c.start > c.end) {
        c.start = c.end = 0;
    }
    return c;
}

quality100%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.