statusrequest.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.22 $

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

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

// + libraries

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

// + class declarations
namespace OSB_DB {
    class StatusRequestGw;
    class Session;
}

namespace {
    struct StatusRequestRow;            // used in statusrequest-gw.h
}

namespace OSB_LIB {
    class RequestHandler;
}

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

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

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

// ************************************************************************
// class definitions
    class StatusRequest {
        friend class OSB_DB::StatusRequestGw;
        friend class RequestHandler;
        friend struct ::StatusRequestRow;

    public:
        typedef Id<StatusRequest> Oid;

        // defined below
        class GeValidFrom;

        enum Cascade {
            cscdNone = 0,
            cscdOwner = 1,
            cscdByParent = 2
        };
    public:
        explicit StatusRequest(const Oid& oid = Oid());
        StatusRequest(
            const StatusValue        s,
            const StatusReason::Oid& r
        );

    public:


        const Oid oid() const;
        const Status& status() const;
        const StatusValue reqStatus() const;
        const StatusReason::Oid reason() const;
        Cascade cascade() const;
        const DateTime& validFrom() const;
        const DateTime& applied() const;
        const DateTime& entered() const;
        const std::string& errCode() const;

        GeValidFrom geValidFrom() const;



        void setReqStatus(const Status& status);
        void setCascade(Cascade cascade);
        void setValidFrom(const DateTime& validFrom);

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

        void updApplied(
            const OSB_DB::Session& session,
                  bool             noWait
        );

    private:
        void read(
            const OSB_DB::Session& session,
                  bool             lockFirst
        );

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

        static void lock(
            const OSB_DB::Session& session,
            const Oid&             id,
                  bool             noWait
        );

        void lock(
            const OSB_DB::Session& session,
                  bool             noWait
        ) const;

        static void handleObjectStatus(
                  ObjectStatus os,
            const Oid&         id
        );

        void incObjVs(const OSB_DB::Session& session);

    private:
        Oid oid_;
        long objVs_;
        Status reqStatus_;
        Cascade cascade_;
        DateTime validFrom_;
        DateTime applied_;
        DateTime entered_;
        std::string errCode_;
    };                                  // class StatusRequest

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

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

    public:
        StatusRequests();

        StatusRequests(
            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 StatusRequest& last() const;
        const StatusRequest& first() const;

        const Cont& requests() const;

        void setPeriod(
            const Period& period
        );

        const StatusRequest* getReqStatus(
            const OSB_LIB::DateTime& ts
        ) const;

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

        void swap(StatusRequests& rhs) throw();

    private:
        Period period_;
        Cont requests_;
    };                                  // class StatusRequests
}                                       // namespace OSB_LIB

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

    // ********************************************************************
    // class StatusRequest
    inline const StatusRequest::Oid StatusRequest::oid() const
    {
        return oid_;
    }

    inline const Status& StatusRequest::status() const
    {
        return reqStatus_;
    }

    inline StatusRequest::Cascade StatusRequest::cascade() const
    {
        return cascade_;
    }

    inline const DateTime& StatusRequest::validFrom() const
    {
        return validFrom_;
    }

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

    // ********************************************************************
    // class StatusRequests
    inline bool StatusRequests::empty() const
    {
        return requests_.empty();
    }

    inline size_t StatusRequests::size() const
    {
        return requests_.size();
    }

    inline StatusRequests::ConstIter StatusRequests::begin() const
    {
        return requests_.begin();
    }

    inline StatusRequests::ConstIter StatusRequests::end() const
    {
        return requests_.end();
    }

    inline StatusRequests::ConstRiter StatusRequests::rbegin() const
    {
        return requests_.rbegin();
    }

    inline StatusRequests::ConstRiter StatusRequests::rend() const
    {
        return requests_.rend();
    }

    inline bool StatusRequests::Cmp::operator()(
        const StatusRequest& lhs,
        const StatusRequest& rhs
    ) const
    {
        if (lhs.validFrom() < rhs.validFrom()) return true;
        if (lhs.validFrom() > rhs.validFrom()) return false;
        return lhs.oid() < rhs.oid();
    }

    template<typename Pred>
    inline size_t StatusRequests::countIf(Pred pred) const
    {
        return std::count_if(begin(), end(), pred);
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _STATUSREQUEST_H_

---