cel_regex.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_regex_h_
#define _cel_regex_h_

#include "cel_string.h"
#include "cel_autoptr.h"

namespace Celartem
{
    enum RegexOptionFlag
    {
        regex_default = 0,       
        regex_multiline = 1,     
        regex_ignoreCase = 2,    
        regex_longest_match = 4, 
        regex_ignore_empty = 8,  
    };

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    class RegEx : public Referable
    {
    public:
        virtual AutoPtr<Region> search(
            const UChar1 *str,
            const UChar1 *rangePtr = NULL, const UChar1 *rangeEnd = NULL,
            const UChar1 *strEnd = NULL) = 0;

        virtual AutoPtr<Region> match(
            const char *str,
            const char *strAt = NULL,
            const char *strEnd = NULL) = 0;

        static AutoPtr<RegEx> create(
            const UChar1 *inPattern, size_t length,
            int inOptionFlags = regex_default);
    };

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    class RegularExpression
    {
    public:
        RegularExpression(
            const UChar1 *inPattern,
            int inOptionFlags = regex_default)
        {
            init(inPattern);
        }

        RegularExpression(
            const String& inPattern,
            int inOptionFlags = regex_default)
            : m_regex(RegEx::create(
                inPattern.c_str(), inPattern.getLength(), inOptionFlags))
        {
            init(inPattern.c_str());
        }

        RegularExpression(
            const utf8s& inPattern,
            int inOptionFlags = regex_default)
        {
            init(inPattern.m_str);
        }

        void init(const UChar1 *inPattern,
            int inOptionFlags = regex_default)
        {
            m_regex = RegEx::create(
                inPattern, StringUtil<UChar1>::strlen(inPattern),
                inOptionFlags);
        }

        inline bool findFirst(const String& str)
        {
            m_region = m_regex->search(str.c_str());
            if(m_region.isValid())
                m_region->lockString(str);
            return m_region.isValid();
        }

        inline bool findFirst(
            const UChar1 *str,
            const UChar1 *rangePtr = NULL, const UChar1 *rangeEnd = NULL,
            const UChar1 *strEnd = NULL)
        {
            m_region = m_regex->search(
                str, rangePtr, rangeEnd, strEnd);
            return m_region.isValid();
        }

        inline bool findNext()
        {
            const UChar1* p = m_region->getPtr();
            m_region = m_regex->search(
                m_region->getBufferPtr(),
                m_region->getEndPtr(0), m_region->getRangeEndPtr(),
                m_region->getBufferEndPtr());
            if(!m_region.isValid())
                return false;
            if(p == m_region->getPtr())
                return false;
            return true;
        }

        inline bool isVaild() const
        {
            return m_region.isValid();
        }

        inline size_t getCount() const
        {
            return m_region->getCount();
        }

        inline size_t getPos(size_t n = 0) const
        {
            return m_region->getPos(n);
        }

        inline size_t getEndPos(size_t n = 0) const
        {
            return m_region->getEndPos(n);
        }

        inline size_t getLength(size_t n = 0) const
        {
            return m_region->getLength(n);
        }

        inline const UChar1 *getPtr(size_t n = 0) const
        {
            return m_region->getPtr(n);
        }

        inline String getString(size_t n = 0) const
        {
            return String(utf8s(m_region->getPtr(n)), m_region->getLength(n));
        }

    private:
        AutoPtr<RegEx> m_regex;
        AutoPtr<Region> m_region;
    };

} // namespace Celartem

#endif // _cel_regex_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.