statuschange.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.8 $

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

// ************************************************************************
// included header files
// + standard includes
#include <set>

// + libraries

// + local headers
#include "status.h"
#include "period.h"

// + class declarations
namespace OSB_DB {
    class StatusChangeGw;
}

namespace OSB_LIB {
    class StatusRequest;
}

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

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

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

// ************************************************************************
// class definitions
    class StatusChange {
        friend class OSB_DB::StatusChangeGw;

    public:
        typedef Id<StatusChange> Oid;

        // defined below
        class GeValidFrom;

    public:
        explicit StatusChange(
            const Oid& oid = Oid()
        );

    public:
        const Oid oid() const;

        void adjustNewStatus(
            const Status& prefStatus
        );

        GeValidFrom geValidFrom() const;

        bool read(
            const OSB_DB::Session& session
        );

        std::ostream& write(std::ostream& os) const;

    private:
        Oid oid_;
    public:
        Id<StatusRequest> requestId_;
        StatusValue oldStatus_;
        StatusValue newStatus_;
        StatusReason::Oid reasonId_;
        DateTime validFrom_;
    };                                  // class StatusChange

    class StatusChange::GeValidFrom {
    public:
        GeValidFrom(const DateTime& rhs);
        bool operator()(const StatusChange& lhs);
    private:
        const DateTime rhs_;
    };                              // class StatusRequest::GeValidFrom

    std::ostream& operator<<(std::ostream&       os,
                             const StatusChange& sc);

    class StatusChanges {
        friend class OSB_DB::StatusChangeGw;
    public:
        struct Cmp {
            bool operator()(
                const StatusChange& lhs,
                const StatusChange& rhs
            ) const;
        };
    public:
        typedef std::set<StatusChange, Cmp> Cont;
        typedef Cont::const_iterator ConstIter;
        typedef Cont::const_reverse_iterator ConstRiter;

    public:
        StatusChanges();

        StatusChanges(
            const Period& period
        );

    public:
        const Period& period() const;

        bool empty() const;
        size_t size() const;

        ConstIter begin() const;
        ConstIter end() const;
        ConstRiter rbegin() const;
        ConstRiter rend() const;

        const Cont& changes() const;

        template<typename Pred>
        size_t countIf(Pred pred) const;

        void setPeriod(
            const Period& period
        );

        void clear();

        void add(
            const StatusChanges& rhs
        );

        void swap(StatusChanges& rhs) throw();

    private:
        Period period_;
        Cont changes_;
    };                                  // class StatusChanges
}                                       // namespace OSB_LIB

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

    // ********************************************************************
    // StatusChange
    inline StatusChange::StatusChange(
        const Oid& oid
    ) : oid_(oid), oldStatus_(svNone), newStatus_(svNone)
    {
        // empty
    }

    inline const StatusChange::Oid StatusChange::oid() const
    {
        return oid_;
    }

    inline void StatusChange::adjustNewStatus(
        const Status& pref
    )
    {
        newStatus_ = mkChildStatus(newStatus_, pref.status());
    }

    inline bool StatusChange::GeValidFrom::operator()(
        const StatusChange& lhs
    )
    {
        return lhs.validFrom_ >= rhs_;
    }

    // ********************************************************************
    // StatusChanges
    inline StatusChanges::StatusChanges()
    {
        // empty
    }

    inline StatusChanges::StatusChanges(
        const Period& period
    ) : period_(period)
    {
        // empty
    }

    inline const Period& StatusChanges::period() const
    {
        return period_;
    }

    inline bool StatusChanges::empty() const
    {
        return changes_.empty();
    }

    inline size_t StatusChanges::size() const
    {
        return changes_.size();
    }

    inline const StatusChanges::Cont& StatusChanges::changes() const
    {
        return changes_;
    }

    inline StatusChanges::ConstIter StatusChanges::begin() const
    {
        return changes_.begin();
    }

    inline StatusChanges::ConstIter StatusChanges::end() const
    {
        return changes_.end();
    }

    inline StatusChanges::ConstRiter StatusChanges::rbegin() const
    {
        return changes_.rbegin();
    }

    inline StatusChanges::ConstRiter StatusChanges::rend() const
    {
        return changes_.rend();
    }

    template<typename Pred>
    inline size_t StatusChanges::countIf(Pred pred) const
    {
        return std::count_if(begin(), end(), pred);
    }

    inline bool StatusChanges::Cmp::operator()(
        const StatusChange& lhs,
        const StatusChange& rhs
    ) const
    {
        if (lhs.validFrom_ < rhs.validFrom_) return true;
        if (lhs.validFrom_ > rhs.validFrom_) return false;
        return lhs.oid() < rhs.oid();
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _STATUSCHANGE_H_

---