roundrule.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Vipul Gupta (vg)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.43 $

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

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

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

// *********************************************************************
// class declarations
namespace OSB_DB {
    class Session;
}

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

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

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

    class RoundRule
    {
    public:
        typedef Id<RoundRule> Oid;

        typedef std::auto_ptr<RoundRule> AutoPtr;

        enum Type {
            rr_unknown   = 0,     
            rr_roundUp   = 1,
            rr_dontRound = 2
        };

        RoundRule(const Oid& id): id_(id) {}
        RoundRule(const Oid&          id,
                  const std::string& name,
                  const std::string& des
                 ) : id_(id), name_(name), des_(des) {}
        virtual ~RoundRule() {}
        virtual Decimal operator()(const Decimal&) const =0;
        Decimal round(const Decimal& d) const { return operator()(d); }



        const Oid& oid() const { return id_; }
        const std::string& name() const { return name_; }
        const std::string& des() const { return des_; }



        void setName(const std::string& name);
        void setDes(const std::string& des);

        AutoPtr clone() const;

        template<typename R> R* isa(R*& ptr);
        template<typename R> const R* isa(R*& ptr) const;

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

    private:
        virtual RoundRule* clone_() const = 0;
    };

    class RoundUp : public RoundRule
    {
    public:
        // Documentation from base class.
        typedef std::auto_ptr<RoundUp> AutoPtr;

        RoundUp(const Oid&          id,
                const Decimal&     threshold,
                const Decimal&     multiple);
        RoundUp(const Oid&          id,
                const std::string& name,
                const std::string& des,
                const Decimal&     threshold,
                const Decimal&     multiple);

        Decimal operator()(const Decimal& d) const;



        const Decimal& threshold() const { return threshold_; }
        const Decimal& multiple() const { return multiple_; }

        // Documentation from base class.
        AutoPtr clone() const;

    private:
        Decimal threshold_;   
        Decimal multiple_;    

    private:
        // Documentation from base class.
        virtual RoundRule* clone_() const;
    };

    class DontRound : public RoundRule
    {
    public:
        // Documentation from base class.
        typedef std::auto_ptr<DontRound> AutoPtr;

        DontRound(const Oid&          id) : RoundRule(id) {};
        DontRound(const Oid&          id,
                  const std::string& name,
                  const std::string& des
                 ) : RoundRule(id, name, des) {};

        Decimal operator()(const Decimal& d) const { return d; }

        // Documentation from base class.
        AutoPtr clone() const;

    private:
        // Documentation from base class.
        virtual RoundRule* clone_() const;
    };

    class RoundRuleList {
    public:


        typedef std::vector<RoundRule*> List;
        typedef List::iterator Iterator;
        typedef List::const_iterator ConstIterator;
        typedef List::size_type SizeType;

        RoundRuleList() {};

        RoundRuleList(const RoundRuleList& rhs);

        RoundRuleList& operator=(const RoundRuleList& rhs);

        ~RoundRuleList();


        Iterator begin() { return list_.begin(); }
        Iterator end() { return list_.end(); }
        ConstIterator begin() const { return list_.begin(); }
        ConstIterator end() const { return list_.end(); }
        SizeType size() const { return list_.size(); }
        void swap(RoundRuleList& rhs);

        void push_back(const RoundRule& rr);

        void push_back(RoundRule::AutoPtr ap);

        Iterator erase(Iterator pos);

        void clear();

        const List& list() const { return list_; }

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

        const RoundRule* findRoundRule(const RoundRule::Oid& oid) const;

        const RoundRule& getRoundRule(const RoundRule::Oid& oid) const;

        RoundRule::Oid getRoundRuleByName(const std::string& name) const;

    private:
        List list_;
    };

    // *****************************************************************
    // RoundRuleFactory
    class RoundRuleFactory {
    public:
        static RoundRule::AutoPtr create(
            const RoundRule::Type& type,
            const RoundRule::Oid&   oid,
            const Decimal&         threshold,
            const Decimal&         multiple
        );

        static RoundRule::AutoPtr create(
            const RoundRule::Type& type,
            const RoundRule::Oid&  oid,
            const std::string&     name,
            const std::string&     desc,
            const Decimal&         threshold,
            const Decimal&         multiple
        );

    private:
        RoundRuleFactory();
        RoundRuleFactory(const RoundRuleFactory& rhs);
    };


// *********************************************************************
// template definitions

    // *****************************************************************
    // RoundRule
    template<typename R> R* RoundRule::isa(R*& ptr)
    {
        ptr = dynamic_cast<R*>(this);
        return ptr;
    }

    template<typename R> const R* RoundRule::isa(R*& ptr) const
    {
        ptr = dynamic_cast<const R*>(this);
        return ptr;
    }


}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ROUNDRULE_H_

---