JMultiSet.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JMULTISET__
#define __JTOOLS__JMULTISET__

#include "JTools/JAbstractMultiMap.hh"
#include "JTools/JSet.hh"


/**
 * \author mdejong
 */

namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }

namespace JTOOLS {


  /**
   * Simple data structure for an abstract multidimensional map of equidistant elements.
   *
   * This class implements the JAbstractMultiMap interface.
   */
  template<unsigned int N, class JAbscissa_t>
  struct JMultiSet :
    public virtual JAbstractMultiMap<N, JAbscissa_t>,
    public JMultiSet<N - 1, JAbscissa_t>
  {
    typedef JAbscissa_t                                          abscissa_type;
    typedef JMultiKey<N - 1, abscissa_type>                      key_type;

    using JMultiSet<N - 1, JAbscissa_t>::operator();


    /**
     * Default constructor.
     */
    JMultiSet() :
      JMultiSet<N - 1, JAbscissa_t>()
    {}


    /**
     * Constructor.
     *
     * \param  bounds        bounds

     */
    JMultiSet(const JSet<abscissa_type>& bounds) :
      JMultiSet<N - 1, JAbscissa_t>(bounds)
    {
      this->bounds = bounds;
    }


    /**
     * Set bounds.
     *
     * \param  index         index of dimension
     * \param  bounds        bounds
     * \return               true if correctly set; else false
     */
    bool set(unsigned int index, const JSet<abscissa_type>& bounds)
    {
      if        (index == N - 1) {

        this->bounds = bounds;

      } else if (index <  N - 1) {

        return static_cast<JMultiSet<N - 1, abscissa_type>&>(*this).set(index, bounds);
      }
      
      return false;
    }


    /**
     * Get abscissa values as a function of given key.
     * 
     * \param  key           key
     * \return               abscissa values
     */
    virtual const JSet<abscissa_type>& operator()(const key_type& key) const 
    {
      return bounds;
    }

  protected:
    JSet<JAbscissa_t> bounds;
  };


  /**
   * Terminator class of recursive class JMultiSet.
   * This class provides for dummy implementations of interface methods.
   */
  template<class JAbscissa_t>
  struct JMultiSet<0, JAbscissa_t>
  {
  protected:

    typedef JAbscissa_t                                          abscissa_type;

    friend class JMultiSet<1, JAbscissa_t>;


    /**
     * Default constructor.
     */
    JMultiSet() 
    {}


    /**
     * Constructor.
     *
     * \param  bounds        bounds
     */
    JMultiSet(const JSet<abscissa_type>& bounds)
    {}


    /**
     * This method does nothing.
     *
     * \param  index         index
     * \param  bounds        bounds
     * \return               false
     */
    bool set(unsigned int index, const JSet<abscissa_type>& bounds) const
    {
      return false;
    }


    /**
     * Dummy operator.
     */
    void operator()() const
    {}
  };


  /**
   * Helper method for JMultiSet.
   *
   * \param  bounds          bounds
   * \return                 multidimensional set
   */
  template<unsigned int N, class JAbscissa_t>
  inline JMultiSet<N, JAbscissa_t> make_multiset(const JSet<JAbscissa_t>& bounds)
  {
    return JMultiSet<N, JAbscissa_t>(bounds);
  }
}

#endif