#ifndef __JSUPPORT__JAUTOTREESCANNER__
#define __JSUPPORT__JAUTOTREESCANNER__

#include <string>

#include "JLang/JType.hh"
#include "JLang/JNullType.hh"
#include "JLang/JSinglePointer.hh"
#include "JROOT/JROOTClassSelector.hh"
#include "JTools/JAutoMap.hh"
#include "JSupport/JTreeScanner.hh"


/**
 * \author mdejong
 */

namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }

namespace JSUPPORT {

  using JLANG::JType;
  using JLANG::JNullType;
  using JLANG::JSinglePointer;
  using JROOT::JROOTClassSelector;
  using JTOOLS::JAutoMap;


  /**
   * Auxiliary class to select JTreeScanner based on ROOT class name.
   */
  template<class JBase_t, class JEvaluator_t = JNullType>
  struct JAutoTreeScanner :
    public JAutoMap<std::string, JSinglePointer< JTreeScannerInterface<JBase_t, JEvaluator_t> > >
  {
    typedef typename JAutoMap<std::string, JSinglePointer< JTreeScannerInterface<JBase_t, JEvaluator_t> > >::map_type      map_type;
    typedef typename JAutoMap<std::string, JSinglePointer< JTreeScannerInterface<JBase_t, JEvaluator_t> > >::value_type    value_type;

    typedef typename map_type::const_iterator                          const_iterator;
    typedef typename map_type::iterator                                iterator;
    typedef typename map_type::const_reverse_iterator                  const_reverse_iterator;
    typedef typename map_type::reverse_iterator                        reverse_iterator;

    using JAutoMap<std::string, JSinglePointer< JTreeScannerInterface<JBase_t, JEvaluator_t> > >::insert;

    
    /**
     * Default constructor.
     */
    JAutoTreeScanner()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  type             data type
     * \param  option           include namespace
     */
    template<class T>
    JAutoTreeScanner(JType<T> type, const bool option = false) :
      option(option)
    {
      this->template insert<T>();
    }


    /**
     * Get option to include name space.
     *
     * \return             option
     */
    bool getOption() const
    {
      return option;
    }
    
    
    /**
     * Insert list of data types.
     */
    template<class T>
    void insert()
    {
      using namespace JPP;
      
      if (option)
	this->insert<T>(JAutomate< JElement_t<true> >());
      else
	this->insert<T>(JAutomate< JElement_t<false> >());
    }
    

  private:
    /**
     * Auxiliary class for element insertion.
     */
    template<bool option>
    struct JElement_t :
      public value_type
    {
      /**
       * Constructor.
       *
       * \param  type             data type
       */
      template<class T>
      JElement_t(JType<T> type) :
        value_type(JROOTClassSelector(type, option), new JTreeScanner<JAssertConversion<T, JBase_t>, JEvaluator_t>())
      {}
    };

    bool option;                //!< include namespace
  };
}

#endif