/*=============================================================================
    Copyright (c) 2003 Hartmut Kaiser
    http://spirit.sourceforge.net/

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef BOOST_SPIRIT_XPRESSIVE_HPP
#define BOOST_SPIRIT_XPRESSIVE_HPP

#include <boost/static_assert.hpp>

///////////////////////////////////////////////////////////////////////////////
//
//  Include the Xpressive regular expression library
//
//  Note though, that this library is not distributed with Spirit. You have to
//  obtain a separate copy from the Boost Sandbox CVS.
//
///////////////////////////////////////////////////////////////////////////////
#include <boost/xpressive/xpressive.hpp>

///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/core/parser.hpp>
#include <boost/spirit/core/composite/directives.hpp>

#include <boost/spirit/utility/impl/xpressive.ipp>

///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {

///////////////////////////////////////////////////////////////////////////////
// xpressive_strlit class
template <typename IteratorT>
class xpressive_strlit
:   public parser<xpressive_strlit<IteratorT> >
{
public:
    typedef xpressive_strlit<IteratorT> self_t;

    template <typename ScannerT>
    struct result
    {
        typedef xpressive::basic_match_results<IteratorT> result_t;
        typedef typename match_result<ScannerT, result_t>::type type;
    };

    xpressive_strlit(IteratorT first, IteratorT last)
    :   xp(first, last) {}

    xpressive_strlit(IteratorT first)
    :   xp(first) {}

    xpressive_strlit(xpressive::basic_regex<IteratorT> const &pattern)
    :   xp(pattern) {}

    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
    //  Due to the nature of the Xpressive regex implementation the iterators
    //  wrapped in the ScannerT object should be at least bidirectional
    //  iterators. Plain forward iterators do not work here.
        typedef typename ScannerT::iterator_t iterator_t;
        typedef
            typename std::iterator_traits<iterator_t>::iterator_category
            iterator_category;

        BOOST_STATIC_ASSERT((
            boost::is_convertible<iterator_category,
                std::bidirectional_iterator_tag>::value
        ));

        typedef typename parser_result<self_t, ScannerT>::type result_t;
        return impl::contiguous_parser_parse<result_t>(xp, scan, scan);
    }

private:
    impl::xpressive_parser<IteratorT> xp;
};

///////////////////////////////////////////////////////////////////////////////
// Generator functions
template <typename CharT>
inline xpressive_strlit<CharT const *>
xpressive_p(CharT const *first)
{
    return xpressive_strlit<CharT const *>(first);
}

//////////////////////////////////
template <typename CharT>
inline xpressive_strlit<CharT const *>
xpressive_p(CharT const *first, CharT const *last)
{
    return xpressive_strlit<CharT const *>(first, last);
}

//////////////////////////////////
template <typename IteratorT>
inline xpressive_strlit<IteratorT>
xpressive_p(xpressive::basic_regex<IteratorT> const &pattern)
{
    return xpressive_strlit<IteratorT>(pattern);
}

///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit

#endif // BOOST_SPIRIT_XPRESSIVE_HPP