status.h

Go to the documentation of this file.

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

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.57 $

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

// ************************************************************************
// included header files
// + standard includes
#include <iosfwd>
#include <string>
#include <list>

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

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

namespace OSB_LIB {
    class StatusChange;
}

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

// ************************************************************************
// forward declarations
    class Status;                       // needed for toChar(const Status&)

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

    enum StatusValue {
        svNone        =  0,
        svDeactivated =  1,
        svCreated     =  2,
        svInactive    =  3,
        svActive      =  4
    };

    char toChar(StatusValue sv);

    char toChar(const Status& s);

    StatusValue statusValue(char c);

    std::ostream& operator<<(std::ostream& o, StatusValue sv);

    bool compatibleStatus(StatusValue parent, StatusValue child);

    StatusValue mkChildStatus(
        StatusValue parentEffStatus,
        StatusValue childPrefStatus
    );

    bool allowed(StatusValue from, StatusValue to);

// ************************************************************************
// class definitions

    class StatusReason {
        friend class OSB_DB::StatusReasonGw;
    private:
        static const long creationId_ = 1;

    public:
        typedef Id<StatusReason> Oid;

        enum Applicable {
            notDefined      = -1,       
            associate       =  1,       
            contract        =  2,       
            persProduct     =  4,       
            persProductNode =  8,       
            all             = 15        
        };

    public:
        StatusReason(const Oid& oid) :
            oid_(oid), applies_(notDefined),
            oldStatus_(svNone), newStatus_(svNone) {}
    public:
        static Oid creation()
        {
            return Oid(creationId_);
        }
    public:

        const Oid& oid() const
        {
            return oid_;
        }
        const std::string& name() const
        {
            return name_;
        }
        const std::string& des()  const
        {
            return des_;
        }
        StatusValue oldStatus() const
        {
            return oldStatus_;
        }
        StatusValue newStatus() const
        {
            return newStatus_;
        }

        bool operator==(const StatusReason& rhs)
        {
            return oid_ == rhs.oid_;
        }

    private:
        Oid         oid_;               
        std::string name_;              
        std::string des_;               

        Applicable  applies_;
        StatusValue oldStatus_;         
        StatusValue newStatus_;         
    };

    class StatusReasons {
    public:


        typedef std::list<StatusReason> Cont;
        typedef Cont::iterator Iterator;
        typedef Cont::const_iterator ConstIterator;
        typedef Cont::size_type SizeType;

    public:

        Iterator begin()
        {
            return reasons_.begin();
        }
        Iterator end()
        {
            return reasons_.end();
        }
        ConstIterator begin() const
        {
            return reasons_.begin();
        }
        ConstIterator end() const
        {
            return reasons_.end();
        }
        SizeType size() const
        {
            return reasons_.size();
        }

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

        void add(const StatusReason& reason)
        {
            return reasons_.push_back(reason);
        }

        const Cont& reasons() const
        {
            return reasons_;
        }

        const StatusReason* find(const StatusReason::Oid& oid);

        const StatusReason& get(const StatusReason::Oid& oid);

        bool get(StatusReason&            dest,
                 const StatusReason::Oid& oid);

    private:
        Cont reasons_;
    };                                  // class StatusReasons

    // ********************************************************************
    // TheStatusReasons
    class TheStatusReasons {
    public:
        static StatusReasons& instance();

    private:
        TheStatusReasons();
        TheStatusReasons(const TheStatusReasons& rhs);

        static StatusReasons* instance_;
    };                                  // TheStatusReasons

    class Status {
    public:
        Status();
        Status(
                  StatusValue        status,
            const StatusReason::Oid& reason
        );

    public:
        StatusValue status() const;
        StatusReason::Oid reason() const;

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

        bool operator==(const Status& rhs) const;

        bool operator==(const StatusReason::Oid& rhs) const;

        bool operator!=(const Status& rhs) const;

        bool changeStatus(
                  StatusValue        newStatus,
            const StatusReason::Oid& reasonId
        );

        bool changeStatus(const Status& newStatus);

        bool changeStatus(const StatusChange& sc);

    private:
        StatusValue status_;
        StatusReason::Oid reasonId_;
    };                                  // class Status

    std::ostream& operator<<(std::ostream& os,
                             const Status& s);
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    // ********************************************************************
    // Status
    inline Status::Status()
      : status_(svNone)
    {
        // empty
    }

    inline StatusValue Status::status() const
    {
        return status_;
    }

    inline StatusReason::Oid Status::reason() const
    {
        return reasonId_;
    }

    inline bool Status::operator==(const Status& rhs) const
    {
        return (   status_   == rhs.status_
                && reasonId_ == rhs.reasonId_);
    }

    inline bool Status::operator==(const StatusReason::Oid& rhs) const
    {
        return (reasonId_ == rhs);
    }

    inline bool Status::operator!=(const Status& rhs) const
    {
        return !(*this == rhs);
    }

    inline bool Status::changeStatus(
        const Status& newStatus
    )
    {
        return changeStatus(newStatus.status_,
                            newStatus.reasonId_);
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _STATUS_H_

---