// -- operator_actions.hpp - Boost Lambda Library ----------------------

// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)

//

// 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)

// For more information, see http://lambda.cs.utu.fi 

#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP

#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP

namespace boost { 

namespace lambda {

// -- artihmetic ----------------------

class plus_action {};

class minus_action {};

class multiply_action {};

class divide_action {};

class remainder_action {};

// -- bitwise  -------------------

class leftshift_action {};

class rightshift_action {};

class xor_action {};

// -- bitwise/logical -------------------

class and_action {};

class or_action {};

class not_action {};

// -- relational -------------------------

class less_action {};

class greater_action {};

class lessorequal_action {};

class greaterorequal_action {};

class equal_action {};

class notequal_action {};

// -- increment/decrement ------------------------------

class increment_action {};

class decrement_action {};

// -- void return ------------------------------

// -- other  ------------------------------

class addressof_action {};

  // class comma_action {}; // defined in actions.hpp

class contentsof_action {};

// class member_pointer_action {}; (defined in member_ptr.hpp)

// -- actioun group templates --------------------

template <class Action> class arithmetic_action;

template <class Action> class bitwise_action;

template <class Action> class logical_action;

template <class Action> class relational_action;

template <class Action> class arithmetic_assignment_action;

template <class Action> class bitwise_assignment_action;

template <class Action> class unary_arithmetic_action;

template <class Action> class pre_increment_decrement_action;

template <class Action> class post_increment_decrement_action;

// ---------------------------------------------------------

  // actions, for which the existence of protect is checked in return type 

  // deduction.

template <class Act> struct is_protectable<arithmetic_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct is_protectable<bitwise_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct is_protectable<logical_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct is_protectable<relational_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> 

struct is_protectable<arithmetic_assignment_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> 

struct is_protectable<pre_increment_decrement_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <class Act> struct 

is_protectable<post_increment_decrement_action<Act> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <> struct is_protectable<other_action<addressof_action> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template <> struct is_protectable<other_action<contentsof_action> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template<> struct is_protectable<other_action<subscript_action> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

template<> struct is_protectable<other_action<assignment_action> > {

  BOOST_STATIC_CONSTANT(bool, value = true);

};

// NOTE: comma action is also protectable, but the specialization is

  // in actions.hpp

} // namespace lambda 

} // namespace boost

#endif