FsfFilter.h

Go to the documentation of this file.

/*
  FSF: Flow Scheduling Framework library
  
  Version 1.0 Copyright (C) 2010 Alexandre R.J. Francois

  Previous versions Copyright (C) 2001-2005 University of Southern California

  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  www.alexandrefrancois.org

  Modular Flow Scheduling Middleware
  mfsm.sourceForge.net
  
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef FSF_FILTER_H
#define FSF_FILTER_H

// no local lock mechanism !

#include <list>

#include "FsfNode.h"
#include "FsfPulse.h"
#include "FsfHandle.h"

namespace fsf{


    class CFilter{
    private:
        std::string m_strName; 
        bool m_bWildcard; 
        long m_nFilterID; 
        bool m_bOptional; 

        void setWildcardFlag() { m_bWildcard=(m_strName.find_first_of("*?[]")!=std::string::npos); }

    protected:
        


        const std::string &getName() const { return m_strName; }
        bool hasWildcard() const { return m_bWildcard; }

    public:


        CFilter() : m_bWildcard(false), m_nFilterID(-1), m_bOptional(false) {}
        CFilter(const std::string &strName, long nFilterID=-1, bool bOptional=false)
            : m_strName(strName), m_nFilterID(nFilterID), m_bOptional(bOptional) { setWildcardFlag(); }
        CFilter(const CFilter &f);
        virtual ~CFilter() {}
        


        void getName(std::string &strName) const { strName.assign(m_strName); }
        long getFilterID() const { return m_nFilterID; }
        bool isOptional() const { return m_bOptional; }



        void setName(const std::string &strName) { m_strName.assign(strName); setWildcardFlag(); }
        void setFilterID(long nFilterID) { m_nFilterID=nFilterID; }
        bool setOptional(bool bOptional=true) { return (m_bOptional=bOptional); }
    };
    
    typedef std::list<CPassiveHandle*> PassiveHandleList;
    class CPassiveFilterBase;
    typedef std::list<CPassiveFilterBase*> PassiveFilterList;
    

    class CPassiveFilterBase : public CFilter {
    private:
        PassiveFilterList m_listChildren; 
    public:


        CPassiveFilterBase() : CFilter() {}
        CPassiveFilterBase(const std::string &strName, long nFilterID=-1, bool bOptional=false)
            : CFilter(strName,nFilterID,bOptional) {}
        CPassiveFilterBase(const CPassiveFilterBase &f);
        virtual ~CPassiveFilterBase();
        virtual CPassiveFilterBase *clone() const =0;



        bool hasChildren() { return (!m_listChildren.empty()); }
        void getChildren(std::list<CPassiveFilterBase*> &listFilters) { if(!m_listChildren.empty()) listFilters.insert(listFilters.end(),m_listChildren.begin(),m_listChildren.end()); }



        void addChild(CPassiveFilterBase *pFilter) { m_listChildren.push_back(pFilter); }




        virtual bool testType(CNode *pNode) { return false; }
        virtual bool testExact(CNode *pNode) { return (testType(pNode) && (pNode->testNameExact(getName()))); }
        virtual bool testWildcard(CNode *pNode) { return (testType(pNode) && (pNode->testNameWildcard(getName()))); }
        virtual bool test(CNode *pNode) { return (hasWildcard())?(testWildcard(pNode)):(testExact(pNode)); }




        bool filter(PassiveHandleList &listHandles, CPassiveHandle *pRootHandle);
        bool matchNode(CPassiveHandle *pNHandle);
        static bool matchListList(PassiveHandleList &listHandles, PassiveFilterList &listFilter, PassiveHandleList &listRHandles, PassiveHandleList &listNHandles);
        bool matchList(PassiveHandleList &listHandles, PassiveHandleList &listRHandles, PassiveHandleList &listNHandles);
        
    };
    
    template <class N> class CPassiveFilter : public CPassiveFilterBase {
    public:


        CPassiveFilter() : CPassiveFilterBase() {}
        CPassiveFilter(const std::string &strName, long nFilterID=-1, bool bOptional=false)
            : CPassiveFilterBase(strName,nFilterID,bOptional) {}
        CPassiveFilter(const CPassiveFilter &f) : CPassiveFilterBase(f) {}
        // virtual ~CPassiveFilter();
        virtual CPassiveFilterBase *clone() const { return new CPassiveFilter<N>(*this); }
        


        virtual bool testType(CNode *pNode) { return (dynamic_cast<N*>(pNode)!=NULL); }
    };
    
    typedef std::list<CActiveHandle*> ActiveHandleList;
    class CActiveFilterBase;
    typedef std::list<CActiveFilterBase*> ActiveFilterList;
    
    class CActiveFilterBase : public CFilter {
    private:
        std::list<CActiveFilterBase*> m_listChildren; 
        
    public:


        CActiveFilterBase() : CFilter() {}
        CActiveFilterBase(const std::string &strName, long nFilterID=-1, bool bOptional=false)
            : CFilter(strName,nFilterID,bOptional) {}
        CActiveFilterBase(const CActiveFilterBase &f);
        virtual ~CActiveFilterBase();
        virtual CActiveFilterBase *clone() const =0;



        void getChildren(std::list<CActiveFilterBase*> &listFilters) { listFilters.insert(listFilters.end(),m_listChildren.begin(),m_listChildren.end()); }




        void addChild(CActiveFilterBase *pFilter) { m_listChildren.push_back(pFilter); }        



        virtual bool testType(CNode *pNode) { return false; }
        


        bool filter(ActiveHandleList &listHandles, CNode *pRoot);
        bool filterExact(ActiveHandleList &listHandles, CNode *pRoot);
        bool filterWildcard(ActiveHandleList &listHandles, CNode *pRoot);
        
        bool matchInRootListExact(ActiveHandleList &listHandles, std::list<CNode*> &listNodes);
        bool matchInRootListWildcard(ActiveHandleList &listHandles, std::list<CNode*> &listNodes);
        bool matchInRootList(ActiveHandleList &listHandles, std::list<CNode*> &listNodes) { return (hasWildcard())?(matchInRootListWildcard(listHandles,listNodes)):(matchInRootListExact(listHandles,listNodes)); }
        
        bool matchInListExact(ActiveHandleList &listHandles, std::list<CNode*> &listNodes, std::list<CNode*>::iterator &it);
        bool matchInListWildcard(ActiveHandleList &listHandles, std::list<CNode*> &listNodes, std::list<CNode*>::iterator &it);
        bool matchInList(ActiveHandleList &listHandles, std::list<CNode*> &listNodes, std::list<CNode*>::iterator &it) { return (hasWildcard())?(matchInListWildcard(listHandles,listNodes,it)):(matchInListExact(listHandles,listNodes,it)); }
        bool matchInListExact(ActiveHandleList &listHandles, std::list<CNode*> &listNodes);
        bool matchInListWildcard(ActiveHandleList &listHandles, std::list<CNode*> &listNodes);
        bool matchInList(ActiveHandleList &listHandles, std::list<CNode*> &listNodes) { return (hasWildcard())?(matchInListWildcard(listHandles,listNodes)):(matchInListExact(listHandles,listNodes)); }
        
        bool matchNodeExact(ActiveHandleList &listHandles, CNode *pNode);
        bool matchNodeWildcard(ActiveHandleList &listHandles, CNode *pNode);
        bool matchSubnodes(std::list<CActiveFilterBase*> &listFilters, std::list<CNode*> &listNodes, ActiveHandleList &listHandles);
        bool matchNode(ActiveHandleList &listHandles, CNode *pNode) { return (hasWildcard())?(matchNodeWildcard(listHandles,pNode)):(matchNodeExact(listHandles,pNode)); }


    };
    
    template <class N> class CActiveFilter : public CActiveFilterBase {
    public:


        CActiveFilter() : CActiveFilterBase() {}
        CActiveFilter(const std::string &strName, long nFilterID=-1, bool bOptional=false)
            : CActiveFilterBase(strName,nFilterID,bOptional) {}
        CActiveFilter(const CActiveFilter &f) : CActiveFilterBase(f) {}
        // virtual ~CActiveFilter();
        virtual CActiveFilterBase *clone() const { return new CActiveFilter<N>(*this); }



        virtual bool testType(CNode *pNode) { return (dynamic_cast<N*>(pNode)!=NULL); }
    };
    
    
//     /// \ingroup Filters
//     /// Helper class for active filtering
//     class CActiveMatch{
//     protected:
//      CActiveFilterBase *m_pFilter;
//      CActiveHandle *m_pHandle;
//     public:
//      CActiveMatch(CActiveFilterBase *pFilter, CActiveHandle *pHandle)
//          : m_pFilter(pFilter), m_pHandle(pHandle) {}
//      CActiveHandle *makeHandle() { return new CActiveHandle(m_pHandle->getNode(),m_pFilter->getFilterID()); }
//     };
    
//     typedef std::list<CActiveMatch*> ActiveMatchList;

    
    
} // namespace fsf

#endif // FSF_FILTER_H

---