//Copyright (c) 2007 Joshua Napoli

//Based on Emil Dotchevski's exception library.

//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)

#ifndef BOOST_EXCEPTION_HPP
#define BOOST_EXCEPTION_HPP

#include <sstream>
#include <boost/exception/exception_ptr.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/extent.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/shared_ptr.hpp>

namespace boost
{
  namespace error
  {
    class exception;

    class error_info_visitor_base
    {
    public:
      virtual ~error_info_visitor_base() {}
    };

    template<typename T>
    class error_info_visitor : public error_info_visitor_base
    {
    public:
      virtual void apply(const T& t) const=0;
      virtual ~error_info_visitor() {}
    };

    namespace exception_detail
    {
      class error_info_base
      {
      public:
        virtual std::ostream& format(std::ostream& os) const throw()=0;
        virtual void visit(const error_info_visitor_base&) const=0;
        virtual ~error_info_base() {}
      };

      template<typename T>
      struct packed_array
      {
        typename boost::remove_const<T>::type t_;
        packed_array(const T& t)
        {
          std::copy(&t[0],&t[extent<T>::value],&t_[0]);
        }
      };

      template<typename T, bool IsArray=is_array<T>::value>
      struct pack 
      {
        typedef T result_type;
        result_type operator()(const T& t) const {return t;}
      };
            
      template<typename T>
      struct pack<T,true>
      {
        typedef packed_array<T> result_type;
        result_type operator()(const T& t) const {return result_type(t);}
      };
      
      template<typename T, bool IsArray=is_array<T>::value>
      struct unpack
      {
        typedef T result_type;
        const result_type& operator()(const T& t) const {return t;}
      };
            
      template<typename T>
      struct unpack<T,true>
      {
        typedef T result_type;
        const result_type& operator()(const packed_array<T>& t) const
        {
          return t.t_;
        }
      };
      
      template<typename T>
      struct print
      {
        template<typename Elem,typename Traits>
        std::basic_ostream<Elem,Traits>& operator() (std::basic_ostream<Elem,Traits>& os, const T& t)
        {
          return os << t;
        }
      };
      
      template<typename T>
      struct apply_error_visitor
      {
        void operator()(const error_info_visitor_base& v, const T& t) const
        {
          const error_info_visitor<T>* visitor(dynamic_cast<const error_info_visitor<T>*>(&v));
          if(visitor)
          {
            visitor->apply(t);
          }          
        }
      };
      
      template<typename Tail>
      class error_info_list : public error_info_base
      {
      public:
        error_info_list(const shared_ptr<error_info_base>& head, const Tail& tail)
          :head_(head)
          ,tail_(pack<Tail>()(tail))
        {}
            
        virtual std::ostream& format(std::ostream& os) const throw()
        {
          if(head_) return print<Tail>()(head_->format(os),unpack<Tail>()(tail_));
          else return print<Tail>()(os,unpack<Tail>()(tail_));
        }
      
        virtual void visit(const error_info_visitor_base& v) const
        {
          if(head_) head_->visit(v);
          apply_error_visitor<Tail>()(v,unpack<Tail>()(tail_));
        }
        virtual ~error_info_list() {}
      private:
        shared_ptr<error_info_base> head_;
        typename pack<Tail>::result_type tail_;
      };
    }
    
    class exception
    {
    public:
      exception() throw() {}
      
      exception(const exception& other) throw()
        :info_(other.info_)
      {}
      
      ///a default message is provided if the formatting fails
      virtual const char* what() const throw()
      {
        try
        {
          std::stringstream s;
          if(info_) info_->format(s);
          what_.reset(new std::string(s.str()));
          return what_->c_str();
        }
        catch(...)
        {
          static const char default_message[]="error while formatting the exception message";
          return default_message;
        }
      }
      
      ///only throws if the visitor throws
      void visit(const error_info_visitor_base& v) const
      {
        if(info_) info_->visit(v);
      }
      
      ///has no effect, if the operation fails
      template<typename T>
      void set(const T&t) throw()
      {
        try { info_.reset(new exception_detail::error_info_list<T>(info_,t)); }
        catch(...) {}
      }

      ///exceptions thrown by destructor of contained values are ignored
      virtual ~exception() throw() 
      {
        boost::shared_ptr<exception_detail::error_info_base> info;
        info_.swap(info);
        try { info.reset(); } catch(...) {}
      }
      
    private:
      shared_ptr<exception_detail::error_info_base> info_;
      mutable shared_ptr<std::string> what_;
    };
    
    template<typename E, typename T>
    E operator<< (const E& e,const T& t)
    {
      E retval(e);
      retval.set(t);
      return retval;
    }
    
    template<typename E, typename T>
    E& operator<< (E& e,const T& t)
    {
      e.set(t);
      return e;
    }
    
    namespace exception_detail
    {
      template<>
      struct print<exception>
      {
        template<typename Elem,typename Traits>        
        std::basic_ostream<Elem,Traits>& operator() 
          (std::basic_ostream<Elem,Traits>& os, const exception& e)
        {
          return os << e.what();
        }
      };
      
      template<>
      struct apply_error_visitor<exception>
      {
        void operator()(const error_info_visitor_base& v, const exception& e) const
        {
          e.visit(v);
        }
      };      
    }
  }//namespace error
  
  typedef error::exception exception;

  template<typename T>
  struct error_info_value
  {
    typedef T type;
  };
    
  template<typename Tag> 
  struct error_info
  {
    typename Tag::type t_;
    error_info(const typename Tag::type& t) : t_(t) {}
  };
    
  template<typename Elem,typename Traits,typename T>
  std::basic_ostream<Elem,Traits>& operator<< (std::basic_ostream<Elem,Traits>& os, const error_info<T>& t)
  {
    return os << t.t_;
  }
    
  template<typename ErrorInfo, typename F>
  struct error_info_field_visitor : error::error_info_visitor<ErrorInfo>
  {
    F f_;
    error_info_field_visitor(F f) : f_(f) {}
    virtual void apply(const ErrorInfo& info) const
    {
      f_(info.t_);
    }
    virtual ~error_info_field_visitor() {}
  };
    
  template<typename T, typename F>
  struct field_visitor : error::error_info_visitor<T>
  {
    F f_;
    field_visitor(F f) : f_(f) {}
    virtual void apply(const T& t) const
    {
      f_(t);
    }
    virtual ~field_visitor() {}
  };
    
  template<typename Tag, typename F>
  error_info_field_visitor<error_info<Tag>,F> on_error_info(Tag, F f)
  {
      return error_info_field_visitor<error_info<Tag>,F>(f);
  }
  
  template<typename T, typename F> 
  field_visitor<T,F> on_error_info(F f)
  {
      return field_visitor<T,F>(f);
  }
}

#endif