filter.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Manikandan (mk)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.16 $

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

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

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

// ********************************************************************
// class declarations
namespace OSB_DB {
    class  Session;
    struct FilterGw;
    struct FilterVersionGw;
    struct FilterExprGw;
    struct FilterCondGw;
    struct ScFilterGw;
    struct TcFilterGw;
}

namespace OSB_LIB {
    class Cdr;
    class UsedService;
}

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

    class FilterManager;

// ********************************************************************
// class definitions
    enum FilterType
    {
        ftUnknown      = 0,
        ftServiceClass = 1,
        ftTariffClass  = 2
    };

    enum OperatorType
    {
        otUnknown    = 0,
        otEqualTo    = 1,
        otNotEqualTo = 2,
        otAnd        = 3,
        otOr         = 4,
        otXor        = 5,
        otNot        = 6
    };

    enum FilterAction
    {
        faUnknown  = 0,
        faDiscard  = 1,
        faFilter   = 2,
        faNoAction = 3
    };


    // *****************************************************************
    // class Filter
    class Filter
    {
        friend struct OSB_DB::FilterGw;
        friend class FilterManager;

    public:
        typedef Id<Filter> Oid;

        Filter(
            const std::string& name,
            const std::string& des
        );

        Filter(
            const Oid&         oid   = Oid(),
            const long&        objVs = 0,
            const std::string& name  = "",
            const std::string& des   = ""
        );



        bool setName(const std::string& name);

        bool setDes(const std::string& des);



        const Oid& oid() const;

        long objVs() const;

        const std::string& name() const;

        const std::string& des() const;

        void print();



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

    private:
        bool insert(const OSB_DB::Session& session);

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

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

        Oid oid_;

        long objVs_;

        std::string name_;

        std::string des_;
    };

    typedef std::vector<Filter> Filters;

    // ****************************************************************
    // class FilterCond
    class FilterCond
    {
        friend struct OSB_DB::FilterCondGw;

        friend class FilterManager;

    public:
        typedef Id<FilterCond> Oid;

        typedef std::auto_ptr<FilterCond> AutoPtr;

        FilterCond(const Oid& oid = Oid());

        FilterCond(
            const Oid&        oid,
            const FilterType  ft
        );

        virtual ~FilterCond();

        AutoPtr clone() const;

        virtual bool eval(
            const Cdr&         cdr,
            const UsedService& us
        ) = 0;



        const FilterCond::Oid& oid() const;

        long objVs() const;

        FilterType fType() const;

        CfgStatus status() const;

        const Date& releaseDate() const;




        bool setReleaseDate(const Date& date);

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

        virtual void print() = 0;



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

    private:
        bool insert(const OSB_DB::Session& session);

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

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


        virtual bool readSpecific(
            const OSB_DB::Session& session
        ) = 0;

        virtual bool insSpecific(
            const OSB_DB::Session& session
        ) = 0;

        virtual bool updSpecific(
            const OSB_DB::Session& session
        ) = 0;

        virtual bool removeSpecific(
            const OSB_DB::Session& session
        ) = 0;


        virtual FilterCond* clone_() const = 0;



        bool freeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool release(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool revoke(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool unfreeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool freezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        ) = 0;

        virtual bool releaseSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        ) = 0;

        virtual bool revokeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        ) = 0;

        virtual bool unfreezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        ) = 0;

        Oid oid_;

        FilterType   ft_;

        long objVs_;

        CfgStatus status_;

        Date releaseDate_;
    };

    struct FilterConds
    {


        typedef std::list<FilterCond*> List;

        typedef List::iterator Iterator;

        typedef List::const_iterator ConstIterator;

        typedef List::size_type SizeType;

        List items;

        FilterConds() {/*Empty*/};

        FilterConds(const FilterConds& rhs);

        FilterConds& operator=(const FilterConds& rhs);

        ~FilterConds();


        Iterator       begin();
        Iterator       end();
        ConstIterator begin() const;
        ConstIterator end() const;
        SizeType      size() const;
        void swap(FilterConds& rhs);

        void push_back(const FilterCond& fc);

        void push_back(FilterCond::AutoPtr fc);

        Iterator erase(Iterator pos);

        void clear();
    };

    // **************************************************************
    // class FilterExpr
    class FilterExpr
    {
        friend struct OSB_DB::FilterExprGw;

        friend class FilterManager;
    public:

        typedef Id<FilterExpr> Oid;

        FilterExpr(const FilterExpr::Oid& oid = Oid());

        FilterExpr(
            const Oid&             oid,
            const FilterCond::Oid& fcId,
            const FilterExpr::Oid& lhsfeId,
            const FilterExpr::Oid& rhsfeId,
                  OperatorType     op = otUnknown
        );

        ~FilterExpr();

        FilterExpr(FilterExpr& rhs);
        FilterExpr(const FilterExpr& rhs);

        bool eval(
            const Cdr& cdr,
            const UsedService& us
        );

        void build();



        const Oid& oid() const;

        long objVs() const;

        const FilterCond::Oid& fcId() const;

        const Oid& lhsfeId() const;

        const Oid& rhsfeId() const;

        OperatorType optype() const;

        CfgStatus status() const;

        const Date& releaseDate() const;




        bool setLhsFeId(const Oid& lhsId);

        bool setRhsFeId(const Oid& rhsId);

        bool setFcId(const FilterCond::Oid& fcId);

        bool setOperator(OperatorType op);

        bool setReleaseDate(const Date& date);

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

        void print();



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

    private:
        bool insert(const OSB_DB::Session& session);

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

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




        bool freeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool release(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool revoke(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool unfreeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        Oid oid_;

        FilterCond::Oid fcId_;

        FilterCond* fc_;

        FilterExpr::Oid lhsfeId_;

        FilterExpr* lhsfe_;

        FilterExpr::Oid rhsfeId_;

        FilterExpr* rhsfe_;

        OperatorType op_;

        long objVs_;

        CfgStatus status_;

        Date releaseDate_;
    };

    typedef std::vector<FilterExpr> FilterExprs;

    // ***************************************************************
    // class FilterVersion
    class FilterVersion
    {
        friend struct OSB_DB::FilterVersionGw;

        friend class FilterManager;
    public:
        typedef Id2<FilterVersion> Oid;

        typedef std::pair<FilterExpr,FilterAction> FeFaPair;

        typedef std::vector<FeFaPair> FExprs;

        FilterVersion(
            const Oid&         oid   = Oid(),
            const std::string& name  = ""
        );

        FilterAction eval(
            Cdr& cdr,
            UsedService& us
        );



        const Oid& oid() const;

        long objVs() const;

        const std::string& name() const;

        CfgStatus status() const;

        const Date& releaseDate() const;

        const FExprs& filterExprs() const;




        bool setName(const std::string& name );

        bool setReleaseDate(const Date& date);


        void print();

        void addFExpr(
            const FilterExpr::Oid& oid,
                  FilterAction     fa
        );

        void removeFExpr(const FilterExpr::Oid& oid);



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

    private:
        bool insert(const OSB_DB::Session& session);

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

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




        bool freeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool release(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool revoke(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        bool unfreeze(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        void build();

        Oid oid_;

        long objVs_;

        std::string name_;

        CfgStatus status_;

        Date releaseDate_;

        FExprs fexprs_;
    };

    typedef std::vector<FilterVersion> FilterVersions;

    // *************************************************************
    // class ScFilter
    class ScFilter : public FilterCond
    {
        friend struct OSB_DB::ScFilterGw;

        friend class FilterCondFactory;

        friend class FilterManager;

    public:

        typedef std::auto_ptr<ScFilter> AutoPtr;

        ScFilter(const Oid& oid);

        ScFilter(
            const Oid&          oid,
                  long          tId,
                  OperatorType  op
        );



        long targetId() const;

        OperatorType oType() const;




        bool setTargetId(long tId);

        bool setOperator(OperatorType op);


        virtual void print();

        bool eval(
            const Cdr& cdr,
            const UsedService& us
        );

        AutoPtr clone() const;
    private:


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

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

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

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




        virtual bool freezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool releaseSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool revokeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool unfreezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual FilterCond* clone_() const;

        OperatorType op_;

        long tId_;
    };

    // *************************************************************
    // class TcFilter
    class TcFilter : public FilterCond
    {
        friend struct OSB_DB::TcFilterGw;

        friend class FilterCondFactory;

        friend class FilterManager;

    public:

        typedef std::auto_ptr<TcFilter> AutoPtr;

        TcFilter(const Oid& oid);

        TcFilter(
            const Oid&         oid,
                  long         tId,
                  OperatorType op
        );



        long targetId() const;

        OperatorType oType() const;




        bool setTargetId(long tId);

        bool setOperator(OperatorType op);


        virtual void print();

        bool eval(
            const Cdr& cdr,
            const UsedService& us
        );

        AutoPtr clone() const;
    private:


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

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

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

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




        virtual bool freezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool releaseSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool revokeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual bool unfreezeSpecific(
            const OSB_DB::Session&       session,
                  std::vector<OsbError>& errors
        );

        virtual FilterCond* clone_() const;

        OperatorType op_;

        long tId_;
    };

    // *****************************************************************
    // class FilterCondFactory
    class FilterCondFactory
    {
        friend struct FilterCondGw;
    public:

        static FilterCond::AutoPtr create(
                  FilterType       ft,
            const FilterCond::Oid& oid,
                  long             targetId = 0,
                  OperatorType     op = otUnknown
        );
    };

    // *****************************************************************
    // class FilterManager
    class FilterManager
    {
    public:

        static FilterManager* getFilterManager();

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

        const Filter* findFilter(const Filter::Oid& oid);

        const Filter& getFilter(const Filter::Oid& oid);

        Filter::Oid creFilter(
            OSB_DB::Session& session,
            std::string&     name,
            std::string&     des
        );

        OsbError updFilter(
            OSB_DB::Session& session,
            Filter&          filt
        );

        void delFilter(
                  OSB_DB::Session& session,
            const Filter::Oid&     oid
        );

        const FilterVersion* findFilterVersion(
            const FilterVersion::Oid& oid
        );

        const FilterVersion& getFilterVersion(
            const FilterVersion::Oid& oid
        );

        FilterVersion::Oid creFilterVersion(
                  OSB_DB::Session& session,
            const Filter::Oid&     filtId,
            const std::string&     name
        );

        OsbError updFilterVersion(
            OSB_DB::Session& session,
            FilterVersion&   fv
        );

        void delFilterVersion(
                  OSB_DB::Session&    session,
            const FilterVersion::Oid& oid
        );

        size_t freezeFilterVersion(
                  OSB_DB::Session&       session,
            const FilterVersion::Oid&    oid,
                  std::vector<OsbError>& errors
        );

        size_t unfreezeFilterVersion(
                  OSB_DB::Session&       session,
            const FilterVersion::Oid&    oid,
                  std::vector<OsbError>& errors
        );

        size_t releaseFilterVersion(
                  OSB_DB::Session&       session,
            const FilterVersion::Oid&    oid,
                  std::vector<OsbError>& errors
        );

        size_t revokeFilterVersion(
                  OSB_DB::Session&       session,
            const FilterVersion::Oid&    oid,
                  std::vector<OsbError>& errors
        );
        const FilterExpr* findFilterExpr(const FilterExpr::Oid& oid);

        const FilterExpr& getFilterExpr(const FilterExpr::Oid& oid);

        FilterExpr::Oid creFilterExpr(
                  OSB_DB::Session& session,
            const FilterCond::Oid& fcId    = FilterCond::Oid(),
            const FilterExpr::Oid& lhsfeId = FilterExpr::Oid(),
            const FilterExpr::Oid& rhsfeId = FilterExpr::Oid(),
                  OperatorType     op      = otUnknown
        );

        OsbError updFilterExpr(
            OSB_DB::Session& session,
            FilterExpr&      fe
        );

        void delFilterExpr(
                  OSB_DB::Session& session,
            const FilterExpr::Oid& oid
        );

        size_t freezeFilterExpr(
                  OSB_DB::Session&       session,
            const FilterExpr::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t unfreezeFilterExpr(
                  OSB_DB::Session&       session,
            const FilterExpr::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t releaseFilterExpr(
                  OSB_DB::Session&       session,
            const FilterExpr::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t revokeFilterExpr(
                  OSB_DB::Session&       session,
            const FilterExpr::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        const FilterCond* findFilterCond(const FilterCond::Oid& oid);

        const FilterCond& getFilterCond(const FilterCond::Oid& oid);

        FilterCond::Oid creFilterCond(
            OSB_DB::Session& session,
            FilterType       ft,
            long             targetId,
            OperatorType     op
        );

        OsbError updFilterCond(
            OSB_DB::Session& session,
            FilterCond&      fc
        );

        void delFilterCond(
                  OSB_DB::Session& session,
            const FilterCond::Oid& oid
        );

        size_t freezeFilterCond(
                  OSB_DB::Session&       session,
            const FilterCond::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t unfreezeFilterCond(
                  OSB_DB::Session&       session,
            const FilterCond::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t releaseFilterCond(
                  OSB_DB::Session&       session,
            const FilterCond::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        size_t revokeFilterCond(
                  OSB_DB::Session&       session,
            const FilterCond::Oid&       oid,
                  std::vector<OsbError>& errors
        );

        void print();
    private:
        FilterManager();

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

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

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

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

        void buildFilterVersions();

        Filters filters_;

        FilterVersions filterVs_;

        FilterExprs filterexprs_;

        FilterConds filterconds_;

        static FilterManager* filtermgr_;
    };

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

}                                        // namespace OSB_LIRBARY
# endif                                  // #ifndef _FILTER_H_

---