pcre2_regex_engine.hpp

Go to the documentation of this file.

/*
    restinio
*/
 
/*!
    Regex engine for using std::regex.
*/
 
#pragma once
 
#include <array>
 
#include <pcre2.h>
 
#include <restinio/impl/include_fmtlib.hpp>
 
#include <restinio/exception.hpp>
 
namespace restinio
{
 
namespace router
{
 
namespace pcre2_details
{
 
//
// match_results_t
//
 
//! A wrapper class for working with pcre match results.
template < typename Traits >
struct match_results_t final
{
    match_results_t()
    {
        m_match_data = pcre2_match_data_create( Traits::max_capture_groups, nullptr );
    }
 
    ~match_results_t()
    {
        if( nullptr != m_match_data )
            pcre2_match_data_free( m_match_data );
    }
 
    match_results_t( const match_results_t & ) = delete;
    match_results_t( match_results_t && ) = delete;
    match_results_t & operator = ( const match_results_t & ) = delete;
    match_results_t & operator = ( match_results_t && ) = delete;
 
    struct matched_item_descriptor_t final
    {
        matched_item_descriptor_t(
            PCRE2_SIZE begin,
            PCRE2_SIZE end )
            :   m_begin{ begin }
            ,   m_end{ end }
        {}
 
        PCRE2_SIZE m_begin;
        PCRE2_SIZE m_end;
    };
 
    matched_item_descriptor_t
    operator [] ( std::size_t i ) const
    {
        PCRE2_SIZE * submatches = pcre2_get_ovector_pointer( m_match_data );
 
        return matched_item_descriptor_t{
                submatches[ 2 * i ],
                submatches[ 1 + 2 * i ] };
    }
 
    std::size_t size() const { return m_size; }
 
    std::size_t m_size{ 0 };
    pcre2_match_data * m_match_data;
};
 
//
// regex_t
//
 
//! A wrapper for using pcre regexes in express_router.
class regex_t final
{
    public:
        regex_t() = default;
        regex_t( string_view_t r, int options )
        {
            compile( r, options );
        }
 
        regex_t( const regex_t & ) = delete;
        regex_t & operator = ( const regex_t & ) = delete;
 
        regex_t( regex_t && rw ) noexcept
            : m_route_regex{ rw.m_route_regex }
        {
            rw.m_route_regex = nullptr;
        }
 
        regex_t & operator = ( regex_t && rw ) noexcept
        {
            if( this != &rw )
            {
                m_route_regex = rw.m_route_regex;
                rw.m_route_regex = nullptr;
            }
 
            return *this;
        }
 
        ~regex_t()
        {
            if( nullptr != m_route_regex )
            {
                pcre2_code_free( m_route_regex );
            }
        }
 
        const pcre2_code *
        pcre2_regex() const
        {
            return m_route_regex;
        }
 
    private:
        pcre2_code * m_route_regex{ nullptr };
 
        void
        compile( string_view_t r, int options )
        {
            PCRE2_SIZE erroroffset;
            int errorcode;
 
            m_route_regex = pcre2_compile(
                reinterpret_cast< const unsigned char*>( r.data() ),
                r.size(),
                static_cast<unsigned int>(options),
                &errorcode,
                &erroroffset,
                nullptr );
 
            if( nullptr == m_route_regex )
            {
                std::array< unsigned char, 256 > buffer;
                (void)pcre2_get_error_message( errorcode, buffer.data(), buffer.size() );
                throw exception_t{
                        fmt::format(
                            RESTINIO_FMT_FORMAT_STRING(
                                "unable to compile regex \"{}\": {}" ),
                            fmtlib_tools::streamed( r ),
                            reinterpret_cast< const char * >( buffer.data() ) ) };
            }
        }
};
 
} /* namespace pcre2_details */
 
//
// pcre_traits_t
//
 
//! PCRE traits.
template < std::size_t Max_Capture_Groups = 20, int Compile_Options = 0, int Match_Options = 0 >
struct pcre2_traits_t
{
    static constexpr std::size_t max_capture_groups = Max_Capture_Groups;
    static constexpr int compile_options = Compile_Options;
    static constexpr int match_options = Match_Options;
};
 
//
// pcre2_regex_engine_t
//
 
//! Regex engine implementation for PCRE2.
template < typename Traits = pcre2_traits_t<> >
struct pcre2_regex_engine_t
{
    using compiled_regex_t = pcre2_details::regex_t;
    using match_results_t = pcre2_details::match_results_t< Traits >;
    using matched_item_descriptor_t = typename  match_results_t::matched_item_descriptor_t;
 
    // Max itemes that can be captured be pcre engine.
    static constexpr std::size_t
    max_capture_groups()
    {
        return Traits::max_capture_groups;
    }
 
    //! Create compiled regex object for a given route.
    static auto
    compile_regex(
        //! Regular expression (the pattern).
        string_view_t r,
        //! Option for case sensativity.
        bool is_case_sensative )
    {
        int options = Traits::compile_options;
 
        if( !is_case_sensative )
        {
            options |= PCRE2_CASELESS;
        }
 
        return compiled_regex_t{ r, options };
    }
 
    //! Wrapper function for matching logic invokation.
    static auto
    try_match(
        string_view_t target_path,
        const compiled_regex_t & r,
        match_results_t & match_results )
    {
        const int rc =
            pcre2_match(
                r.pcre2_regex(),
                reinterpret_cast< const unsigned char* >( target_path.data() ),
                target_path.size(),
                0, // startoffset
                Traits::match_options,
                match_results.m_match_data,
                nullptr );
 
        if( rc > 0 )
        {
            match_results.m_size = static_cast<std::size_t>(rc);
            return true;
        }
        else if( rc == 0 )
        {
            // This should not happen,
            // because the number of groups is checked when creating route matcher.
            throw exception_t{ "unexpected: not enough submatch vector size" };
        }
        if( PCRE2_ERROR_NOMATCH != rc )
        {
            throw exception_t{
                fmt::format( RESTINIO_FMT_FORMAT_STRING( "pcre2 error: {}" ), rc ) };
        }
        // else PCRE2_ERROR_NOMATCH -- no match for this route
 
        return false;
    }
 
    //! Get the beginning of a submatch.
    static auto
    submatch_begin_pos( const matched_item_descriptor_t & m )
    {
        return static_cast< std::size_t >( m.m_begin );
    }
 
    //! Get the end of a submatch.
    static auto
    submatch_end_pos( const matched_item_descriptor_t & m )
    {
        return static_cast< std::size_t >( m.m_end );
    }
};
 
} /* namespace router */
 
} /* namespace restinio */