// Copyright Krzysztof Czainski 2011
// 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)

/**
 * @file cz/boost/utility/safe_bool.hpp
 * Introduction by Vladimir Batov:
 * An implicit conversion to bool (operator bool() const) is very much
 * idiomatic and is often deployed in constructs like "if (foo)" and "if (!foo)"
 * (with no explicit op!() defined). However, sadly, implementing "operator bool()"
 * is *wrong* as that conversion kicks in far too often and unexpectedly. Like in
 * "foo == 1", "foo+1", "1+foo" or potentially during lexical_cast<string>(foo)
 * (if there are no op>>() and op<<() defined). Consequently, that "implicit
 * conversion to bool" functionality has to be implemented in an indirect and
 * somewhat awkward way via an implicit conversion to some other type. The best
 * type for the purpose appears to be a pointer to a member variable. For more
 * see the chapter 7.7 in Alexandrescu's "Modern C++ Design" and the article at 
 * http://www.artima.com/cppsource/safebool.html by Bjorn Karlsson.
 *
 * @warning by Stephan T. Lavavej: Having done this in the STL, I can offer the following
 *  warning: you'll need to generate a different fake-bool type for every class, otherwise things
 *  will be [in]equality comparable that should not be.
 *
 * @since 31-05-2011
 * @author Krzysztof Czainski
 */

#ifndef HPP_CZBOOSTUTILITY_SAFE_BOOL_
#define HPP_CZBOOSTUTILITY_SAFE_BOOL_

#include "./empty_base.hpp"

#include <boost/detail/workaround.hpp>

namespace boost { namespace utility {

struct as_bool_policy_operator_not
{
	template < class T >
	static bool as_bool( T const& x )
	{
		return ! ! x;
	}
};

/**
 * CRTP class, that provides a safe-conversion-to-bool operator, implemented in terms of
 * Derived::operator!
 *
 * @tparam Derived the derived class
 * @tparam Babe a public base class for base class chaining
 *
 * Usage: @see safe_bool_t
 */
template < class Derived, class Base = empty_t, class AsBoolPolicy = as_bool_policy_operator_not >
class safe_bool_convertible : public Base
{

#if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) \
	|| defined(__CINT__)
	// From <boost/smart_ptr/detail/operator_bool.hpp>

	typedef bool unspecified_bool_t;

	static unspecified_bool_t unspedified_bool_true()
	{
		return true;
	}

#elif defined( _MANAGED )
	// From <boost/smart_ptr/detail/operator_bool.hpp>

	static void unspecified_bool_true_( Derived*** )
	{}

	typedef void (*unspecified_bool_t)( Derived*** );

	static unspecified_bool_t unspecified_bool_true()
	{
		return unspecified_bool_true_;
	}

#elif ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
	( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
	( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
	// From <boost/smart_ptr/detail/operator_bool.hpp>

	void unspecified_bool_true_() const
	{	}

	typedef void (safe_bool_convertible::*unspecified_bool_t)() const;

	static unspecified_bool_t unspecified_bool_true()
	{
		return &safe_bool_convertible::unspedified_bool_true_;
	}

#else

	/*
	 * A pointer to members of unspecified_bool_t_struct will be the unspecified_bool_t
	 */
	struct unspecified_bool_t_struct
	{
		/**
		 * Jeffrey Lee Hellrung, Jr.:
		 * According to Andrey Semashev, you do need two data members, as some compilers
		 * interpret a pointer-to-first-member as equal to 0 (i.e., convertible to false).
		 */
		Derived* dummy;

		/**
		 * A pointer to @c true_ will be the value @c true for unspecified_bool_t
		 */
		Derived* true_;
	};

	typedef Derived* unspecified_bool_t_struct::*unspecified_bool_t;

	static unspecified_bool_t unspecified_bool_true()
	{
		return &unspecified_bool_t_struct::true_;
	}

#endif

public:

	operator unspecified_bool_t() const
	{
		return AsBoolPolicy::as_bool( static_cast<Derived const&>( *this ) ) ? unspecified_bool_true() : 0;
	}

};

/**
 * Safe_bool_t is a stand-alone type safely convertible to bool.
 *
 * @note Safe_bool_t is implemented in terms of safe-bool_convertible.
 *
 * Usage:
 * @code
 * struct X
 * {
 *   bool i_am_ok() const;
 *   operator safe_bool_t<X>() const \
 *   { return safe_bool_t<X>(expr); }
 * };
 * @endcode
 */
template < class Tag >
class safe_bool_t : public safe_bool_convertible< safe_bool_t<Tag> >
{
public:

	explicit safe_bool_t( bool value = false ) : value_(value)
	{}

	bool operator!() const
	{
		return ! value_;
	}

private:

	bool value_;
};

/**
 * Supply implicit conversion to safe_bool_t inside a class.
 *
 * @author Robert Stewart suggested only one macro BOOST_OPERATOR_SAFE_BOOL(expr)
 *
 * @param tag makes the safe_bool type distinct; may be incomplete or the containing class
 * @param expr the boolean expression returned
 *
 * Usage:
 * @code
 * struct X
 * {
 *   bool i_am_ok() const;
 *   BOOST_OPERATOR_SAFE_BOOL_TAGGED( X, i_am_ok() )
 * };
 * @endcode
 */
#define BOOST_OPERATOR_SAFE_BOOL_TAGGED( tag, expr ) \
	operator ::boost::utility::safe_bool_t<tag>() const \
	{ return ::boost::utility::safe_bool_t<tag>(expr); }

/**
 * Supply implicit conversion to safe_bool_t inside a class.
 *
 * @note Also inserts an incomplete type named safe_bool_tag_ into the class.
 *
 * @author Robert Stewart suggested only one macro BOOST_OPERATOR_SAFE_BOOL(expr)
 *
 * @param expr the boolean expression returned
 *
 * Usage:
 * @code
 * struct X
 * {
 *   bool i_am_ok() const;
 *   BOOST_OPERATOR_SAFE_BOOL( i_am_ok() )
 * };
 * @endcode
 */
#define BOOST_OPERATOR_SAFE_BOOL( expr ) \
	struct safe_bool_tag_; \
	BOOST_OPERATOR_SAFE_BOOL_TAGGED( safe_bool_tag_, expr )

/**
 * @def BOOST_EXPLICIT_OPERATOR_BOOL(expr)
 *
 * Supply explicit conversion to bool, if available, or fall back to
 * BOOST_OPERATOR_SAFE_BOOL(expr).
 *
 * @author Jeffrey Lee Hellrung, Jr. has suggested the use of explicit operator bool, if
 *  available.
 *
 * @warning Sebastian Redl:
 * You can only omit the case in "contextual conversion" situations, which are:
 * - Conditions of if, while, do..while and for (maybe switch? not sure);
 * - Arguments to &&, || and !;
 * - First argument to ?:.
 *
 * So these two code examples that a 03 user might write would fail:
 * @code
 * convertible_to_bool obj;
 * bool b = obj; // must write bool b(obj);
 * @endcode
 * @code
 * void fn(bool);
 * fn(obj); // must cast
 * @endcode
 */

#if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)

#define BOOST_EXPLICIT_OPERATOR_BOOL(expr) \
	BOOST_OPERATOR_SAFE_BOOL(expr)

#else // BOOST_NO_EXPLICIT_CONVERSION_OPERATORS

#define BOOST_EXPLICIT_OPERATOR_BOOL(expr) \
	explicit operator bool() const \
	{ return expr; }

#endif // BOOST_NO_EXPLICIT_CONVERSION_OPERATORS

}} // boost::utility

#endif // HPP_CZBOOSTUTILITY_SAFE_BOOL_