TimeValueC.h

Go to the documentation of this file.

/*
// Copyright 2014 Sensics, Inc.
//
// Licensed 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.
*/

#ifndef INCLUDED_TimeValueC_h_GUID_A02C6917_124D_4CB3_E63E_07F2DA7144E9
#define INCLUDED_TimeValueC_h_GUID_A02C6917_124D_4CB3_E63E_07F2DA7144E9

/* Internal Includes */
#include <osvr/Util/APIBaseC.h>
#include <osvr/Util/AnnotationMacrosC.h>
#include <osvr/Util/BoolC.h>
#include <osvr/Util/Export.h>
#include <osvr/Util/PlatformConfig.h>
#include <osvr/Util/StdInt.h>

/* Library/third-party includes */
/* none */

/* Standard includes */
/* none */

OSVR_EXTERN_C_BEGIN

typedef int64_t OSVR_TimeValue_Seconds;
typedef int32_t OSVR_TimeValue_Microseconds;

typedef struct OSVR_TimeValue {
    OSVR_TimeValue_Seconds seconds;
    OSVR_TimeValue_Microseconds microseconds;
} OSVR_TimeValue;

#ifdef OSVR_HAVE_STRUCT_TIMEVAL

OSVR_UTIL_EXPORT void osvrTimeValueGetNow(OSVR_OUT OSVR_TimeValue *dest)
    OSVR_FUNC_NONNULL((1));

struct timeval; /* forward declaration */

OSVR_UTIL_EXPORT void
osvrTimeValueToStructTimeval(OSVR_OUT struct timeval *dest,
                             OSVR_IN_PTR const OSVR_TimeValue *src)
    OSVR_FUNC_NONNULL((1, 2));

OSVR_UTIL_EXPORT void
osvrStructTimevalToTimeValue(OSVR_OUT OSVR_TimeValue *dest,
                             OSVR_IN_PTR const struct timeval *src)
    OSVR_FUNC_NONNULL((1, 2));
#endif

OSVR_UTIL_EXPORT void osvrTimeValueNormalize(OSVR_INOUT_PTR OSVR_TimeValue *tv)
    OSVR_FUNC_NONNULL((1));

OSVR_UTIL_EXPORT void osvrTimeValueSum(OSVR_INOUT_PTR OSVR_TimeValue *tvA,
                                       OSVR_IN_PTR const OSVR_TimeValue *tvB)
    OSVR_FUNC_NONNULL((1, 2));

OSVR_UTIL_EXPORT void
osvrTimeValueDifference(OSVR_INOUT_PTR OSVR_TimeValue *tvA,
                        OSVR_IN_PTR const OSVR_TimeValue *tvB)
    OSVR_FUNC_NONNULL((1, 2));

OSVR_UTIL_EXPORT int osvrTimeValueCmp(OSVR_IN_PTR const OSVR_TimeValue *tvA,
                                      OSVR_IN_PTR const OSVR_TimeValue *tvB)
    OSVR_FUNC_NONNULL((1, 2));

OSVR_EXTERN_C_END

OSVR_INLINE double
osvrTimeValueDurationSeconds(OSVR_IN_PTR const OSVR_TimeValue *tvA,
                             OSVR_IN_PTR const OSVR_TimeValue *tvB) {
    OSVR_TimeValue A = *tvA;
    osvrTimeValueDifference(&A, tvB);
    double dt = A.seconds + A.microseconds / 1000000.0;
    return dt;
}

OSVR_INLINE OSVR_CBool
osvrTimeValueGreater(OSVR_IN_PTR const OSVR_TimeValue *tvA,
                     OSVR_IN_PTR const OSVR_TimeValue *tvB) {
    if (!tvA || !tvB) {
        return OSVR_FALSE;
    }
    return ((tvA->seconds > tvB->seconds) ||
            ((tvA->seconds == tvB->seconds) &&
             (tvA->microseconds > tvB->microseconds)))
               ? OSVR_TRUE
               : OSVR_FALSE;
}

#ifdef __cplusplus

#include <cassert>
#include <cmath>

inline bool osvrTimeValueIsNormalized(const OSVR_TimeValue &tv) {
#ifdef _LIBCPP_VERSION
    // libcxx has only floating-point abs and has several, so it makes this
    // ambiguous otherwise
    return std::abs(double(tv.microseconds)) < 1000000 &&
#else
    return (std::abs(tv.microseconds) < 1000000) &&
#endif
           (
               // zeros can be paired with a positive or negative
               (tv.seconds == 0) || (tv.microseconds == 0) ||
               // if both non-zero, then both must have same sign.
               ((tv.seconds > 0) == (tv.microseconds > 0)));
}

inline bool osvrTimeValueGreater(const OSVR_TimeValue &tvA,
                                 const OSVR_TimeValue &tvB) {
    assert(osvrTimeValueIsNormalized(tvA) &&
           "First timevalue argument to comparison was not normalized!");
    assert(osvrTimeValueIsNormalized(tvB) &&
           "Second timevalue argument to comparison was not normalized!");
    return (tvA.seconds > tvB.seconds) ||
           (tvA.seconds == tvB.seconds && tvA.microseconds > tvB.microseconds);
}

inline bool operator>(const OSVR_TimeValue &tvA, const OSVR_TimeValue &tvB) {
    return osvrTimeValueGreater(tvA, tvB);
}

inline bool operator<(const OSVR_TimeValue &tvA, const OSVR_TimeValue &tvB) {
    // Change the order of arguments before forwarding.
    return osvrTimeValueGreater(tvB, tvA);
}

inline bool operator==(const OSVR_TimeValue &tvA, const OSVR_TimeValue &tvB) {
    assert(
        osvrTimeValueIsNormalized(tvA) &&
        "First timevalue argument to equality comparison was not normalized!");
    assert(
        osvrTimeValueIsNormalized(tvB) &&
        "Second timevalue argument to equality comparison was not normalized!");
    return (tvA.seconds == tvB.seconds) &&
           (tvA.microseconds == tvB.microseconds);
}
inline bool operator!=(const OSVR_TimeValue &tvA, const OSVR_TimeValue &tvB) {
    assert(osvrTimeValueIsNormalized(tvA) && "First timevalue argument to "
                                             "inequality comparison was not "
                                             "normalized!");
    assert(osvrTimeValueIsNormalized(tvB) && "Second timevalue argument to "
                                             "inequality comparison was not "
                                             "normalized!");
    return (tvA.seconds != tvB.seconds) ||
           (tvA.microseconds != tvB.microseconds);
}
#endif

#endif