JMultiKey.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JMULTIKEY__
#define __JTOOLS__JMULTIKEY__
 
#include <cstddef>
#include <istream>
#include <ostream>
#include <utility>
#include <array>
#include <type_traits>
 
#include "JLang/JClass.hh"
#include "JLang/JComparable.hh"
#include "JLang/JManip.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  using JLANG::JComparable;
  using JLANG::JClass;
 
 
  /**
   * Multidimensional key.
   *
   * This class reproduces the key of a multidimensional map.
   * The individual data members can be accessed as, e.g:
   * <pre>
   *           JMultiKey<3, key_type>  key;
   *
   *           key[[.second].second].first;
   * </pre>
   */
  template<unsigned int N, class JKey_t>
  class JMultiKey :
    public std::pair<JKey_t, JMultiKey<N-1, JKey_t> >,
    public JComparable< JMultiKey<N, JKey_t> >
  {
  public:
 
    typedef JKey_t                                               key_type;
    typedef JMultiKey<N-1, JKey_t>                               mapped_type;
    typedef std::pair<key_type, mapped_type>                     pair_type;
    typedef std::array<key_type, N>                              array_type;
 
    typedef typename std::conditional<std::is_const<key_type>::value,
                                      typename std::remove_const<key_type>::type,
                                      typename std::add_const   <key_type>::type>::type  U;   // opposite constness
 
    /**
     * Default constructor.
     */
    JMultiKey() :
      pair_type()
    {}
 
 
    /**
     * Append constructor.
     * The secondary key is appended to the end of the primary keys.
     *
     * \param   first        primary   keys
     * \param   second       secondary key
     */
    JMultiKey(typename JClass<mapped_type>::argument_type first,
              typename JClass<key_type>   ::argument_type second) :
      pair_type(first.first, mapped_type(first, second))
    {}
 
 
    /**
     * Insert constructor.
     * The primary key is inserted at the start of the secondary keys.
     *
     * \param   first        primary   key
     * \param   second       secondary keys
     */
    JMultiKey(typename JClass<key_type>   ::argument_type first,
              typename JClass<mapped_type>::argument_type second) :
      pair_type(first, second)
    {}
 
 
    /**
     * Shift constructor.
     * The first of the primary keys is removed and the secondary key is appended to the end of the remainder of the primary keys.
     *
     * \param   first        primary   keys
     * \param   second       secondary key
     */
    JMultiKey(const JMultiKey& first, typename JClass<key_type>::argument_type second) :
      JMultiKey(first.second, second)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param   key          key
     */
    JMultiKey(const JMultiKey<N, U>& key) :
      pair_type(key.first, key.second)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param   array        array
     */
    JMultiKey(const std::array<key_type, N>& array) :
      pair_type(array[0], pop_front(array, std::make_index_sequence<N>{}))
    {}
 
 
    /**
     * Type conversion operator.
     *
     * \return               array
     */
    operator array_type() const
    {
      return to_array(this->first, this->second, std::make_index_sequence<N-1>{});
    }
 
 
    /**
     * Less than method.
     *
     * \param   key          key
     * \return               true if this key less than given key; else false
     */
    bool less(const JMultiKey& key) const
    {
      if (this->first == key.first)
        return this->second.less(key.second);
      else
        return this->first < key.first;
    }
    
 
    /**
     * Get frontend key.
     *
     * \return               frontend key
     */
    JMultiKey<N-1, key_type> front() const
    {
      return JMultiKey<0, key_type>::front(*this);
    }
 
 
    /**
     * Get backend key.
     *
     * \return               backend key
     */
    key_type back() const
    {
      return this->second.back();
    }
 
 
    /**
     * Read key from input.
     *
     * \param  in            input stream
     * \param  key           key
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JMultiKey& key)
    {
      in >> key.first;
      in >> key.second;
 
      return in;
    }
 
 
    /**
     * Write key to output.
     *
     * \param  out           output stream
     * \param  key           key
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JMultiKey& key)
    {
      const JFormat format(out, getFormat< JMultiKey<0, key_type> >(JFormat_t(9, 3, std::ios::fixed | std::ios::showpos)));
 
      out << format << key.first;
      out << ' ';
      out << key.second;
 
      return out;
    }
 
 
  private:
    /**
     * Auxiliary method to convert keys to array.
     *
     * \param  key           key
     * \param  array         array
     * \return               array
     */
    template<size_t ...i>
    static array_type to_array(const key_type& key,
                               const typename mapped_type::array_type& array,
                               std::index_sequence<i...>)
    {
      return {key, array[i]...};
    }
 
 
    /**
     * Auxiliary method to pop front array.
     *
     * \param  key           key
     * \param  args          values
     */
    template<class ...Args>
    std::array<key_type, N-1> pop_front(const key_type key, const Args& ...args)
    {
      return std::array<key_type, N-1>({args...});
    }
 
 
    /**
     * Pop front array.
     *
     * \param  array         array
     * \param  ls            indices of array
     */
    template<size_t ...i>
    std::array<key_type, N-1> pop_front(const std::array<key_type, N>& array, const std::index_sequence<i...>& ls)
    {
      return pop_front(array[i]...);
    }
  };
 
 
  /**
   * One-dimensional key.
   */  
  template<class JKey_t>
  class JMultiKey<1, JKey_t> :
    public JComparable< JMultiKey<1, JKey_t> >
  {
  public:
 
    typedef JKey_t                                               key_type;
    typedef JMultiKey<0, key_type>                               mapped_type;
    typedef std::array<key_type, 1>                              array_type;
 
    typedef typename std::conditional<std::is_const<key_type>::value,
                                      typename std::remove_const<key_type>::type,
                                      typename std::add_const   <key_type>::type>::type  U;   // opposite constness
 
 
    /**
     * Default constructor.
     */
    JMultiKey() :
      first()
    {}
 
 
    /**
     * Append onstructor.
     * The secondary key is appended to the end of the primary key.
     *
     * \param   first        primary   key
     * \param   second       secondary key
     */
    JMultiKey(typename JClass<mapped_type>::argument_type first,
              typename JClass<key_type>   ::argument_type second) :
      first(second)
    {}
 
 
    /**
     * Insert constructor.
     * The primary key is inserted at the start of the secondary key.
     *
     * \param   first        primary   key
     * \param   second       secondary key
     */
    JMultiKey(typename JClass<key_type>   ::argument_type first,
              typename JClass<mapped_type>::argument_type second) :
      first(first)
    {}
 
 
    /**
     * Shift constructor.
     * The first of the primary keys is removed and the secondary key is appended to the end of the remainder of the primary keys.
     *
     * \param   first        primary   keys
     * \param   second       secondary key
     */
    JMultiKey(const JMultiKey& first, typename JClass<key_type>::argument_type second) :
      first(second)
    {}
 
 
    /**
     * Constructor.
     *
     * \param   first        key
     */
    JMultiKey(typename JClass<key_type>::argument_type first) :
      first(first)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param   key          key
     */
    JMultiKey(const JMultiKey<1, U>& key) :
      first(key.first)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param   array        array
     */
    JMultiKey(const std::array<key_type, 1>& array) :
      first(array[0])
    {}
 
 
    /**
     * Type conversion operator.
     *
     * \return               array
     */
    operator array_type() const
    {
      return {this->first};
    }
 
 
    /**
     * Less than method.
     *
     * \param   key          key
     * \return               true if this key less than given key; else false
     */
    bool less(const JMultiKey& key) const
    {
      return this->first < key.first;
    }
 
 
    /**
     * Get backend key.
     *
     * \return               backend key
     */
    key_type back() const
    {
      return this->first;
    }
 
 
    /**
     * Read key from input.
     *
     * \param  in            input stream
     * \param  key           key
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JMultiKey& key)
    {
      in >> key.first;
 
      return in;
    }
 
 
    /**
     * Write key to output.
     *
     * \param  out           output stream
     * \param  key           key
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JMultiKey& key)
    {
      const JFormat format(out, getFormat< JMultiKey<0, key_type> >(JFormat_t(9, 3, std::ios::fixed | std::ios::showpos)));
 
      out << format << key.first;
 
      return out;
    }
 
 
    key_type first;
  };
 
 
  /**
   * Empty key.
   */
  template<class JKey_t>
  struct JMultiKey<0, JKey_t>
  {
    typedef JKey_t                                               key_type;
 
 
    /**
     * Get frontend key.
     *
     * \param  key           key
     * \return               frontend key
     */
    template<unsigned int N>
    static inline JMultiKey<N-1, key_type> front(const JMultiKey<N, key_type>& key)
    {
      return JMultiKey<N-1, key_type>(key.first, key.second.front());
    }
 
 
    /**
     * Get frontend key.
     *
     * \param  key           key
     * \return               frontend key
     */
    static inline JMultiKey<1, key_type> front(const JMultiKey<2, key_type>& key)
    {
      return JMultiKey<1, key_type>(key.first);
    }
  };
}
 
#endif