source: trunk/ETSI-Testsuites/ETSI_auto_IOT/codec/c++/Regex.h

#include <boost/regex.hpp>
#include <t3devlib/t3devlib.h>

namespace t3devlib { namespace gen {

/** Implementation of perl-like regular expressions to be used in a decoder
 * generated by T3DevKit.
 *
 * This class handles the regex compilation and execution. The result of
 * group matching is stored internally.
 *
 * It is designed to be used seamlessly in codets for T3DevKit, thus:
 *  - it can interact with t3devlib data (Buffer, Variable, DecodeError)
 *  - it reports errors using T3DevKit's exceptions
 *  - it returns the length of the matches in bits
 *
 *
 * The regular expression is compiled at the construction of the object. Then
 * it can be used multiple times to search the regex in the buffer (with
 * Match() or AssertMatch()).
 *
 * After a regex search, it is possible to inspect the result at to take
 * actions with other member functions (GetMatchedLength(), MoveAt(), ...)
 *
 * \warning     Apart from moving the cursor, the buffer MUST NOT be modified
 *              between the call of Match() or AssertMatch() and the use of
 *              inspection/action member functions (GetMatchedLength(),
 *              MoveAt() ...)
 */
class Regex {
public:
        typedef std::string::const_iterator     iterator;

        /** Constructor
         *
         * This constructor compiles the regular expression given as a
         * parameter. It is based on the format of perl regular expressions.
         *
         * \warning     it is assumed that regex is a static const string
         */
        Regex(const char* regex)
         : mSource (regex), mRegex (regex, boost::regex_constants::perl | boost::regex_constants::no_mod_m)
        {}

        /** Try to match the regular expression in the buffer.
         *
         * The regular expression is searched in the buffer between the
         * position of its cursor and the first end marker set (thus between
         * the positions given by Buffer::GetPosition() and
         * Buffer::GetEndMarker()) 
         *
         * \param buffer        buffer on which the regex shall be searched
         *
         * \return      true in case of success
         */
        bool Match (Buffer& buffer) {
                mStart = iterator (reinterpret_cast<const char*> (buffer.GetValueBin()) + (buffer.GetPosition() / 8));
                mStop = iterator (reinterpret_cast<const char*> (buffer.GetValueBin()) + (buffer.GetEndMarker() / 8));

                int result = boost::regex_search (mStart, mStop, mResults, mRegex);

                return result;
        }

        /** Match the regular expression in the buffer or throw an exeption
         * if not successful.
         *
         * \param buffer        buffer on which the regex shall be searched
         * \param v             reference of the value being decoded; it is
         *                      used to allow locating the error in case an
         *                      exception is thrown
         */
        void AssertMatch (Buffer& buffer, Variable* v) throw (DecodeError) {
                if (!Match (buffer)) {
                        Error (v, buffer);
                }
        }

        /** Get the length of a group match
         *
         * \param       id      index of the '(...)' group to analyse (or 0
         *                      to refer to the whole regular expression)
         *
         * \return              the length of the group in bits
         */
        int GetMatchedLength(int id = 0) {
                return mResults[id].length()*8;
        }

        /** Get the content of a group match
         *
         * \param       id      index of the '(...)' group to analyse (or 0
         *                      to refer to the whole regular expression)
         *
         * \return              the string matched by the group
         */
        std::string GetMatchedString(int id = 0) {
                return std::string (mResults[id].first, mResults[id].second);
        }

        /** Move the cursor of the buffer past a group match
         *
         * \param       id      index of the '(...)' group to analyse (or 0
         *                      to refer to the whole regular expression)
         */
        void MovePast (Buffer& buffer, int id = 0)
        {
                buffer.SetPosition ((&*mResults[id].second - reinterpret_cast<const char*> (buffer.GetValueBin())) * 8);
        }
        
        /** Move the cursor of the buffer at the beginning of group match
         *
         * \param       id      index of the '(...)' group to analyse (or 0
         *                      to refer to the whole regular expression)
         */
        void MoveAt (Buffer& buffer, int id = 0)
        {
                buffer.SetPosition ((&*mResults[id].first - reinterpret_cast<const char*> (buffer.GetValueBin())) * 8);
        }

        /** Throw a decoding error
         *
         * This function will throw an exception telling that the codec
         * could not match the regular expression. The error message will
         * also contains details about the regular expression and the
         * content of the buffer at the position where the exception could
         * not be matched.
         *
         * \param       v       reference to the value being decoded
         *                      (used to locate the position of the error)
         * \param       buffer  buffer on which the regex could no be matched
         */
        void Error (Variable* v, Buffer& buffer) throw (DecodeError) {

                std::string message ("cannot match regex /");
                message += mSource;
                message += "/ in '";
                if ((mStop - mStart) > 40) {
                        message.append (&*mStart, 40);
                        message += "...";
                } else {
                        message.append (mStart, mStop);
                }
                message += "'\n";
                throw DecodeError (v, message);
        }

private:
        /** source of the regular expression (should be a static string) */
        const char*     mSource;

        /** boost regex object used to implement the regular expression */
        boost::regex    mRegex;

        /** iterators delimiting the positions in the buffer where the regex
         * is applied (between GetPosition() and GetEndMarker)
         */
        iterator        mStart, mStop;

        /** boost match result used to store the results of the regex search */
        boost::match_results<iterator>  mResults;
};


}} //namespaces