platform/include/pion/platform/RuleChain.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Pion is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// Pion 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 Affero General Public License for
// more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Pion.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef __PION_RULECHAIN_HEADER__
#define __PION_RULECHAIN_HEADER__

#include <string>
#include <vector>
#include <libxml/tree.h>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Event.hpp>
#include <pion/platform/Vocabulary.hpp>
#include <pion/platform/Comparison.hpp>


namespace pion {        // begin namespace pion
namespace platform {    // begin namespace platform (Pion Platform Library)


class PION_PLATFORM_API RuleChain
{
public:

    class UnknownTermException : public PionException {
    public:
        UnknownTermException(const std::string& term)
            : PionException("Unable to find required Vocabulary term for Comparison rule: ", term) {}
    };

    class EmptyTermException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Comparison rule configuration is missing a term identifier";
        }
    };

    class EmptyTypeException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Comparison rule configuration does not include a comparison type";
        }
    };

    class EmptyValueException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Comparison rule configuration is missing a required comparison value";
        }
    };
    

    RuleChain(void) {}

    virtual ~RuleChain() {}

    virtual void setConfig(const pion::platform::Vocabulary& v, const xmlNodePtr config_ptr);
    
    virtual void updateVocabulary(const pion::platform::Vocabulary& v);

    inline bool operator()(const pion::platform::EventPtr& e) const;


private:

    typedef std::vector<pion::platform::Comparison>     ComparisonVector;


    static const std::string        COMPARISON_ELEMENT_NAME;
    
    static const std::string        TERM_ELEMENT_NAME;

    static const std::string        TYPE_ELEMENT_NAME;
    
    static const std::string        VALUE_ELEMENT_NAME;

    static const std::string        MATCH_ALL_VALUES_ELEMENT_NAME;
    
    static const std::string        MATCH_ALL_COMPARISONS_ELEMENT_NAME;


    ComparisonVector                m_comparisons;

    bool                            m_match_all_comparisons;
};


// inline members for RuleChain

inline bool RuleChain::operator()(const pion::platform::EventPtr& e) const
{
    ComparisonVector::const_iterator i = m_comparisons.begin();
    
    if (m_match_all_comparisons) {
        // all comparisons in the rule chain must pass for the Event to be delivered
        for (; i != m_comparisons.end(); ++i) {
            if (! i->evaluate(*e) )
                return false;
        }
    } else {
        // any one comparison in the rule chain must pass for the Event to be delivered
        for (; i != m_comparisons.end(); ++i) {
            if ( i->evaluate(*e) )
                break;
        }
        // return if none matched & at least one rule is defined
        if ( i == m_comparisons.end() && ! m_comparisons.empty() )
            return false;
    }
    
    return true;
}


}   // end namespace platform
}   // end namespace pion

#endif

---