/src/contrib/boost/spirit/home/classic/phoenix/special_ops.hpp
http://pythonocc.googlecode.com/ · C++ Header · 341 lines · 192 code · 38 blank · 111 comment · 6 complexity · 2a33ea5a90e315057dbe68494bdc244a MD5 · raw file
- /*=============================================================================
- Phoenix V1.2.1
- Copyright (c) 2001-2002 Joel de Guzman
- 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)
- ==============================================================================*/
- #ifndef PHOENIX_SPECIAL_OPS_HPP
- #define PHOENIX_SPECIAL_OPS_HPP
- #include <boost/config.hpp>
- #ifdef BOOST_NO_STRINGSTREAM
- #include <strstream>
- #define PHOENIX_SSTREAM strstream
- #else
- #include <sstream>
- #define PHOENIX_SSTREAM stringstream
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- #include <boost/spirit/home/classic/phoenix/operators.hpp>
- #include <iosfwd>
- ///////////////////////////////////////////////////////////////////////////////
- #if defined(_STLPORT_VERSION) && defined(__STL_USE_OWN_NAMESPACE)
- #define PHOENIX_STD _STLP_STD
- #define PHOENIX_NO_STD_NAMESPACE
- #else
- #define PHOENIX_STD std
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- //#if !defined(PHOENIX_NO_STD_NAMESPACE)
- namespace PHOENIX_STD
- {
- //#endif
- template<typename T> class complex;
- //#if !defined(PHOENIX_NO_STD_NAMESPACE)
- }
- //#endif
- ///////////////////////////////////////////////////////////////////////////////
- namespace phoenix
- {
- ///////////////////////////////////////////////////////////////////////////////
- //
- // The following specializations take into account the C++ standard
- // library components. There are a couple of issues that have to be
- // dealt with to enable lazy operator overloads for the standard
- // library classes.
- //
- // *iostream (e.g. cout, cin, strstream/ stringstream) uses non-
- // canonical shift operator overloads where the lhs is taken in
- // by reference.
- //
- // *I/O manipulators overloads for the RHS of the << and >>
- // operators.
- //
- // *STL iterators can be objects that conform to pointer semantics.
- // Some operators need to be specialized for these.
- //
- // *std::complex is given a rank (see rank class in operators.hpp)
- //
- ///////////////////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////////////////////////////////
- //
- // specialization for rank<std::complex>
- //
- ///////////////////////////////////////////////////////////////////////////////
- template <typename T> struct rank<PHOENIX_STD::complex<T> >
- { static int const value = 170 + rank<T>::value; };
- ///////////////////////////////////////////////////////////////////////////////
- //
- // specializations for std::istream
- //
- ///////////////////////////////////////////////////////////////////////////////
- #if defined(__GNUC__) && (__GNUC__ < 3)
- #if defined(_STLPORT_VERSION)
- #define PHOENIX_ISTREAM _IO_istream_withassign
- #else
- #define PHOENIX_ISTREAM PHOENIX_STD::_IO_istream_withassign
- #endif
- #else
- // #if (defined(__ICL) && defined(_STLPORT_VERSION))
- // #define PHOENIX_ISTREAM istream_withassign
- // #else
- #define PHOENIX_ISTREAM PHOENIX_STD::istream
- // #endif
- #endif
- //////////////////////////////////
- #if defined(__GNUC__) && (__GNUC__ < 3)
- // || (defined(__ICL) && defined(_STLPORT_VERSION))
- template <typename T1>
- struct binary_operator<shift_r_op, PHOENIX_ISTREAM, T1>
- {
- typedef PHOENIX_STD::istream& result_type;
- static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
- { return out >> rhs; }
- };
- #endif
- //////////////////////////////////
- template <typename T1>
- struct binary_operator<shift_r_op, PHOENIX_STD::istream, T1>
- {
- typedef PHOENIX_STD::istream& result_type;
- static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
- { return out >> rhs; }
- };
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary3
- <shift_r_op, variable<PHOENIX_ISTREAM>, BaseT>::type
- operator>>(PHOENIX_ISTREAM& _0, actor<BaseT> const& _1)
- {
- return impl::make_binary3
- <shift_r_op, variable<PHOENIX_ISTREAM>, BaseT>
- ::construct(var(_0), _1);
- }
- #undef PHOENIX_ISTREAM
- ///////////////////////////////////////////////////////////////////////////////
- //
- // specializations for std::ostream
- //
- ///////////////////////////////////////////////////////////////////////////////
- #if defined(__GNUC__) && (__GNUC__ < 3)
- #if defined(_STLPORT_VERSION)
- #define PHOENIX_OSTREAM _IO_ostream_withassign
- #else
- #define PHOENIX_OSTREAM PHOENIX_STD::_IO_ostream_withassign
- #endif
- #else
- // #if (defined(__ICL) && defined(_STLPORT_VERSION))
- // #define PHOENIX_OSTREAM ostream_withassign
- // #else
- #define PHOENIX_OSTREAM PHOENIX_STD::ostream
- // #endif
- #endif
- //////////////////////////////////
- #if defined(__GNUC__) && (__GNUC__ < 3)
- // || (defined(__ICL) && defined(_STLPORT_VERSION))
- template <typename T1>
- struct binary_operator<shift_l_op, PHOENIX_OSTREAM, T1>
- {
- typedef PHOENIX_STD::ostream& result_type;
- static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
- { return out << rhs; }
- };
- #endif
- //////////////////////////////////
- template <typename T1>
- struct binary_operator<shift_l_op, PHOENIX_STD::ostream, T1>
- {
- typedef PHOENIX_STD::ostream& result_type;
- static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
- { return out << rhs; }
- };
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary3
- <shift_l_op, variable<PHOENIX_OSTREAM>, BaseT>::type
- operator<<(PHOENIX_OSTREAM& _0, actor<BaseT> const& _1)
- {
- return impl::make_binary3
- <shift_l_op, variable<PHOENIX_OSTREAM>, BaseT>
- ::construct(var(_0), _1);
- }
- #undef PHOENIX_OSTREAM
- ///////////////////////////////////////////////////////////////////////////////
- //
- // specializations for std::strstream / stringstream
- //
- ///////////////////////////////////////////////////////////////////////////////
- template <typename T1>
- struct binary_operator<shift_r_op, PHOENIX_STD::PHOENIX_SSTREAM, T1>
- {
- typedef PHOENIX_STD::istream& result_type;
- static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
- { return out >> rhs; }
- };
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary3
- <shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type
- operator>>(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1)
- {
- return impl::make_binary3
- <shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>
- ::construct(var(_0), _1);
- }
- //////////////////////////////////
- template <typename T1>
- struct binary_operator<shift_l_op, PHOENIX_STD::PHOENIX_SSTREAM, T1>
- {
- typedef PHOENIX_STD::ostream& result_type;
- static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
- { return out << rhs; }
- };
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary3
- <shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type
- operator<<(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1)
- {
- return impl::make_binary3
- <shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>
- ::construct(var(_0), _1);
- }
- ///////////////////////////////////////////////////////////////////////////////
- //
- // I/O manipulator specializations
- //
- ///////////////////////////////////////////////////////////////////////////////
- #if (!defined(__GNUC__) || (__GNUC__ > 2))
- // && !(defined(__ICL) && defined(_STLPORT_VERSION))
- typedef PHOENIX_STD::ios_base& (*iomanip_t)(PHOENIX_STD::ios_base&);
- typedef PHOENIX_STD::istream& (*imanip_t)(PHOENIX_STD::istream&);
- typedef PHOENIX_STD::ostream& (*omanip_t)(PHOENIX_STD::ostream&);
- #if defined(__BORLANDC__)
- ///////////////////////////////////////////////////////////////////////////////
- //
- // Borland does not like i/o manipulators functions such as endl to
- // be the rhs of a lazy << operator (Borland incorrectly reports
- // ambiguity). To get around the problem, we provide function
- // pointer versions of the same name with a single trailing
- // underscore.
- //
- // You can use the same trick for other i/o manipulators.
- // Alternatively, you can prefix the manipulator with a '&'
- // operator. Example:
- //
- // cout << arg1 << &endl
- //
- ///////////////////////////////////////////////////////////////////////////////
- imanip_t ws_ = &PHOENIX_STD::ws;
- iomanip_t dec_ = &PHOENIX_STD::dec;
- iomanip_t hex_ = &PHOENIX_STD::hex;
- iomanip_t oct_ = &PHOENIX_STD::oct;
- omanip_t endl_ = &PHOENIX_STD::endl;
- omanip_t ends_ = &PHOENIX_STD::ends;
- omanip_t flush_ = &PHOENIX_STD::flush;
- #else // __BORLANDC__
- ///////////////////////////////////////////////////////////////////////////////
- //
- // The following are overloads for I/O manipulators.
- //
- ///////////////////////////////////////////////////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary1<shift_l_op, BaseT, imanip_t>::type
- operator>>(actor<BaseT> const& _0, imanip_t _1)
- {
- return impl::make_binary1<shift_l_op, BaseT, imanip_t>::construct(_0, _1);
- }
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type
- operator>>(actor<BaseT> const& _0, iomanip_t _1)
- {
- return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1);
- }
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary1<shift_l_op, BaseT, omanip_t>::type
- operator<<(actor<BaseT> const& _0, omanip_t _1)
- {
- return impl::make_binary1<shift_l_op, BaseT, omanip_t>::construct(_0, _1);
- }
- //////////////////////////////////
- template <typename BaseT>
- inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type
- operator<<(actor<BaseT> const& _0, iomanip_t _1)
- {
- return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1);
- }
- #endif // __BORLANDC__
- #endif // !defined(__GNUC__) || (__GNUC__ > 2)
- ///////////////////////////////////////////////////////////////////////////////
- //
- // specializations for stl iterators and containers
- //
- ///////////////////////////////////////////////////////////////////////////////
- template <typename T>
- struct unary_operator<dereference_op, T>
- {
- typedef typename T::reference result_type;
- static result_type eval(T const& iter)
- { return *iter; }
- };
- //////////////////////////////////
- template <typename T0, typename T1>
- struct binary_operator<index_op, T0, T1>
- {
- typedef typename T0::reference result_type;
- static result_type eval(T0& container, T1 const& index)
- { return container[index]; }
- };
- //////////////////////////////////
- template <typename T0, typename T1>
- struct binary_operator<index_op, T0 const, T1>
- {
- typedef typename T0::const_reference result_type;
- static result_type eval(T0 const& container, T1 const& index)
- { return container[index]; }
- };
- ///////////////////////////////////////////////////////////////////////////////
- } // namespace phoenix
- #undef PHOENIX_SSTREAM
- #undef PHOENIX_STD
- #endif