//  extending_return_type_traits.cpp  -- The Boost Lambda Library --------
//
// Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
// Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com)
//
// 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 www.boost.org

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


#include <boost/test/minimal.hpp>    // see "Header Implementation Option"

#include "boost/lambda/bind.hpp"
#include "boost/lambda/lambda.hpp"
#include "boost/lambda/detail/suppress_unused.hpp"

#include <iostream>

#include <functional>

#include <algorithm>

using boost::lambda::detail::suppress_unused_variable_warnings;

class A {};
class B {};

using namespace boost::lambda; 


B operator--(const A&, int) { return B(); }
B operator--(A&) { return B(); }
B operator++(const A&, int) { return B(); }
B operator++(A&) { return B(); }
B operator-(const A&) { return B(); }
B operator+(const A&) { return B(); }

B operator!(const A&) { return B(); }

B operator&(const A&) { return B(); }
B operator*(const A&) { return B(); }

namespace boost {
namespace lambda {

  // unary + and -
template<class Act>
struct plain_return_type_1<unary_arithmetic_action<Act>, A > {
  typedef B type;
};

  // post incr/decr
template<class Act>
struct plain_return_type_1<post_increment_decrement_action<Act>, A > {
  typedef B type;
};

  // pre incr/decr
template<class Act>
struct plain_return_type_1<pre_increment_decrement_action<Act>, A > {
  typedef B type;
};
  // !
template<> 
struct plain_return_type_1<logical_action<not_action>, A> {
  typedef B type;
};
  // &
template<> 
struct plain_return_type_1<other_action<addressof_action>, A> {
  typedef B type;
};
  // *
template<> 
struct plain_return_type_1<other_action<contentsof_action>, A> {
  typedef B type;
};


} // lambda
} // boost

void ok(B /*b*/) {}

void test_unary_operators() 
{
  A a; int i = 1;
  ok((++_1)(a));
  ok((--_1)(a));
  ok((_1++)(a));
  ok((_1--)(a));
  ok((+_1)(a));
  ok((-_1)(a));
  ok((!_1)(a));
  ok((&_1)(a));
  ok((*_1)(a));

  BOOST_CHECK((*_1)(make_const(&i)) == 1);
}

class X {};
class Y {};
class Z {};

Z operator+(const X&, const Y&) { return Z(); }
Z operator-(const X&, const Y&) { return Z(); }
X operator*(const X&, const Y&) { return X(); }

Z operator/(const X&, const Y&) { return Z(); }
Z operator%(const X&, const Y&) { return Z(); }

class XX {};
class YY {};
class ZZ {};
class VV {};

// it is possible to support differently cv-qualified versions
YY operator*(XX&, YY&) { return YY(); }
ZZ operator*(const XX&, const YY&) { return ZZ(); }
XX operator*(volatile XX&, volatile YY&) { return XX(); }
VV operator*(const volatile XX&, const volatile YY&) { return VV(); }

// the traits can be more complex:
template <class T>
class my_vector {};

template<class A, class B> 
my_vector<typename return_type_2<arithmetic_action<plus_action>, A&, B&>::type>
operator+(const my_vector<A>& /*a*/, const my_vector<B>& /*b*/)
{
  typedef typename 
    return_type_2<arithmetic_action<plus_action>, A&, B&>::type res_type;
  return my_vector<res_type>();
}



// bitwise ops:
X operator<<(const X&, const Y&) { return X(); }
Z operator>>(const X&, const Y&) { return Z(); }
Z operator&(const X&, const Y&) { return Z(); }
Z operator|(const X&, const Y&) { return Z(); }
Z operator^(const X&, const Y&) { return Z(); }

// comparison ops:

X operator<(const X&, const Y&) { return X(); }
Z operator>(const X&, const Y&) { return Z(); }
Z operator<=(const X&, const Y&) { return Z(); }
Z operator>=(const X&, const Y&) { return Z(); }
Z operator==(const X&, const Y&) { return Z(); }
Z operator!=(const X&, const Y&) { return Z(); }

// logical 

X operator&&(const X&, const Y&) { return X(); }
Z operator||(const X&, const Y&) { return Z(); }

// arithh assignment

Z operator+=( X&, const Y&) { return Z(); }
Z operator-=( X&, const Y&) { return Z(); }
Y operator*=( X&, const Y&) { return Y(); }
Z operator/=( X&, const Y&) { return Z(); }
Z operator%=( X&, const Y&) { return Z(); }

// bitwise assignment
Z operator<<=( X&, const Y&) { return Z(); }
Z operator>>=( X&, const Y&) { return Z(); }
Y operator&=( X&, const Y&) { return Y(); }
Z operator|=( X&, const Y&) { return Z(); }
Z operator^=( X&, const Y&) { return Z(); }

// assignment
class Assign {
public:
  void operator=(const Assign& /*a*/) {}
  X operator[](const int& /*i*/) { return X(); }
};



namespace boost {
namespace lambda {
  
  // you can do action groups
template<class Act> 
struct plain_return_type_2<arithmetic_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<arithmetic_action<multiply_action>, X, Y> {
  typedef X type;
};

  // if you want to make a distinction between differently cv-qualified
  // types, you need to specialize on a different level:
template<> 
struct return_type_2<arithmetic_action<multiply_action>, XX, YY> {
  typedef YY type;
};
template<> 
struct return_type_2<arithmetic_action<multiply_action>, const XX, const YY> {
  typedef ZZ type;
};
template<> 
struct return_type_2<arithmetic_action<multiply_action>, volatile XX, volatile YY> {
  typedef XX type;
};
template<> 
struct return_type_2<arithmetic_action<multiply_action>, volatile const XX, const volatile YY> {
  typedef VV type;
};

  // the mapping can be more complex:
template<class A, class B> 
struct plain_return_type_2<arithmetic_action<plus_action>, my_vector<A>, my_vector<B> > {
  typedef typename 
    return_type_2<arithmetic_action<plus_action>, A&, B&>::type res_type;
  typedef my_vector<res_type> type;
};

  // bitwise binary:
  // you can do action groups
template<class Act> 
struct plain_return_type_2<bitwise_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<bitwise_action<leftshift_action>, X, Y> {
  typedef X type;
};

  // comparison binary:
  // you can do action groups
template<class Act> 
struct plain_return_type_2<relational_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<relational_action<less_action>, X, Y> {
  typedef X type;
};

  // logical binary:
  // you can do action groups
template<class Act> 
struct plain_return_type_2<logical_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<logical_action<and_action>, X, Y> {
  typedef X type;
};

  // arithmetic assignment :
  // you can do action groups
template<class Act> 
struct plain_return_type_2<arithmetic_assignment_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<arithmetic_assignment_action<multiply_action>, X, Y> {
  typedef Y type;
};

  // arithmetic assignment :
  // you can do action groups
template<class Act> 
struct plain_return_type_2<bitwise_assignment_action<Act>, X, Y> {
  typedef Z type;
};

  // or specialize the exact action
template<> 
struct plain_return_type_2<bitwise_assignment_action<and_action>, X, Y> {
  typedef Y type;
};

  // assignment
template<> 
struct plain_return_type_2<other_action<assignment_action>, Assign, Assign> {
  typedef void type;
};
  // subscript
template<> 
struct plain_return_type_2<other_action<subscript_action>, Assign, int> {
  typedef X type;
};


} // end lambda
} // end boost



void test_binary_operators() {

  X x; Y y;
  (_1 + _2)(x, y);
  (_1 - _2)(x, y);
  (_1 * _2)(x, y);
  (_1 / _2)(x, y);
  (_1 % _2)(x, y);


  // make a distinction between differently cv-qualified operators
  XX xx; YY yy;
  const XX& cxx = xx;
  const YY& cyy = yy;
  volatile XX& vxx = xx;
  volatile YY& vyy = yy;
  const volatile XX& cvxx = xx;
  const volatile YY& cvyy = yy;

  ZZ dummy1 = (_1 * _2)(cxx, cyy);
  YY dummy2 = (_1 * _2)(xx, yy);
  XX dummy3 = (_1 * _2)(vxx, vyy);
  VV dummy4 = (_1 * _2)(cvxx, cvyy);

  suppress_unused_variable_warnings(dummy1);
  suppress_unused_variable_warnings(dummy2);
  suppress_unused_variable_warnings(dummy3);
  suppress_unused_variable_warnings(dummy4);

  my_vector<int> v1; my_vector<double> v2;
  my_vector<double> d = (_1 + _2)(v1, v2);

  suppress_unused_variable_warnings(d);

  // bitwise

  (_1 << _2)(x, y);
  (_1 >> _2)(x, y);
  (_1 | _2)(x, y);
  (_1 & _2)(x, y);
  (_1 ^ _2)(x, y);

  // comparison
  
  (_1 < _2)(x, y);
  (_1 > _2)(x, y);
  (_1 <= _2)(x, y);
  (_1 >= _2)(x, y);
  (_1 == _2)(x, y);
  (_1 != _2)(x, y);

  // logical
 
  (_1 || _2)(x, y);
  (_1 && _2)(x, y);

  // arithmetic assignment
  (_1 += _2)(x, y);
  (_1 -= _2)(x, y);
  (_1 *= _2)(x, y);
  (_1 /= _2)(x, y);
  (_1 %= _2)(x, y);
 
  // bitwise assignment
  (_1 <<= _2)(x, y);
  (_1 >>= _2)(x, y);
  (_1 |= _2)(x, y);
  (_1 &= _2)(x, y);
  (_1 ^= _2)(x, y);

}


int test_main(int, char *[]) {
  test_unary_operators();
  test_binary_operators();
  return 0;
}