osbutils.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.58 $

  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 _OSBUTILS_H_
#define _OSBUTILS_H_

// *********************************************************************
// included header files
// + standard includes
#include<algorithm>
#include<functional>
#include<iosfwd>
#include<string>
#include<utility>

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

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

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

// *********************************************************************
// class declarations

    class EditStatus {
    public:
        enum Status {
            esUnchanged = 0x00,
            esModified  = 0x01,
            esCreated   = 0x02,
            esDeleted   = 0x04
        };

        EditStatus(Status status = esUnchanged);

        bool setRead() const;

        bool setCreated();

        bool setModified();

        bool changesDiscarded();

        bool setDeleted();

        bool setUndeleted();

        Status status() const;

    private:
        Status toStatus(int value) const;

        int status_;
    };

    // Identifier and a date
    template<typename I>
    struct IdDate{
        IdDate() : id(ID_NOT_SET) {}
        IdDate(long i, const Date& d) : id(i), dt(d) {}
        IdDate(long i, const std::string& d_str) : id(i), dt(d_str) {}
        bool notSet() const { return ID_NOT_SET == id; }
        bool isSet() const { return !notSet(); }
        bool operator==(const IdDate& rhs) const
            { return id == rhs.id && dt == rhs.dt; }
        bool operator<(const IdDate& rhs) const
            { return id == rhs.id ? dt < rhs.dt : id < rhs.id; }

        long id;
        Date dt;
    };

    // Identifier and a time period.
    // If only one date is given, the type represents a 'reference date'
    // and the comparison operators allow to search for the id/period
    // that contains a given reference date (eg, keys in STL containers)
    // Important: Two periods must not overlap!
    // ToDo: should use the type-safe id from above
    template<typename I>
    struct IdPeriod {
        IdPeriod() : id(ID_NOT_SET) {}
        IdPeriod(long i, const Date& d) : id(i), from(d), to(d) {}
        IdPeriod(long i, const std::string& d_str)
            : id(i), from(d_str), to(d_str) {}
        IdPeriod(long i, const Date& f, const Date& t)
            : id(i), from(std::min(f, t)), to(std::max(f, t)) {}
        IdPeriod(long i, const std::string& f_str,
                 const std::string& t_str)
            : id(i), from(std::min(Date(f_str), Date(t_str))),
              to(std::max(Date(f_str), Date(t_str))) {}
        inline bool notSet() const { return ID_NOT_SET == id; }
        bool isSet() const { return !notSet(); }
        inline bool operator==(const IdPeriod& rhs) const;
        inline bool operator!=(const IdPeriod& rhs) const;
        inline bool operator< (const IdPeriod& rhs) const;
        inline bool operator> (const IdPeriod& rhs) const;
        // ToDo: I'm not sure if <= and >= make sense
        inline bool operator<=(const IdPeriod& rhs) const;
        inline bool operator>=(const IdPeriod& rhs) const;

        long id;
        Date from;
        Date to;
    };

    // output operator for IdPeriod
    template<typename I>
    std::ostream& operator<<(std::ostream& o, IdPeriod<I> Id)
    {
        return o << Id.id << ','
                 << Id.from.str() << ','
                 << Id.to.str();
    }

    // Strict weak ordering for two objects by object identifiers.
    // Requires method oid()
    template<class T>
    struct LessOid : public std::binary_function<T, T, bool> {
        bool operator() (const T& x, const T& y) const
            { return x.oid() < y.oid(); }
    };

    // Specialization for pointers
    template<class T>
    struct LessOid<T*> : public std::binary_function<T*, T*, bool> {
        bool operator() (const T* x, const T* y) const
            { return x->oid() < y->oid(); }
    };

// *********************************************************************
// inline definitions

    // provided that the two ids are equal, then
    // + a period and a ref date are equal if the period contains
    //   the ref date
    // + two periods or ref dates are equal if they have the
    //   same boundaries
    template<typename I>
    inline bool IdPeriod<I>::operator==(const IdPeriod& rhs) const
    {
        if (id != rhs.id) return false;
        if (from == to && rhs.from != rhs.to) {
            return from >= rhs.from && from < rhs.to;
        }
        if (rhs.from == rhs.to && from != to) {
            return rhs.from >= from && rhs.from < to;
        }
        return from == rhs.from && to == rhs.to;
    }

    // provided that the two ids are equal, then
    // + a period is less than another period if its from date is less
    // + a ref date is less than a period if its from date is less
    // + a ref date is less than a ref date if its to/from dates are less
    // + a period is less than a ref date if its to date is less or equal
    template<typename I>
    inline bool IdPeriod<I>::operator<(const IdPeriod& rhs) const
    {
        if (id != rhs.id) return id < rhs.id;
        if (from != to && rhs.from == rhs.to) return to <= rhs.from;
        return from < rhs.from;
    }

    template<typename I>
    inline bool IdPeriod<I>::operator!=(const IdPeriod& rhs) const
    {
        return !(*this == rhs);
    }

    template<typename I>
    inline bool IdPeriod<I>::operator>(const IdPeriod& rhs) const
    {
        return rhs < *this;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _OSBUTILS_H_

---