/*=========================================================================
                                                                                
  Program:   bbtk
  Module:    $RCSfile: bbtkAny.h,v $
  Language:  C++
  Date:      $Date: 2008/01/22 15:02:00 $
  Version:   $Revision: 1.1 $
                                                                                
  Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  l'Image). All rights reserved. See doc/license.txt or
  http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details.
                                                                                
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.
                                                                                
=========================================================================*/
/**
 *\file
 *\brief  Defines the class any which can store any type of data (adapted from boost::any).
 */
#ifndef __BBTKANY_H_INCLUDED__
#define __BBTKANY_H_INCLUDED__

/*
#include <string>
#include <iostream>
#include <typeinfo>
#include <set>
#include <map>
#include <sstream>
#include <exception>

#include <cxxabi.h>
*/
#include <sstream>
#include "bbtkRTTI.h"
#include "bbtkMessageManager.h"
#include "bbtkException.h"

#ifdef _USE_BOOST_
#include <boost/type_traits/is_pointer.hpp>
#endif 

namespace bbtk 
{





  //=========================================================
  /// Abstract class used by the any class to store values
  class anyplaceholder
  {
  public: // structors
    
    virtual ~anyplaceholder() {}
    
  public: // queries
    
    /// returns the type of the held value
    virtual const std::type_info & type() const = 0;
    /// returns the type of the pointed held value
    virtual const std::type_info & pointed_type() const = 0;
    
    /// returns true iff the stored value is a pointer
    virtual bool is_pointer() const = 0;
    
    /// If the held value is a pointer then 
    /// returns its value
    virtual void* get_pointer() const = 0;
 
    /// 
    virtual void* get_pointer_to( const std::type_info& ) const = 0;
   
    virtual anyplaceholder * clone() const = 0;
    
  };
  //=========================================================
  
  //=========================================================
  /// Concrete template class used by the any class to store values
  /// which stores a value of type ValueType
  template<typename ValueType>
  class anyholder : public anyplaceholder
  {
  public: // structors
    
    anyholder(const ValueType & value)
      : held(value)
    {}
    
  public: // queries
    
    virtual const std::type_info & type() const { return typeid(ValueType);}
    virtual bool is_pointer() const { return false; }
    virtual const std::type_info & pointed_type() const { return typeid(void); }
    virtual void* get_pointer() const { return 0; }
    virtual void* get_pointer_to( const std::type_info& ) const { return 0; }
    virtual anyplaceholder * clone() const { return new anyholder(held); }
    
    public: // representation
    
    ValueType held;
    
  };
  //=========================================================
  
  //=========================================================
  /// specialization of anyholder for pointer types
  template<typename ValueType>
  class anyholder<ValueType*> : public anyplaceholder
  {
  public: // structors
    
    anyholder(ValueType* const & value)
      : held(value)
    { }
    
  public: // queries
    
    virtual const std::type_info & type() const
    {
      return typeid(ValueType*);
    }
    
    virtual bool is_pointer() const { return true; }
    virtual const std::type_info & pointed_type() const { return typeid(ValueType); }
    virtual void* get_pointer() const { 
      return (void*)held; 
    }
    virtual void* get_pointer_to( const std::type_info& t) const 
    { 
      return run_time_up_or_down_cast(t,typeid(ValueType),held);
    }

    virtual anyplaceholder * clone() const { return new anyholder(held); }
    
  public: // representation
    
    ValueType* held;
    
  };
  //=========================================================


  /** A magic class which can store any type of data which 
   * is allowed by the template template parameter TypeTrait.
   *
   * The only requirement on TypeTrait<T> is to have the member :
   *    static const bool value;
   * which is true iff the type T is an allowed type 
   * 
   * TypeTraits compliant objects are usually template structs 
   * for which the initialisation of value is set to false by default 
   * and set to true for the allowed types (template specialisation)
   * Example :
   *   template <typename T> struct mytypes { static const bool value; };
   *   template <typename T> const bool mytypes<T>::value = false;
   *   template <> const bool mytypes<int>::value = true;
   *   template <> const bool mytypes<float>::value = true; 
   * etc.
   * You can use any boost type_trait, like is_pointer, is_floating_point, etc.
   *
   * The class any is a generalisation of the boost::any class 
   * (see http://www.boost.org/doc/html/any.html).
   * The boost::any class itself is reproduced by any<thing>,
   * where thing is a TypeTrait whose value is true for all types.
   **/
  template <template <class> class TypeTraits >
  class any
  {
  public:
    typedef any< TypeTraits > self;
    // structors
  
    /// Default constructor
    any()
      : content(0)
    {
    }
  
    /// Constructor with a value of template type
    template<typename ValueType>
    any(const ValueType & value)
      : content(0)
    {
      bbtkDebugMessage("Data",1,
		       bbtk::HumanTypeName<self>()<<" construction with <"
		       <<bbtk::HumanTypeName<ValueType>()<<">"<<std::endl);
      //      ValueType v = value;
      //      int** i = (int**)(&v);
      //      std::cout << "v="<<*i<<std::endl;
      
      if (accepts<ValueType>()) 
	{ 
	  content = new anyholder<ValueType>(value);
	}
      else 
	{
	  bbtkError(bbtk::HumanTypeName<self>()
		    <<" constructor : data of type <"
		    <<bbtk::HumanTypeName<ValueType>()
		    <<"> are not accepted by traits <"
		    <<bbtk::HumanTypeName<TypeTraits<void> >()<<"> ");
	}
    }
  
    /// Copy constructor
    any(const any & other)
      : content(other.content ? other.content->clone() : 0)
    {
      bbtkDebugMessage("Data",1,
		       HumanTypeName<self>()
		       <<" copy construction with new content : "
		       <<HumanTypeName(type())
		       <<std::endl);
    }
  
    /// Destructor
    ~any()
    {
      delete content;
    }
  

    /// Swaps the content of this with another any
    any & swap(any & rhs)
    {
      std::swap(content, rhs.content);
      return *this;
    }

    /// Affectation of a value of template type
    template<typename ValueType>
    any & operator=(const ValueType & rhs)
    {
      bbtkDebugMessage("Data",1,
		       HumanTypeName<self>()
		       <<" operator= with data of type <"
		       <<HumanTypeName<ValueType>()
		       <<">"<<std::endl);
      if (accepts<ValueType>()) 
	{
	  any(rhs).swap(*this);
	  return *this;
	}
      else 
	{
	  bbtkError(HumanTypeName<self>()
		    <<" operator= : data of type <"
		    <<HumanTypeName<ValueType>()
		    <<"> are not accepted by traits <"
		    <<HumanTypeName<TypeTraits<void> >()<<"> ");
	}
    
    }
  
    /// Affectation of another any
    any & operator=(const any & rhs)
    {
	bbtkDebugMessage("Data",1,
			 HumanTypeName<self >()
			 <<" operator=(const any&) with content : "
			 <<HumanTypeName(rhs.type())<<std::endl);

      any(rhs).swap(*this);
      return *this;
    }
  

    /// Is it empty (no value held) ?
    bool empty() const
    {
      return !content;
    }
  
    /// Returns the type_info of the held value
    const std::type_info & type() const
    {
      return content ? content->type() : typeid(void);
    }

    /// Returns the type_info of the pointed held value
    const std::type_info & pointed_type() const
    {
      return content ? content->pointed_type() : typeid(void);
    }


    /// Returns true iff the contained type is Type
    template<typename Type>
    inline bool contains()
    {
      return ( type() == typeid(Type) );
    }

    /// Returns true iff the contained type is a pointer
    inline bool contains_pointer()
    {
      return content->is_pointer() ;
    }

    /// Returns true iff the contained type is t
    inline bool contains(TypeInfo t)
    {
      return ( type() == t );
     }

    /// Returns true iff any of type ValueType can be held 
    template<typename Type>
    inline bool accepts()
    {
      return TypeTraits<Type>::value; //is_valid();
    }

    /// Returns a const reference on the held value iff its type matches 
    /// the template parameter  
    template<typename ValueType>
    inline const ValueType& get() const
    {
	bbtkDebugMessage("Data",1,
			 HumanTypeName<self >()
			 <<" get<"<<HumanTypeName<ValueType>()
			 <<"> with content : "
			 <<HumanTypeName(type())<<std::endl);

      if ( type() == typeid(ValueType) )
	return static_cast< anyholder<ValueType> *>(content)->held;

      bbtkError(HumanTypeName<self >()
		<<" get with type <"
		<<bbtk::HumanTypeName<ValueType>()
		<<"> does not match content type <"
		<<bbtk::HumanTypeName<>(type())<<">");
    }

    template<typename ValueType>
    inline const ValueType* getP() const
    {
      if ( type() == typeid(ValueType) )
	return &static_cast< anyholder<ValueType> *>(content)->held;
 
      bbtkError(HumanTypeName<self >()
		<<" getP with type <"
		<<bbtk::HumanTypeName<ValueType>()
		<<"> does not match content type <"
		<<bbtk::HumanTypeName<>(type())<<">");
    }

    /// Returns a const reference on the held value 
    /// ** EVEN IF ITS TYPE DOES NOT MATCH THE TEMPLATE PARAMETER **
    /// Hence must be used when one knows that the type is good
    /// Otherwise can lead to unpredictible results 
    template<typename ValueType>
    inline const ValueType& unsafe_get() const
    {
	bbtkDebugMessage("Data",1,
			 HumanTypeName<self>()
			 <<"::unsafe_get<"
			 <<HumanTypeName<ValueType>()<<"> with content : "
			 <<HumanTypeName(this->type())
			 <<std::endl);

	//	PrintValueIfIsPointer<ValueType>(static_cast< anyholder<ValueType> * >(content)->held);
	//	int** i = (int**)(&static_cast< anyholder<ValueType> * >(content)->held);
	//	std::cout << "v="<<*i<<std::endl;

	if (content) 
	  return static_cast< anyholder<ValueType> * >(content)->held;
	
	bbtkError(HumanTypeName<self >()
		  <<"::usafe_get<"
		  <<bbtk::HumanTypeName<ValueType>()
		  <<"> : void content");
    }


    inline void* get_pointer() const 
    {
      void* p = content->get_pointer();
      bbtkDebugMessage("Data",1,
		       HumanTypeName<self>()
		       <<"::get_pointer() with content <"
		       <<HumanTypeName(this->type())
		       <<"> : result = "
		       << p
		       <<std::endl);
      return p;
    }
    
    inline void* get_pointer_to(const std::type_info& t) const 
    {
      void* p = content->get_pointer_to(t);
      bbtkDebugMessage("Data",1,
		       HumanTypeName<self>()
		       <<"::get_pointer_to("<<HumanTypeName(t)
		       <<") with content <"
		       <<HumanTypeName(this->type())
		       <<"> : result = "
		       << p
		       <<std::endl);
      return p;
    }
    
  private: 
    /// content
    anyplaceholder * content;
    
  };

  

  /// The TypeTraits which validates any type 
  template <typename T> struct thing { static const bool value = true; };

  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbtk::any<bbtk::thing>,"anything");


  /// The TypeTraits which validates all integer types
  template <typename T> struct integer { static const bool value; };
  template <class T> const bool integer<T>::value = false;

  /// The TypeTraits which validates all floating point number types
  template <typename T> struct floating_point { static const bool value; };
  template <class T> const bool floating_point<T>::value = false;


  /// The TypeTraits which validates all numerical types
  template <typename T> struct number { static const bool value; };
  template <class T> const bool number<T>::value = 
	     integer<T>::value || floating_point<T>::value ;
  
  
  /// Macro to begin the enumeration of types included into a 
  /// any_type_collection previously declared with 
  /// DECLARE_any_type_collection. 
  /// Must be placed in the implementation part of the code.
#define BBTK_DECLARE_TYPE_TRAITS(NAME)					\
  template <typename T> struct NAME { static const bool value; };	\
    template <class T> const bool NAME<T>::value = false;
  
#define BBTK_ADD_TO_TYPE_TRAITS(NAME,TYPE)	\
  template <> bool NAME<TYPE>::value = true;


}





/*

// TRY TO INCLUDE BOOST DIRECTLY : OK WORKS !
#include <algorithm>
#include <typeinfo>

#include "boost/config.hpp"
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/throw_exception.hpp>
#include <boost/static_assert.hpp>


namespace bbtk
{


  class bad_any_cast : public std::bad_cast
  {
  public:
    virtual const char * what() const throw()
    {
      return "boost::bad_any_cast: "
	"failed conversion using boost::any_cast";
    }
  };
  
  typedef any<thing> anything;

  template<typename ValueType>
  ValueType * any_cast(anything * operand)
  {
    return operand && operand->type() == typeid(ValueType)
      ? &static_cast<anything::holder<ValueType> *>(operand->content)->held
      : 0;
  }
  
    template<typename ValueType>
    const ValueType * any_cast(const anything * operand)
    {
        return any_cast<ValueType>(const_cast<anything *>(operand));
    }

    template<typename ValueType>
    ValueType any_cast(const anything & operand)
    {
      typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<ValueType>::type nonref;

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        // If 'nonref' is still reference type, it means the user has not
        // specialized 'remove_reference'.

        // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
        // to generate specialization of remove_reference for your class
        // See type traits library documentation for details
      BOOST_STATIC_ASSERT(!boost::is_reference<nonref>::value);
#endif

        const nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());
        return *result;
    }

    template<typename ValueType>
    ValueType any_cast(anything & operand)
    {
      typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<ValueType>::type nonref;

#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        // The comment in the above version of 'any_cast' explains when this
        // assert is fired and what to do.
        BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
#endif

        nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());
        return *result;
    }

    // Note: The "unsafe" versions of any_cast are not part of the
    // public interface and may be removed at any time. They are
    // required where we know what type is stored in the any and can't
    // use typeid() comparison, e.g., when our types may travel across
    // different shared libraries.
    template<typename ValueType>
    inline ValueType * unsafe_any_cast(anything * operand)
    {
        return &static_cast<anything::holder<ValueType> *>(operand->content)->held;
    }

    template<typename ValueType>
    inline const ValueType * unsafe_any_cast(const anything * operand)
    {
        return unsafe_any_cast<ValueType>(const_cast<anything *>(operand));
    }
}
*/ // EO TRY TO INCLUDE BOOST

#endif