#pragma once

#ifndef TCG_BASE_H
#define TCG_BASE_H

namespace tcg {

/*!
  \file   tcg_base.h

  \brief  This file contains the implementation of some handy base classes
          that can be inherited from.
*/

//========================================================================

/*!
  \brief  The empty_type can be used as default template parameter in cases
          where the template parameter may be omitted.
*/
struct empty_type {};

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

/*!
  \brief  The noncopyable class can be inherited to forbid access to the
          copy constructor and assignment operator.

  \note   A template parameter is provided to permit the empty base
          class optimization. In case this optimization is not needed,
          please use boost::noncopyable instead.
*/

template <typename B = empty_type>
struct noncopyable : public B {
  noncopyable() {}
  // noncopyable(const B& b) : B(b) {}                 // Would introduce
  // additional copies
  // along the inheritance chain. Not worth it.
protected:
  ~noncopyable() {}  //!< Protected destructor since the class
                     //!  is intended for nonvirtual inheritance.
private:
  noncopyable(const noncopyable &);  //!< Non-accessible copy constructor.
  noncopyable &operator=(
      const noncopyable &);  //!< Non-accessible assignment operator.
};

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

/*!
  \brief    The polymorphic class just implements an empty class
            with a virtual destructor.

  \details  It can be useful in certain occasions:

              \li Explicitly marks derived classes as polymporphic, and
                  spares the need to write a virtual destructor.
              \li It's noncopyable, disabling value semantics.
              \li Provides a common base class to polymorphic hierarchies.
              \li Enables lightweight type erasure without resorting to
                  a wrapper class like boost::any, assuming you have
                  enough control of the involved class to add a base class.
*/

class polymorphic : noncopyable<>  // Noncopyable to prevent slicing
{
protected:
  polymorphic() {}  //!< Protected constructor to ensure that the
                    //!  class is only used as base class.
public:
  virtual ~polymorphic() {}  //!< A virtual destructor as every good base
                             //!  class must have.
};

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

/*!
  The tcg::safe_bool template class is a simple implementation
  of the classic Safe Bool Idiom, meant to be used inside tcg.

  For a better implementation, you should consider looking into
  Boost.Spirit.Safe_Bool.
*/

template <typename T, typename B = empty_type>  // B is used for base class
                                                // chaining, to deal with
                                                class safe_bool
    : public B  // the empty class optimization
{
  class dummy {};
  struct detail {
    dummy *member;
  };

public:
  typedef dummy *detail::*bool_type;

public:
  safe_bool() {}
  // safe_bool(const B& b) : B(b) {}         // Would introduce additional
  // copies
  // along the inheritance chain. Not worth it.
  operator bool_type() const {
    return static_cast<const T *>(this)->operator_bool() ? &detail::member : 0;
  }

protected:
  ~safe_bool() {}  //!< Protected destructor since the class
                   //!  is intended for nonvirtual inheritance.
private:
  bool operator==(const safe_bool &);
  bool operator!=(const safe_bool &);
};

}  // namespace tcg

#endif  // TCG_BASE_H