TimeValue.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_TimeValue_h_GUID_AD9F3D81_382D_4394_433B_A8026BE803B6
#define INCLUDED_TimeValue_h_GUID_AD9F3D81_382D_4394_433B_A8026BE803B6

// Internal Includes
#include <osvr/Util/TimeValueC.h>
#include <osvr/Util/TimeValue_fwd.h>

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

// Standard includes
#include <iomanip>
#include <sstream>

namespace osvr {
namespace util {
    namespace time {
        typedef ::OSVR_TimeValue TimeValue;

        inline void getNow(TimeValue &tv) { osvrTimeValueGetNow(&tv); }

        inline TimeValue getNow() {
            TimeValue tv;
            getNow(tv);
            return tv;
        }

        inline double duration(TimeValue const &a, TimeValue const &b) {
            return osvrTimeValueDurationSeconds(&a, &b);
        }

        inline std::string toDecimalString(TimeValue tv) {
            std::ostringstream os;
            osvrTimeValueNormalize(&tv);
            // Ensure we have only non-negative components, pulling out the
            // negatives. (Normalize ensures we have 0 or the same sign between
            // components)
            bool negative = false;
            if (tv.seconds < 0) {
                negative = true;
                tv.seconds *= -1;
            }
            if (tv.microseconds < 0) {
                negative = true;
                tv.microseconds *= -1;
            }
            // Output sign
            if (negative) {
                os << "-";
            }
            // Output seconds
            os << tv.seconds << ".";
            // set up decimal padding
            os << std::setw(6) << std::setfill('0');
            // Output microseconds
            os << tv.microseconds;

            return os.str();
        }

#ifdef OSVR_HAVE_STRUCT_TIMEVAL
        inline void toStructTimeval(struct timeval &dest,
                                    TimeValue const &src) {
            osvrTimeValueToStructTimeval(&dest, &src);
        }

        inline void fromStructTimeval(TimeValue &dest,
                                      struct timeval const &src) {
            osvrStructTimevalToTimeValue(&dest, &src);
        }

        inline TimeValue toTimeValue(struct timeval const &src) {
            TimeValue dest;
            osvrStructTimevalToTimeValue(&dest, &src);
            return dest;
        }
        inline TimeValue fromStructTimeval(struct timeval const &src) {
            return toTimeValue(src);
        }

#ifdef OSVR_STRUCT_TIMEVAL_INCLUDED
        inline struct timeval toStructTimeval(TimeValue const &src) {
            struct timeval dest;
            osvrTimeValueToStructTimeval(&dest, &src);
            return dest;
        }
#endif // OSVR_STRUCT_TIMEVAL_INCLUDED

#endif // OSVR_HAVE_STRUCT_TIMEVAL

    } // namespace time
} // namespace util
} // namespace osvr

#endif // INCLUDED_TimeValue_h_GUID_AD9F3D81_382D_4394_433B_A8026BE803B6