/*============================================================================= | |
Copyright (c) 1998-2003 Joel de Guzman | |
http://spirit.sourceforge.net/ | |
Distributed under 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) | |
=============================================================================*/ | |
#if !defined(BOOST_SPIRIT_STORED_RULE_HPP) | |
#define BOOST_SPIRIT_STORED_RULE_HPP | |
/////////////////////////////////////////////////////////////////////////////// | |
#include <boost/spirit/home/classic/namespace.hpp> | |
#include <boost/spirit/home/classic/core/non_terminal/impl/rule.ipp> | |
#include <boost/spirit/home/classic/dynamic/rule_alias.hpp> | |
#include <boost/shared_ptr.hpp> | |
#include <boost/spirit/home/classic/dynamic/stored_rule_fwd.hpp> | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
/////////////////////////////////////////////////////////////////////////// | |
// | |
// stored_rule class | |
// | |
/////////////////////////////////////////////////////////////////////////// | |
template < | |
typename T0 | |
, typename T1 | |
, typename T2 | |
, bool EmbedByValue | |
> | |
class stored_rule | |
: public impl::rule_base< | |
stored_rule<T0, T1, T2, EmbedByValue> | |
, typename mpl::if_c< | |
EmbedByValue | |
, stored_rule<T0, T1, T2, true> | |
, stored_rule<T0, T1, T2> const&>::type | |
, T0, T1, T2> | |
{ | |
public: | |
typedef stored_rule<T0, T1, T2, EmbedByValue> self_t; | |
typedef impl::rule_base< | |
self_t | |
, typename mpl::if_c< | |
EmbedByValue | |
, stored_rule<T0, T1, T2, true> | |
, self_t const&>::type | |
, T0, T1, T2> | |
base_t; | |
typedef typename base_t::scanner_t scanner_t; | |
typedef typename base_t::attr_t attr_t; | |
typedef impl::abstract_parser<scanner_t, attr_t> abstract_parser_t; | |
typedef rule_alias<self_t> alias_t; | |
stored_rule() : ptr() {} | |
~stored_rule() {} | |
stored_rule(stored_rule const& r) | |
: ptr(r.ptr) {} | |
template <typename ParserT> | |
stored_rule(ParserT const& p) | |
: ptr(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p)) {} | |
template <typename ParserT> | |
stored_rule& operator=(ParserT const& p) | |
{ | |
ptr.reset(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p)); | |
return *this; | |
} | |
stored_rule& operator=(stored_rule const& r) | |
{ | |
// If this is placed above the templatized assignment | |
// operator, VC6 incorrectly complains ambiguity with | |
// r1 = r2, where r1 and r2 are both rules. | |
ptr = r.ptr; | |
return *this; | |
} | |
stored_rule<T0, T1, T2, true> | |
copy() const | |
{ | |
return stored_rule<T0, T1, T2, true>(ptr); | |
} | |
alias_t | |
alias() const | |
{ | |
return alias_t(*this); | |
} | |
private: | |
friend class impl::rule_base_access; | |
friend class stored_rule<T0, T1, T2, !EmbedByValue>; | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
public: | |
#endif | |
abstract_parser_t* | |
get() const | |
{ | |
return ptr.get(); | |
} | |
#if defined(__GNUC__) && (__GNUC__ < 3) | |
private: | |
#endif | |
stored_rule(shared_ptr<abstract_parser_t> const& ptr) | |
: ptr(ptr) {} | |
shared_ptr<abstract_parser_t> ptr; | |
}; | |
/////////////////////////////////////////////////////////////////////////////// | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
}} // namespace BOOST_SPIRIT_CLASSIC_NS | |
#endif |