[/
  (C) Copyright 2009-2011  Frederic Bron.
  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).
]

[section:has_post_increment has_post_increment]
   template <class Lhs, class Ret=dont_care>
   struct has_post_increment : public __tof {};

__inherit
If (i) `lhs` of type `Lhs` can be used in expression `lhs++`,
and (ii) `Ret=dont_care` or the result of expression `lhs++` is convertible to `Ret`
then inherits from __true_type,
otherwise inherits from __false_type.

The default behaviour (`Ret=dont_care`) is to not check for the return value of postfix `operator++`.
If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
``
void f(Ret);
Lhs lhs;
f(lhs++); // is valid if has_post_increment<Lhs, Ret>::value==true
``
If `Ret=void`, the return type is checked to be exactly `void`.

__header `#include <boost/type_traits/has_post_increment.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`

[has_binary_operator_compat]

__examples

[:`has_post_increment<Lhs, Ret>::value_type` is the type `bool`.]
[:`has_post_increment<Lhs, Ret>::value` is a `bool` integral constant expression.]
[:`has_post_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
[:`has_post_increment<long>` inherits from `__true_type`.]

[:`has_post_increment<int, int>` inherits from `__true_type`.]
[:`has_post_increment<int, long>` inherits from `__true_type`.]
[:`has_post_increment<double, double>` inherits from `__true_type`.]
[:`has_post_increment<double, int>` inherits from `__true_type`.]
[:`has_post_increment<bool>` inherits from `__true_type`.]

[:`has_post_increment<const int>` inherits from `__false_type`.]
[:`has_post_increment<void*>` inherits from `__false_type`.]
[:`has_post_increment<int, std::string>` inherits from `__false_type`.]


[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]

[*Known issues:]

* This trait cannot detect whether postfix `operator++` is public or not:
if `operator++` is defined as a private member of `Lhs` then
instantiating `has_post_increment<Lhs>` will produce a compiler error.
For this reason `has_post_increment` cannot be used to determine whether a type has a public `operator++` or not.
``
struct A { private: void operator++(int); };
boost::has_post_increment<A>::value; // error: A::operator++(int) is private
``

* There is an issue if the operator exists only for type `A` and `B` is
convertible to `A`. In this case, the compiler will report an ambiguous overload.
``
struct A { };
void operator++(const A&, int);
struct B { operator A(); };
boost::has_post_increment<A>::value; // this is fine
boost::has_post_increment<B>::value; // error: ambiguous overload
``

* There is an issue when applying this trait to template classes.
If `operator++` is defined but does not bind for a given template type,
it is still detected by the trait which returns `true` instead of `false`.
Example:
``
#include <boost/type_traits/has_post_increment.hpp>
#include <iostream>

template <class T>
struct contains { T data; };

template <class T>
bool operator++(const contains<T> &lhs, int) {
	return f(lhs.data);
}

class bad { };
class good { };
bool f(const good&, const good&) { }

int main() {
	std::cout<<std::boolalpha;
	// works fine for contains<good>
	std::cout<<boost::has_post_increment< contains< good > >::value<<'\n'; // true
	contains<good> g;
	g++; // ok
	// does not work for contains<bad>
	std::cout<<boost::has_post_increment< contains< bad > >::value<<'\n'; // true, should be false
	contains<bad> b;
	b++; // compile time error
	return 0;
}
``

* `volatile` qualifier is not properly handled and would lead to undefined behavior

[prefix_operator_known_issues has_post_increment..++]

[endsect]

