C++ QDateTime::offsetFromUtc方法代码示例

void AbstractDateTime::copyTimeSpec(const QDateTime &from,
                                    QDateTime &to)
{
    switch(from.timeSpec())
    {
        case Qt::UTC:
        /* Fallthrough. */
        case Qt::LocalTime:
        {
            to.setTimeSpec(from.timeSpec());
            return;
        }
        case Qt::OffsetFromUTC:
        {
            to.setOffsetFromUtc(from.offsetFromUtc());
            Q_ASSERT(to.timeSpec() == Qt::OffsetFromUTC);
            return;
        }
        case Qt::TimeZone:
        {
            to.setTimeZone(from.timeZone());
            return;
        }
    }
}

bool SortFilterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
    if (filterRole() == "fromNow" && sourceModel()->roleNames().values().contains("start")) {
        QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
        QDateTime date = sourceModel()->data(index, sourceModel()->roleNames().key("start")).toDateTime();
        QDateTime currentDateTime = QDateTime::currentDateTime();
        int localTimeZoneOffset = currentDateTime.offsetFromUtc();
        currentDateTime.setMSecsSinceEpoch(currentDateTime.currentMSecsSinceEpoch() + localTimeZoneOffset*1000);
        return date >= currentDateTime;
    } else {
        if (m_hide && sourceModel()->roleNames().values().contains("hideInSchedule")) {
            QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
            bool willBeHidden = sourceModel()->data(index, sourceModel()->roleNames().key("hideInSchedule")).toBool();
            if (willBeHidden)
                return false;
        }
        return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
    }
}

template <> RubyValue Conversion<QDateTime>::to(const QDateTime &dateTime)
{
    RubyValue sec = rb_rational_new(RubyValue::from(dateTime.toMSecsSinceEpoch()), RubyValue::from(1000));
    RubyValue time = rb_time_num_new(sec, RubyValue::from(dateTime.offsetFromUtc()));
    return time.send(RUBYQML_INTERN("to_datetime"));
}

//.........这里部分代码省略.........
    int64_t domainLoNSecs = this->domainLo % MILLISECOND_NS;
    if (domainLoNSecs < 0)
    {
        domainLoMSecs -= 1;
        domainLoNSecs += MILLISECOND_NS;
    }

    int64_t starttime, prevstart;

    switch(granularity)
    {
    case Timescale::YEAR:
    {
        int yeardelta = (int) (deltatick / YEAR_NS);
        Q_ASSERT((deltatick % YEAR_NS) == 0);

        QDateTime date = QDateTime::fromMSecsSinceEpoch(domainLoMSecs - 1, this->tz);
        int curryear = ceildiv(date.date().year(), yeardelta) * yeardelta;
        date.setDate(QDate(curryear, 1, 1));
        date.setTime(QTime());

        if (domainLoMSecs == date.toMSecsSinceEpoch() && domainLoNSecs > 0)
        {
            date = date.addYears(yeardelta);
        }

        /* TODO: this multiplication might overflow */
        starttime = date.toMSecsSinceEpoch() * MILLISECOND_NS;
        prevstart = starttime;

        /* This is the lowest granularity, so we need to check for overflow. */
        while (starttime <= this->domainHi && starttime >= prevstart)
        {
            ticks.append({ starttime, getTimeTickLabel(starttime, date, granularity, !this->promoteTicks) });
            date = date.addYears(yeardelta);
            prevstart = starttime;
            starttime = date.toMSecsSinceEpoch() * MILLISECOND_NS;
        }
        break;
    }
    case Timescale::MONTH:
    {
        int monthdelta = (int) (deltatick / MONTH_NS);
        Q_ASSERT((deltatick % MONTH_NS) == 0);

        QDateTime date = QDateTime::fromMSecsSinceEpoch(domainLoMSecs - 1, this->tz);
        date.setTime(QTime());

        /* currmonth is an int from 0 to 11. */
        int currmonth = ceildiv(date.date().month() - 1, monthdelta) * monthdelta;
        int curryear = date.date().year() + (currmonth / 12);
        currmonth %= 12;
        date.setDate(QDate(curryear, currmonth + 1, 1));
        date.setTime(QTime());

        if (domainLoMSecs == date.toMSecsSinceEpoch() && domainLoNSecs > 0)
        {
            date = date.addMonths(monthdelta);
        }

        starttime = date.toMSecsSinceEpoch() * (int64_t) MILLISECOND_NS;
        prevstart = starttime;
        while (starttime <= this->domainHi && starttime >= prevstart)
        {
            ticks.append({ starttime, getTimeTickLabel(starttime, date, granularity, !this->promoteTicks) });
            date = date.addMonths(monthdelta);
            prevstart = starttime;
            starttime = date.toMSecsSinceEpoch() * (int64_t) MILLISECOND_NS;
        }
        break;
    }
    default:
        starttime = ceildiv(this->domainLo, (int64_t) deltatick) * deltatick;
        if (granularity == Timescale::DAY || granularity == Timescale::HOUR)
        {
            /* I'm assuming that the timezone offset is never in smaller granularity than minutes. */
            QDateTime d = QDateTime::fromMSecsSinceEpoch(ceildiv(starttime, MILLISECOND_NS), this->tz);
            starttime -= SECOND_NS * (int64_t) d.offsetFromUtc();
            while (starttime > this->domainLo)
            {
                starttime -= deltatick;
            }
            while (starttime < this->domainLo)
            {
                starttime += deltatick;
            }
        }
        prevstart = starttime;
        while (starttime <= this->domainHi && starttime >= prevstart) {
            // Add the tick to ticks
            QDateTime date = QDateTime::fromMSecsSinceEpoch(ceildiv(starttime, MILLISECOND_NS), this->tz);
            ticks.append({ starttime, getTimeTickLabel(starttime, date, granularity, !this->promoteTicks) });
            prevstart = starttime;
            starttime += deltatick;
        }
        break;
    }

    return ticks;
}