#ifndef HolderH
#define HolderH
/*---------------------------------------------------------------------------
   Holder.hpp

   ---------------------------------------------------------------------------
   Copyright (C) 2009/01 - 2009 Nowake nowake@fircewinds.net
----------------------------------------------------------------------------*/

#include "Multimethod.hpp"

   ///////////////////////////////////////////////////////////////////////////
   // Original any for fast multi method
   ///////////////////////////////////////////////////////////////////////////
   class Holder {
   public:
      Holder() : caddy_(0) {};
      template<typename type_t> Holder(const type_t& value) : caddy_(new Container<type_t>(value)) {};
      Holder(const Holder& other) : caddy_(other.caddy_ ? other.caddy_->clone() : 0) {};
      ~Holder() { delete caddy_; };
      Holder& swap(Holder& other) {
         std::swap(caddy_, other.caddy_);
         return *this;
      };
      template<typename type_t>
      Holder& operator=(const type_t& other) {
         Holder(other).swap(*this);
         return *this;
      };
      Holder& operator=(const Holder& other) {
         Holder(other).swap(*this);
         return *this;
      };
      bool empty() const { return !caddy_; };
      const std::type_info& type() const { return caddy_ ? caddy_->type() : typeid(void); };
      template<typename type_t>
      type_t* cast() {
         return caddy_ && type() == typeid(type_t) ? &static_cast<Container<type_t> *>(caddy_)->content_ : 0;
      };
      void reset() { Holder().swap(*this); };
      template<typename type_t>
      void reset() { Holder(new Container<type_t>()).swap(*this); };
      template<typename type_t, typename arg1_t>
      void reset(arg1_t arg1) { Holder(new Container<type_t>(arg1)).swap(*this); };
      template<typename type_t, typename arg1_t, typename arg2_t>
      void reset(arg1_t arg1, arg2_t arg2) { Holder(new Container<type_t>(arg1, arg2)).swap(*this); };
      template<typename type_t, typename arg1_t, typename arg2_t, typename arg3_t>
      void reset(arg1_t arg1, arg2_t arg2, arg3_t arg3) { Holder(new Container<type_t>(arg1, arg2, arg3)).swap(*this); };
      unsigned int id() { return caddy_ ? caddy_->id() : id<void>(); };
      template<typename type_t>
      static unsigned int id() { static unsigned int r(count()); return r; };
   private:
      static unsigned int count() { static unsigned int r(0); return ++r; };
      class Caddy {
      public:
         virtual ~Caddy() {};
         virtual const std::type_info& type() const = 0;
         virtual Caddy* clone() const = 0;
         virtual unsigned int id() = 0;
      };
      template<typename type_t>
      class Container : public Caddy {
      public:
         Container() : content_() {};
         Container(const type_t& value) : content_(value) {};
         template<typename arg1_t>
         Container(arg1_t& value1) : content_(value1) {};
         template<typename arg1_t, typename arg2_t>
         Container(arg1_t& value1, arg2_t& value2) : content_(value1, value2) {};
         template<typename arg1_t, typename arg2_t, typename arg3_t>
         Container(arg1_t& value1, arg2_t& value2, arg3_t& value3) : content_(value1, value2, value3) {};
         virtual const std::type_info& type() const { return typeid(type_t); };
         virtual Container* clone() const { return new Container(content_); };
         virtual unsigned int id() { return Holder::id<type_t>(); };
         type_t content_;
      };
      Caddy* caddy_;
      template<typename T>
      Holder(Container<T>* value) : caddy_(value) {};
   public:  // Method entry
      template<typename M0>
      static bool entry() { return Multimethod::entry<Holder, Holder, M0>(); };
      template<typename M0, typename A1>
      static bool entry() { return Multimethod::entry<Holder, Holder, M0, A1>(); };
      template<typename M0, typename A1, typename A2>
      static bool entry() { return Multimethod::entry<Holder, Holder, M0, A1, A2>(); };
      template<typename M0, typename A1, typename A2, typename A3>
      static bool entry() { return Multimethod::entry<Holder, Holder, M0, A1, A2, A3>(); };
   public:  // Multi Method
      Holder operator()() { return Multimethod::apply<Holder, Holder>(*this); };
      template <typename T0>
      Holder operator()(T0& arg1) { return Multimethod::apply<Holder, Holder>(*this, arg1); };
      template <typename T0>
      Holder operator()(const T0& arg1) { return Multimethod::apply<Holder, Holder>(*this, arg1); };
      template <typename T0, typename T1>
      Holder operator()(T0& arg1, T1& arg2) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2); };
      template <typename T0, typename T1>
      Holder operator()(const T0& arg1, T1& arg2) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2); };
      template <typename T0, typename T1>
      Holder operator()(T0& arg1, const T1& arg2) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2); };
      template <typename T0, typename T1>
      Holder operator()(const T0& arg1, const T1& arg2) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(T0& arg1, T1& arg2, T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(const T0& arg1, T1& arg2, T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(T0& arg1, const T1& arg2, T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(T0& arg1, T1& arg2, const T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(const T0& arg1, const T1& arg2, T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(const T0& arg1, T1& arg2, const T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(T0& arg1, const T1& arg2, const T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template <typename T0, typename T1, typename T2>
      Holder operator()(const T0& arg1, const T1& arg2, const T2& arg3) { return Multimethod::apply<Holder, Holder>(*this, arg1, arg2, arg3); };
      template<unsigned int> Holder& operator()();
      template<> Holder& operator()<0>() { operator()(); return *this; };
      template<unsigned int> Holder& operator()(Holder& arg1);
      template<> Holder& operator()<0>(Holder& arg1) { operator()(arg1); return *this; };
      template<> Holder& operator()<1>(Holder& arg1) { operator()(arg1); return arg1; };
      template<unsigned int> Holder& operator()(Holder& arg1, Holder& arg2);
      template<> Holder& operator()<0>(Holder& arg1, Holder& arg2) { operator()(arg1, arg2); return *this; };
      template<> Holder& operator()<1>(Holder& arg1, Holder& arg2) { operator()(arg1, arg2); return arg1; };
      template<> Holder& operator()<2>(Holder& arg1, Holder& arg2) { operator()(arg1, arg2); return arg2; };
      template<unsigned int> Holder& operator()(Holder& arg1, Holder& arg2, Holder& arg3);
      template<> Holder& operator()<0>(Holder& arg1, Holder& arg2, Holder& arg3) { operator()(arg1, arg2, arg3); return *this; };
      template<> Holder& operator()<1>(Holder& arg1, Holder& arg2, Holder& arg3) { operator()(arg1, arg2, arg3); return arg1; };
      template<> Holder& operator()<2>(Holder& arg1, Holder& arg2, Holder& arg3) { operator()(arg1, arg2, arg3); return arg2; };
      template<> Holder& operator()<3>(Holder& arg1, Holder& arg2, Holder& arg3) { operator()(arg1, arg2, arg3); return arg3; };
   };

   class holder_bad_cast : public std::bad_cast {
   public:
      virtual const char * what() const throw() { return "bad_cast: failed conversion using holder_cast"; };
   };

   template<typename type_t>
   type_t* holder_cast(Holder* operand) { return operand->cast<type_t>(); };

   template<typename type_t>
   inline const type_t* holder_cast(const Holder * operand) {
      return holder_cast<type_t>(const_cast<Holder *>(operand));
   };

   template<typename type_t>
   type_t holder_cast(Holder& operand) {
      typedef typename remove_reference<type_t>::type nonref;
      nonref* result = holder_cast<nonref>(&operand);
      if(!result)
         boost::throw_exception(holder_bad_cast());
      return *result;
   };

   template<typename type_t>
   inline type_t holder_cast(const Holder& operand) {
      return holder_cast<const remove_reference<type_t>::type&>(const_cast<Holder&>(operand));
   };

   template<> struct Multimethod::Traits<Holder> {
      typedef unsigned int index_type;
      static unsigned int id(Holder& target) { return target.id(); };
      template<typename target_t>
      static unsigned int id() { return Holder::id<target_t>(); };
      template<typename type_t>
      static type_t cast(Holder& operand) { return holder_cast<remove_reference<type_t>::type&>(operand); };
   };


#endif