#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"></typename>

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 b="empty_type" t,="" typename="">  // B is used for base class</typename>

// 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;</const>

  }

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