Clock.h

Go to the documentation of this file.

/*
 * Clock.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 *
 * 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 CLOCK_H_
#define CLOCK_H_

#include <sys/time.h>

#include "ibrdtn/data/Number.h"
#include "ibrdtn/data/Bundle.h"
#include "ibrdtn/data/BundleID.h"

#include <ibrcommon/MonotonicClock.h>

#ifdef __WIN32__

#ifndef timerclear
#define timerclear(a) \
        (a)->tv_set = 0; (a)->tv_usec = 0
#endif

#ifndef timeradd
#define timeradd(a, b, result) \
    do { \
        (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
        (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
        if ((result)->tv_usec >= 1000000L) { \
            ++(result)->tv_sec; \
            (result)->tv_usec -= 1000000L; \
        } \
    } while (0)
#endif

#ifndef timersub
#define timersub(a, b, result) \
    do { \
        (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
        (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
        if ((result)->tv_usec < 0) { \
            --(result)->tv_sec; \
            (result)->tv_usec += 1000000L; \
        } \
    } while (0)
#endif
#endif

namespace dtn
{
        namespace utils
        {
                class Clock
                {
                public:
                        static dtn::data::Timestamp getMonotonicTimestamp();

                        static dtn::data::Timestamp getTime();

                        static bool isExpired(const dtn::data::Timestamp &timestamp, const dtn::data::Number &lifetime);

                        static bool isExpired(const dtn::data::Bundle &b);

                        static bool isExpired(const dtn::data::MetaBundle &m);

                        static dtn::data::Timestamp getExpireTime(const dtn::data::Bundle &b);

                        static dtn::data::Timestamp getExpireTime(const dtn::data::Timestamp &timestamp, const dtn::data::Number &lifetime) __attribute__ ((deprecated));

                        static dtn::data::Timestamp getExpireTime(const dtn::data::Number &lifetime);

                        static void settimeofday(struct timeval *tv);

                        static void gettimeofday(struct timeval *tv);

                        static void getdtntimeofday(struct timeval *tv);

                        static void setOffset(const struct timeval &tv);

                        static const struct timeval& getOffset();

                        static const dtn::data::Timestamp TIMEVAL_CONVERSION;

                        static double getRating();

                        static void setRating(double val);

                        static bool shouldModifyClock();

                        static void setModifyClock(bool val);

                        static double toDouble(const timeval &val);

                        static dtn::data::Timestamp getUptime();

                private:
                        static double _rating;

                        static bool _modify_clock;

                        Clock();
                        virtual ~Clock();

                        static dtn::data::Timestamp __getExpireTime(const dtn::data::Timestamp &timestamp, const dtn::data::Number &lifetime);

                        static struct timeval _offset;
                        static bool _offset_init;

                        static ibrcommon::MonotonicClock _monotonic_clock;
                };
        }
}

#endif /* CLOCK_H_ */