platform/include/pion/platform/Comparison.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_COMPARISON_HEADER__
#define __PION_COMPARISON_HEADER__

#include <boost/scoped_array.hpp>
#include <boost/regex.hpp>
#include <boost/regex/icu.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/algorithm/string/compare.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/tuple/tuple.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Vocabulary.hpp>
#include <pion/platform/Event.hpp>
#include <unicode/uiter.h>
#include <unicode/ustring.h>
#include <unicode/stsearch.h>

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

class PION_PLATFORM_API Comparison
{
public:

    enum ComparisonType {
        TYPE_FALSE = 0,                     // always false
        TYPE_TRUE,                          // always true
        TYPE_IS_DEFINED,                    // true if at least one value is defined
        TYPE_IS_NOT_DEFINED,                // true if no values are defined
        // numeric operations
        TYPE_EQUALS,
        TYPE_NOT_EQUALS,
        TYPE_GREATER_THAN,
        TYPE_LESS_THAN,
        TYPE_GREATER_OR_EQUAL,
        TYPE_LESS_OR_EQUAL,
        // string operations
        TYPE_EXACT_MATCH,
        TYPE_NOT_EXACT_MATCH,
        TYPE_CONTAINS,
        TYPE_NOT_CONTAINS,
        TYPE_STARTS_WITH,
        TYPE_NOT_STARTS_WITH,
        TYPE_ENDS_WITH,
        TYPE_NOT_ENDS_WITH,
        TYPE_ORDERED_BEFORE,
        TYPE_NOT_ORDERED_BEFORE,
        TYPE_ORDERED_AFTER,
        TYPE_NOT_ORDERED_AFTER,
        TYPE_REGEX,
        TYPE_NOT_REGEX,
        // string operations using UCOL_PRIMARY
        TYPE_EXACT_MATCH_PRIMARY,
        TYPE_NOT_EXACT_MATCH_PRIMARY,
        TYPE_CONTAINS_PRIMARY,
        TYPE_NOT_CONTAINS_PRIMARY,
        TYPE_STARTS_WITH_PRIMARY,
        TYPE_NOT_STARTS_WITH_PRIMARY,
        TYPE_ENDS_WITH_PRIMARY,
        TYPE_NOT_ENDS_WITH_PRIMARY,
        TYPE_ORDERED_BEFORE_PRIMARY,
        TYPE_NOT_ORDERED_BEFORE_PRIMARY,
        TYPE_ORDERED_AFTER_PRIMARY,
        TYPE_NOT_ORDERED_AFTER_PRIMARY,
        // date_time operations
        TYPE_SAME_DATE_TIME,
        TYPE_NOT_SAME_DATE_TIME,
        TYPE_EARLIER_DATE_TIME,
        TYPE_LATER_DATE_TIME,
        TYPE_SAME_OR_EARLIER_DATE_TIME,
        TYPE_SAME_OR_LATER_DATE_TIME,
        // date operations
        TYPE_SAME_DATE,
        TYPE_NOT_SAME_DATE,
        TYPE_EARLIER_DATE,
        TYPE_LATER_DATE,
        TYPE_SAME_OR_EARLIER_DATE,
        TYPE_SAME_OR_LATER_DATE,
        // time of day operations
        TYPE_SAME_TIME,
        TYPE_NOT_SAME_TIME,
        TYPE_EARLIER_TIME,
        TYPE_LATER_TIME,
        TYPE_SAME_OR_EARLIER_TIME,
        TYPE_SAME_OR_LATER_TIME,
        // Update LAST_COMPARISON_TYPE if adding types after TYPE_SAME_OR_LATER_TIME.
        LAST_COMPARISON_TYPE = TYPE_SAME_OR_LATER_TIME
    };

    class UnknownComparisonTypeException : public PionException {
    public:
        UnknownComparisonTypeException(const std::string& comparison_type)
            : PionException("Could not parse unknown comparison type: ", comparison_type) {}
    };

    class InvalidComparisonException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "An invalid comparison was attempted";
        }
    };

    class InvalidTypeForTermException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Invalid comparison type given for Vocabulary Term";
        }
    };

    class InvalidValueForTypeException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Invalid value given for comparison type";
        }
    };


    virtual ~Comparison() {}

    explicit Comparison(const Vocabulary::Term& term)
        : m_term(term), m_type(TYPE_FALSE), m_match_all_values(false)
    {}

    Comparison(const Comparison& c)
        : m_term(c.m_term), m_type(c.m_type), m_value(c.m_value),
        m_str_value(c.m_str_value), m_comparison_func(c.m_comparison_func), 
        m_regex(c.m_regex), m_match_all_values(c.m_match_all_values)
    {}

    inline bool evaluate(const Event& e) const;

    inline bool evaluateRange(const Event::ValuesRange& values_range) const;

    template <typename T>
    inline void configure(const ComparisonType type,
                          const T& value,
                          const bool match_all_values = false);

    inline void configure(const ComparisonType type, const char *value,
                          const bool match_all_values = false)
    {
        std::string value_str(value);
        configure(type, value_str, match_all_values);
    }

    void configure(const ComparisonType type, const std::string &value,
                   const bool match_all_values = false);

    void configure(const ComparisonType type);

    void updateVocabulary(const Vocabulary& v);


    inline const Vocabulary::Term& getTerm(void) const { return m_term; }

    inline ComparisonType getType(void) const { return m_type; }

    inline const Event::ParameterValue& getValue(void) const { return m_value; }

    inline bool getMatchAllValues(void) const { return m_match_all_values; }

    inline const boost::u32regex& getRegex(void) const { return m_regex; }

    inline const std::string& getRegexStr(void) const { return m_regex_str; }

    static ComparisonType parseComparisonType(std::string str);

    static std::string getComparisonTypeAsString(const ComparisonType comparison_type);

    static bool requiresValue(ComparisonType t);

    static void writeComparisonsXML(std::ostream& out);

private:

    template <typename T>
    class CompareEquals {
    public:
        CompareEquals(const Event::ParameterValue& value) : m_value(boost::get<const T&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const T&>(event_value) == m_value;
        }
    private:
        const T&    m_value;
    };

    template <typename T>
    class CompareGreaterThan {
    public:
        CompareGreaterThan(const Event::ParameterValue& value) : m_value(boost::get<const T&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const T&>(event_value) > m_value;
        }
    private:
        const T&    m_value;
    };

    template <typename T>
    class CompareLessThan {
    public:
        CompareLessThan(const Event::ParameterValue& value) : m_value(boost::get<const T&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const T&>(event_value) < m_value;
        }
    private:
        const T&    m_value;
    };

    template <typename T>
    class CompareGreaterOrEqual {
    public:
        CompareGreaterOrEqual(const Event::ParameterValue& value) : m_value(boost::get<const T&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const T&>(event_value) >= m_value;
        }
    private:
        const T&    m_value;
    };

    template <typename T>
    class CompareLessOrEqual {
    public:
        CompareLessOrEqual(const Event::ParameterValue& value) : m_value(boost::get<const T&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const T&>(event_value) <= m_value;
        }
    private:
        const T&    m_value;
    };

    class ComparisonFunctor {
    public:
        ComparisonFunctor(const std::string& value, UColAttributeValue attr);
        virtual ~ComparisonFunctor();

        virtual bool operator()(const Event::ParameterValue& event_value) const = 0;

    protected:
        int32_t         m_pattern_buf_len;
        UChar*          m_pattern_buf;
        UCollator*      m_collator;
    };

    class CompareStringExactMatch : public ComparisonFunctor {
    public:
        CompareStringExactMatch(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringExactMatch() {}

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            UCharIterator text_iter, pattern_iter;
            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            uiter_setUTF8(&text_iter, blob.get(), blob.size());
            uiter_setString(&pattern_iter, m_pattern_buf, m_pattern_buf_len);
            UErrorCode errorCode = U_ZERO_ERROR;
            UCollationResult result = ucol_strcollIter(m_collator, &text_iter, &pattern_iter, &errorCode);
            // TODO: check errorCode.
            return (result == UCOL_EQUAL);
        }
    };

    class CompareStringContains : public ComparisonFunctor {
    public:
        CompareStringContains(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringContains() {}

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            //UnicodeString text = UnicodeString::fromUTF8(boost::get<const Event::BlobType&>(event_value).get());

            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            int32_t text_buf_len;
            UErrorCode errorCode = U_ZERO_ERROR;
            u_strFromUTF8(NULL, 0, &text_buf_len, blob.get(), blob.size(), &errorCode);
            errorCode = U_ZERO_ERROR; // Need to reset, because u_strFromUTF8 returns U_BUFFER_OVERFLOW_ERROR when destCapacity = 0.
            boost::scoped_array<UChar> text_buf(new UChar[text_buf_len]);
            u_strFromUTF8(text_buf.get(), text_buf_len, NULL, blob.get(), blob.size(), &errorCode);
            // Use u_strFromUTF8Lenient instead?
            UStringSearch* ss = usearch_openFromCollator(m_pattern_buf, m_pattern_buf_len, text_buf.get(), text_buf_len, m_collator, NULL, &errorCode);
            int pos = usearch_first(ss, &errorCode);
            usearch_close(ss);
            // TODO: check errorCode.
            return (pos != USEARCH_DONE);
        }
    };

    class CompareStringStartsWith : public ComparisonFunctor {
    public:
        CompareStringStartsWith(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringStartsWith();

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            // Create a code unit iterator from the Event value.
            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            UCharIterator text_iter;
            uiter_setUTF8(&text_iter, blob.get(), blob.size());

            // Populate a buffer by parsing UTF-8 bytes from the blob into code units, until the number of code units is the same as in the pattern.
            boost::scoped_array<UChar> text_prefix_buf(new UChar[m_pattern_buf_len]);
            int i;
            for (i = 0; i < m_pattern_buf_len; ++i) {
                UChar32 c = text_iter.next(&text_iter);
                if (c == U_SENTINEL) {
                    // If the iteration failed, the text is too short to start with the pattern, so return false.
                    return false;
                }
                text_prefix_buf[i] = c;
            }

            UCollationResult result = ucol_strcoll(m_collator, text_prefix_buf.get(), m_pattern_buf_len, m_pattern_buf, m_pattern_buf_len);
            return (result == UCOL_EQUAL);
        }
    };

    class CompareStringEndsWith : public ComparisonFunctor {
    public:
        CompareStringEndsWith(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringEndsWith() {}

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            // Create a code unit iterator from the Event value.
            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            UCharIterator text_iter;
            uiter_setUTF8(&text_iter, blob.get(), blob.size());

            // Try to iterate back m_pattern_buf_len code units from the end (where m_pattern_buf_len is the number of code units in the pattern).
            int32_t p = text_iter.move(&text_iter, -m_pattern_buf_len, UITER_LIMIT);

            // If the iteration failed, the text is too short to end with the pattern, so return false.
            if (p == U_SENTINEL)
                return false;

            // Compare the last m_pattern_buf_len code units of the text with all m_pattern_buf_len code units of the pattern.
            UCharIterator pattern_iter;
            uiter_setString(&pattern_iter, m_pattern_buf, m_pattern_buf_len);
            UErrorCode errorCode = U_ZERO_ERROR;
            UCollationResult result = ucol_strcollIter(m_collator, &text_iter, &pattern_iter, &errorCode);
            // TODO: check errorCode.
            return (result == UCOL_EQUAL);
        }
    };

    class CompareStringOrderedBefore : public ComparisonFunctor {
    public:
        CompareStringOrderedBefore(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringOrderedBefore() {}

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            UCharIterator text_iter, pattern_iter;
            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            uiter_setUTF8(&text_iter, blob.get(), blob.size());
            uiter_setString(&pattern_iter, m_pattern_buf, m_pattern_buf_len);
            UErrorCode errorCode = U_ZERO_ERROR;
            UCollationResult result = ucol_strcollIter(m_collator, &text_iter, &pattern_iter, &errorCode);
            // TODO: check errorCode.
            return (result == UCOL_LESS);
        }
    };

    class CompareStringOrderedAfter : public ComparisonFunctor {
    public:
        CompareStringOrderedAfter(const std::string& value, UColAttributeValue attr = UCOL_DEFAULT);
        ~CompareStringOrderedAfter() {}

        virtual bool operator()(const Event::ParameterValue& event_value) const {
            UCharIterator text_iter, pattern_iter;
            const Event::BlobType& blob = boost::get<const Event::BlobType&>(event_value);
            uiter_setUTF8(&text_iter, blob.get(), blob.size());
            uiter_setString(&pattern_iter, m_pattern_buf, m_pattern_buf_len);
            UErrorCode errorCode = U_ZERO_ERROR;
            UCollationResult result = ucol_strcollIter(m_collator, &text_iter, &pattern_iter, &errorCode);
            // TODO: check errorCode.
            return (result == UCOL_GREATER);
        }
    };

    class CompareStringRegex {
    public:
        CompareStringRegex(const boost::u32regex& value) : m_regex(value) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            // note: regex_match must match the ENTIRE string; use regex_search
            // instead to match any part of the string
            return boost::u32regex_search(
                boost::get<const Event::BlobType&>(event_value).get(), m_regex);
        }
    private:
        const boost::u32regex&  m_regex;
    };

    class CompareSameDateTime {
    public:
        CompareSameDateTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value) == m_value;
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareEarlierDateTime {
    public:
        CompareEarlierDateTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value) < m_value;
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareLaterDateTime {
    public:
        CompareLaterDateTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value) > m_value;
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrEarlierDateTime {
    public:
        CompareSameOrEarlierDateTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value) <= m_value;
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrLaterDateTime {
    public:
        CompareSameOrLaterDateTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value) >= m_value;
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameDate {
    public:
        CompareSameDate(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).date() == m_value.date();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareEarlierDate {
    public:
        CompareEarlierDate(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).date() < m_value.date();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareLaterDate {
    public:
        CompareLaterDate(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).date() > m_value.date();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrEarlierDate {
    public:
        CompareSameOrEarlierDate(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).date() <= m_value.date();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrLaterDate {
    public:
        CompareSameOrLaterDate(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).date() >= m_value.date();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameTime {
    public:
        CompareSameTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).time_of_day() == m_value.time_of_day();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareEarlierTime {
    public:
        CompareEarlierTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).time_of_day() < m_value.time_of_day();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareLaterTime {
    public:
        CompareLaterTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).time_of_day() > m_value.time_of_day();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrEarlierTime {
    public:
        CompareSameOrEarlierTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).time_of_day() <= m_value.time_of_day();
        }
    private:
        const PionDateTime& m_value;
    };

    class CompareSameOrLaterTime {
    public:
        CompareSameOrLaterTime(const Event::ParameterValue& value) : m_value(boost::get<const PionDateTime&>(value)) {}
        inline bool operator()(const Event::ParameterValue& event_value) const {
            return boost::get<const PionDateTime&>(event_value).time_of_day() >= m_value.time_of_day();
        }
    private:
        const PionDateTime& m_value;
    };


    bool checkForValidType(const ComparisonType type) const;

    template <typename ComparisonFunction>
    inline bool checkComparison(const ComparisonFunction& comparison_func,
                                const Event::ValuesRange& values_range) const;

    Vocabulary::Term            m_term;

    ComparisonType              m_type;

    Event::ParameterValue       m_value;

    std::string                 m_str_value;

    boost::shared_ptr<ComparisonFunctor>
                                m_comparison_func;

    boost::u32regex             m_regex;

    std::string                 m_regex_str;

    bool                        m_match_all_values;
};



template <typename T>
inline void Comparison::configure(const ComparisonType type,
                                  const T& value,
                                  const bool match_all_values)
{
    if (! checkForValidType(type))
        throw InvalidTypeForTermException();

    m_type = type;
    m_value = value;
    m_match_all_values = match_all_values;

    // make sure the value matches the comparison type
    switch (m_term.term_type) {
        case Vocabulary::TYPE_NULL:
        case Vocabulary::TYPE_OBJECT:
            throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_INT8:
        case Vocabulary::TYPE_INT16:
        case Vocabulary::TYPE_INT32:
            if (boost::get<boost::int32_t>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_UINT8:
        case Vocabulary::TYPE_UINT16:
        case Vocabulary::TYPE_UINT32:
            if (boost::get<boost::uint32_t>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_INT64:
            if (boost::get<boost::int64_t>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_UINT64:
            if (boost::get<boost::uint64_t>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_FLOAT:
            if (boost::get<float>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_DOUBLE:
            if (boost::get<double>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_LONG_DOUBLE:
            if (boost::get<long double>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_SHORT_STRING:
        case Vocabulary::TYPE_STRING:
        case Vocabulary::TYPE_LONG_STRING:
        case Vocabulary::TYPE_CHAR:
        case Vocabulary::TYPE_BLOB:
        case Vocabulary::TYPE_ZBLOB:
            throw InvalidValueForTypeException();
            break;
        case Vocabulary::TYPE_DATE_TIME:
        case Vocabulary::TYPE_DATE:
        case Vocabulary::TYPE_TIME:
            if (boost::get<PionDateTime>(&m_value) == NULL)
                throw InvalidValueForTypeException();
            break;
    }
}

//************************************************************************************************************************************************

// inline member functions for Comparison

template <typename ComparisonFunction>
inline bool Comparison::checkComparison(const ComparisonFunction& comparison_func,
                                        const Event::ValuesRange& values_range) const
{
    boost::tribool result = boost::indeterminate;
//  Event::ConstIterator value = values_range.second;

    for (Event::ConstIterator i = values_range.first;
         i != values_range.second; ++i)
    {
        if (comparison_func(i->value)) {
            if (! m_match_all_values) {
                result = true;
//              value = i;
                break;
            }
        } else {
            if (m_match_all_values) {
                result = false;
                break;
            }
        }
    }

    if (boost::indeterminate(result))
        result = m_match_all_values;

    return result;
}


// This method now evaluates only a values_range, in order to support TransformReactor2
// See Comparison::evaluate() on how values_range is defined, and the special case of *_DEFINED
inline bool Comparison::evaluateRange(const Event::ValuesRange& values_range) const
{
    bool result = false;
    bool negate_result = false;

    switch (m_type) {
        case TYPE_FALSE:
            result = false;
            break;
        case TYPE_TRUE:
            result = true;
            break;
        case TYPE_IS_DEFINED:
            result = (values_range.first != values_range.second);
            break;
        case TYPE_IS_NOT_DEFINED:
            result = (values_range.first == values_range.second);
            break;

        case TYPE_EQUALS:
        case TYPE_NOT_EQUALS:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_INT8:
                case Vocabulary::TYPE_INT16:
                case Vocabulary::TYPE_INT32:
                {
                    CompareEquals<boost::int32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_INT64:
                {
                    CompareEquals<boost::int64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT8:
                case Vocabulary::TYPE_UINT16:
                case Vocabulary::TYPE_UINT32:
                {
                    CompareEquals<boost::uint32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT64:
                {
                    CompareEquals<boost::uint64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_FLOAT:
                {
                    CompareEquals<float> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_DOUBLE:
                {
                    CompareEquals<double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_LONG_DOUBLE:
                {
                    CompareEquals<long double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            if (m_type == TYPE_NOT_EQUALS)
                result = !result;
            break;

        case TYPE_GREATER_THAN:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_INT8:
                case Vocabulary::TYPE_INT16:
                case Vocabulary::TYPE_INT32:
                {
                    CompareGreaterThan<boost::int32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_INT64:
                {
                    CompareGreaterThan<boost::int64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT8:
                case Vocabulary::TYPE_UINT16:
                case Vocabulary::TYPE_UINT32:
                {
                    CompareGreaterThan<boost::uint32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT64:
                {
                    CompareGreaterThan<boost::uint64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_FLOAT:
                {
                    CompareGreaterThan<float> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_DOUBLE:
                {
                    CompareGreaterThan<double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_LONG_DOUBLE:
                {
                    CompareGreaterThan<long double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            break;

        case TYPE_LESS_THAN:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_INT8:
                case Vocabulary::TYPE_INT16:
                case Vocabulary::TYPE_INT32:
                {
                    CompareLessThan<boost::int32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_INT64:
                {
                    CompareLessThan<boost::int64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT8:
                case Vocabulary::TYPE_UINT16:
                case Vocabulary::TYPE_UINT32:
                {
                    CompareLessThan<boost::uint32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT64:
                {
                    CompareLessThan<boost::uint64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_FLOAT:
                {
                    CompareLessThan<float> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_DOUBLE:
                {
                    CompareLessThan<double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_LONG_DOUBLE:
                {
                    CompareLessThan<long double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            break;

        case TYPE_GREATER_OR_EQUAL:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_INT8:
                case Vocabulary::TYPE_INT16:
                case Vocabulary::TYPE_INT32:
                {
                    CompareGreaterOrEqual<boost::int32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_INT64:
                {
                    CompareGreaterOrEqual<boost::int64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT8:
                case Vocabulary::TYPE_UINT16:
                case Vocabulary::TYPE_UINT32:
                {
                    CompareGreaterOrEqual<boost::uint32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT64:
                {
                    CompareGreaterOrEqual<boost::uint64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_FLOAT:
                {
                    CompareGreaterOrEqual<float> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_DOUBLE:
                {
                    CompareGreaterOrEqual<double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_LONG_DOUBLE:
                {
                    CompareGreaterOrEqual<long double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            break;

        case TYPE_LESS_OR_EQUAL:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_INT8:
                case Vocabulary::TYPE_INT16:
                case Vocabulary::TYPE_INT32:
                {
                    CompareLessOrEqual<boost::int32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_INT64:
                {
                    CompareLessOrEqual<boost::int64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT8:
                case Vocabulary::TYPE_UINT16:
                case Vocabulary::TYPE_UINT32:
                {
                    CompareLessOrEqual<boost::uint32_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_UINT64:
                {
                    CompareLessOrEqual<boost::uint64_t> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_FLOAT:
                {
                    CompareLessOrEqual<float> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_DOUBLE:
                {
                    CompareLessOrEqual<double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                case Vocabulary::TYPE_LONG_DOUBLE:
                {
                    CompareLessOrEqual<long double> comparison_func(m_value);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            break;

        case TYPE_NOT_EXACT_MATCH:
        case TYPE_NOT_EXACT_MATCH_PRIMARY:
        case TYPE_NOT_CONTAINS:
        case TYPE_NOT_CONTAINS_PRIMARY:
        case TYPE_NOT_STARTS_WITH:
        case TYPE_NOT_STARTS_WITH_PRIMARY:
        case TYPE_NOT_ENDS_WITH:
        case TYPE_NOT_ENDS_WITH_PRIMARY:
        case TYPE_NOT_ORDERED_BEFORE:
        case TYPE_NOT_ORDERED_BEFORE_PRIMARY:
        case TYPE_NOT_ORDERED_AFTER:
        case TYPE_NOT_ORDERED_AFTER_PRIMARY:
            negate_result = true;
        case TYPE_EXACT_MATCH:
        case TYPE_EXACT_MATCH_PRIMARY:
        case TYPE_CONTAINS:
        case TYPE_CONTAINS_PRIMARY:
        case TYPE_STARTS_WITH:
        case TYPE_STARTS_WITH_PRIMARY:
        case TYPE_ENDS_WITH:
        case TYPE_ENDS_WITH_PRIMARY:
        case TYPE_ORDERED_BEFORE:
        case TYPE_ORDERED_BEFORE_PRIMARY:
        case TYPE_ORDERED_AFTER:
        case TYPE_ORDERED_AFTER_PRIMARY:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_SHORT_STRING:
                case Vocabulary::TYPE_STRING:
                case Vocabulary::TYPE_LONG_STRING:
                case Vocabulary::TYPE_CHAR:
                case Vocabulary::TYPE_BLOB:
                case Vocabulary::TYPE_ZBLOB:
                    result = checkComparison(*m_comparison_func, values_range);
                    break;
                default:
                    throw InvalidComparisonException();
            }
            if (negate_result)
                result = !result;
            break;

        case TYPE_REGEX:
        case TYPE_NOT_REGEX:
            switch (m_term.term_type) {
                case Vocabulary::TYPE_SHORT_STRING:
                case Vocabulary::TYPE_STRING:
                case Vocabulary::TYPE_LONG_STRING:
                case Vocabulary::TYPE_CHAR:
                case Vocabulary::TYPE_BLOB:
                case Vocabulary::TYPE_ZBLOB:
                {
                    CompareStringRegex comparison_func(m_regex);
                    result = checkComparison(comparison_func, values_range);
                    break;
                }
                default:
                    throw InvalidComparisonException();
            }
            if (m_type == TYPE_NOT_REGEX)
                result = !result;
            break;

        case TYPE_SAME_DATE_TIME:
        case TYPE_NOT_SAME_DATE_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME)
            CompareSameDateTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            if (m_type == TYPE_NOT_SAME_DATE_TIME)
                result = !result;
            break;
        }

        case TYPE_EARLIER_DATE_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME)
            CompareEarlierDateTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_LATER_DATE_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME)
            CompareLaterDateTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_EARLIER_DATE_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME)
            CompareSameOrEarlierDateTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_LATER_DATE_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME)
            CompareSameOrLaterDateTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_DATE:
        case TYPE_NOT_SAME_DATE:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_DATE)
            CompareSameDate comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            if (m_type == TYPE_NOT_SAME_DATE)
                result = !result;
            break;
        }

        case TYPE_EARLIER_DATE:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_DATE)
            CompareEarlierDate comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_LATER_DATE:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_DATE)
            CompareLaterDate comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_EARLIER_DATE:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_DATE)
            CompareSameOrEarlierDate comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_LATER_DATE:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_DATE)
            CompareSameOrLaterDate comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_TIME:
        case TYPE_NOT_SAME_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_TIME)
            CompareSameTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            if (m_type == TYPE_NOT_SAME_TIME)
                result = !result;
            break;
        }

        case TYPE_EARLIER_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_TIME)
            CompareEarlierTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_LATER_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_TIME)
            CompareLaterTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_EARLIER_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_TIME)
            CompareSameOrEarlierTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }

        case TYPE_SAME_OR_LATER_TIME:
        {
            PION_ASSERT(m_term.term_type == Vocabulary::TYPE_DATE_TIME || m_term.term_type == Vocabulary::TYPE_TIME)
            CompareSameOrLaterTime comparison_func(m_value);
            result = checkComparison(comparison_func, values_range);
            break;
        }
    }

    return result;
}

// This is the refactored version of evaluate
// Since IS_DEFINED and IS_NOT_DEFINED allow for looking at Event, in addition to range_value,
// it was necessary to put some convoluted special-case logic here...
inline bool Comparison::evaluate(const Event& e) const
{
    if (m_type == TYPE_IS_DEFINED || m_type == TYPE_IS_NOT_DEFINED) {
        // If object type matches looked for type, return true -- refactored out of evaluateRange
        if (e.getType() == m_term.term_ref) return m_type == TYPE_IS_DEFINED;
    }
    Event::ValuesRange values_range = e.equal_range(m_term.term_ref);
    return Comparison::evaluateRange(values_range);
}


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

#endif

---