JMultiPair.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JMULTIPAIR__
#define __JTOOLS__JMULTIPAIR__
 
#include "JTools/JMultiKey.hh"
#include "JLang/JClass.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  /**
   * Multidimensional pair.
   *
   * This class reproduces the element of a multidimensional map.
   * The individual data members can be accessed as:
   * <pre>
   *           JMultiPair<3, key_type, mapped_type>  pair;
   *
   *           pair[[.second].second].first;
   *           pair[[.second].second].second;
   * </pre>
   */
  template<unsigned int N, class JKey_t, class JValue_t>
  class JMultiPair 
  {
  public:
 
    typedef JKey_t                                              key_type;
    typedef JValue_t                                            value_type;
    typedef JMultiPair<N-1, key_type, value_type>               mapped_type;
    typedef typename JLANG::JClass<value_type>::reference_type  reference_type;
    typedef JMultiKey<N, key_type>                              multikey_type;
 
 
    /**
     * Default constructor.
     */
    JMultiPair() :
      first (),
      second()
    {}
 
    
    /**
     * Append constructor.
     * The secondary key is appended to the end of the primary keys.
     *
     * \param   first        primary   keys and value
     * \param   second       secondary key
     */
    JMultiPair(typename JClass<mapped_type>::argument_type first,
               typename JClass<key_type>   ::argument_type second) :
      first (first.first),
      second(mapped_type(first.second, second))
    {}
 
    
    /**
     * Insert constructor.
     * The primary key is inserted at the start of the secondary keys.
     *
     * \param   first        primary   key
     * \param   second       secondary keys and value
     */
    JMultiPair(typename JClass<key_type>   ::argument_type first,
               typename JClass<mapped_type>::argument_type second) :
      first (first),
      second(second)
    {}
 
 
    /**
     * Shift constructor.
     * The first of the secondary keys is removed and the primary key is inserted in the remainder of the primary keys.
     *
     * \param   first        primary   key
     * \param   second       secondary keys and value
     */
    JMultiPair(typename JClass<key_type>::argument_type first, const JMultiPair& second) :
      first (first),
      second(second.second)
    {}
 
    
    /**
     * Constructor.
     *
     * \param   key          multidimensional key
     * \param   value        value
     */
    JMultiPair(typename JClass<multikey_type>::argument_type key,
               typename JClass<value_type>   ::argument_type value) :
      first (key.first),
      second(mapped_type(key.second, value))
    {}
 
 
    /**
     * Get multidimensional key.
     *
     * \return               multidimensional key
     */
    multikey_type getKey() const
    {
      return multikey_type(this->first, this->second.getKey());
    }
 
 
    /**
     * Get value.
     *
     * \return               value
     */
    reference_type getValue()
    {
      return this->second.getValue();
    }
 
 
    /**
     * Get value.
     *
     * \return               value
     */
    const reference_type getValue() const
    { 
      return this->second.getValue();
    }
 
 
    key_type    first;
    mapped_type second;
  };
 
 
  /**
   * One-dimensional pair.
   */  
  template<class JKey_t, class JValue_t>
  class JMultiPair<1, JKey_t, JValue_t> 
  {
  public:
 
    typedef JKey_t                                       key_type;
    typedef JValue_t                                     value_type;
    typedef JValue_t                                     mapped_type;
    typedef typename JClass<value_type>::reference_type  reference_type;
    typedef JMultiKey<1, key_type>                       multikey_type;
 
 
    /**
     * Default constructor.
     */
    JMultiPair() :
      first (),
      second()
    {}
 
 
    /**
     * Constructor.
     *
     * \param   first        key
     * \param   second       value
     */
    JMultiPair(typename JClass<key_type>  ::argument_type first,
               typename JClass<value_type>::argument_type second) :
      first (first),
      second(second)
    {}
 
    
    /**
     * Constructor.
     *
     * \param   key          multidimensional key
     * \param   value        value
     */
    JMultiPair(typename JClass<multikey_type>::argument_type key,
               typename JClass<value_type>   ::argument_type value) :
      first (key.first),
      second(value)
    {}
 
 
    /**
     * Shift constructor.
     * The first of the secondary keys is removed and the primary key is inserted in the remainder of the primary keys.
     *
     * \param   first        primary   key
     * \param   second       secondary keys and value
     */
    JMultiPair(typename JClass<key_type>::argument_type first, const JMultiPair& second) :
      first (first),
      second(second.second)
    {}
 
 
    /**
     * Get multidimensional key.
     *
     * \return               multidimensional key
     */
    multikey_type getKey() const
    { 
      return JMultiKey<1, key_type>(this->first);
    }
 
 
    /**
     * Get value.
     *
     * \return               value
     */
    reference_type getValue()
    {
      return this->second;
    }
 
 
    /**
     * Get value.
     *
     * \return               value
     */
    const reference_type getValue() const
    { 
      return this->second;
    }
 
 
    key_type    first;
    mapped_type second;
  };
 
 
  /**
   * Empty pair.
   */
  template<class JKey_t, class JValue_t>
  class JMultiPair<0, JKey_t, JValue_t>
  {};
}
 
#endif