period.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.12 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _PERIOD_H_
#define _PERIOD_H_

// ************************************************************************
// included header files
// + standard includes

// + libraries

// + local headers
#include "chrono.h"
#include "osberror.h"

// + class declarations

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// forward declarations

// ************************************************************************
// type definitions

// ************************************************************************
// class definitions
    class Period {
    public:
        struct Less {
            inline bool operator()(
                const Period& lhs,
                const Period& rhs
            );
        };                              // struct Less

        // defined below
        class Overlap;

    public:
        static Period infinite();

        explicit Period(
            const DateTime& ts = DateTime()
        );

        Period(const DateTime& from, const DateTime& to);

    public:


        DateTime from() const;
        DateTime to() const;
        bool isTimestamp() const;

        bool contains(const DateTime& ts) const;

        bool overlap(const Period& rhs) const;

        bool less(const Period& rhs) const;

    private:
        DateTime from_;
        DateTime to_;
        bool isTs_;
    };                                  // class Period

    class Period::Overlap : public OsbException {
        static ErrorNo errNo_;
    public:
        Overlap(
            const Period& lhs,
            const Period& rhs
        );
    public:
        const Period& lhs() const;
        const Period& rhs() const;
    private:
        Period lhs_;
        Period rhs_;
    };                                  // class Period::Overlap
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {

    // ********************************************************************
    // class Period
    inline Period Period::infinite()
    {
        return Period(DateTime::min(),
                      DateTime::max());
    }

    inline Period::Period(
        const DateTime& ts
    ) : from_(ts), to_(ts), isTs_(true)
    {
        // empty
    }

    inline DateTime Period::from() const
    {
        return from_;
    }

    inline DateTime Period::to() const
    {
        return to_;
    }

    inline bool Period::isTimestamp() const
    {
        return isTs_;
    }

    inline bool Period::contains(const DateTime& ts) const
    {
        // a time stamp can not contain another time stamp
        if (isTs_)       return false;
        // an unknown time stamp never is within a period
        if (ts.notSet()) return false;

        // note: if upper boundary of period is infinite
        //       then any ts is less than the upper boundary
        //       (except if not set, but this is handled above)
        return (   (from_ <= ts  || from_ == DateTime::min())
                && (ts    <  to_ || to_   == DateTime::max()));
    }

    inline bool Period::overlap(const Period& rhs) const
    {
        if (isTs_ || rhs.isTs_) return false;

        return contains(rhs.from_) || rhs.contains(from_);
    }

    inline bool Period::less(const Period& rhs) const
    {
        // lhs is TS, rhs is period or TS:
        // in both cases compare the from dates
        if      (isTs_)     return from_ <  rhs.from_;
        // lhs is period, rhs is TS
        else if (rhs.isTs_) return to_   <= rhs.from_;

        // two periods: check for overlap
        if (overlap(rhs)) {
            throw Overlap(*this, rhs);
        }

        return (from_ < rhs.from_);
    }

    // ********************************************************************
    // struct Period::Less
    inline bool Period::Less::operator()(
        const Period& lhs,
        const Period& rhs
    )
    {
        return lhs.less(rhs);
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _PERIOD_H_

---