bijection.h

Go to the documentation of this file.

#ifndef GUM_BIJECTION_H
#define GUM_BIJECTION_H

#include <initializer_list>
#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>

#include <agrum/core/hashTable.h>

namespace gum {

#ifndef DOXYGEN_SHOULD_SKIP_THIS

  template < typename T1, typename T2 >
  class BijectionIteratorSafe;
  template < typename T1, typename T2 >
  class BijectionIterator;
  template < typename T1, typename T2, typename Alloc, bool >
  class BijectionImplementation;
  template < typename T1, typename T2, typename Alloc >
  class Bijection;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */


  // ===========================================================================
  // ===                NON SCALAR BIJECTION IMPLEMENTATION                  ===
  // ===========================================================================

  template < typename T1, typename T2, typename Alloc, bool Gen >
  class BijectionImplementation {
    public:
    using type1_type = T1;
    using type1_reference = T1&;
    using type1_const_reference = const T1&;
    using type1_pointer = T1*;
    using type1_const_pointer = const T1*;
    using type2_type = T2;
    using type2_reference = T2&;
    using type2_const_reference = const T2&;
    using type2_pointer = T2*;
    using type2_const_pointer = const T2*;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using allocator_type = Alloc;
    using iterator = BijectionIterator< T1, T2 >;
    using const_iterator = BijectionIterator< T1, T2 >;
    using iterator_safe = BijectionIteratorSafe< T1, T2 >;
    using const_iterator_safe = BijectionIteratorSafe< T1, T2 >;
    using allocator12_type =
       typename Alloc::template rebind< std::pair< T1, T2* > >::other;
    using allocator21_type =
       typename Alloc::template rebind< std::pair< T2, T1* > >::other;

    private:
    BijectionImplementation(Size size, bool resize_policy);

    BijectionImplementation(std::initializer_list< std::pair< T1, T2 > > list);

    BijectionImplementation(
       const BijectionImplementation< T1, T2, Alloc, Gen >& toCopy);

    template < typename OtherAlloc >
    BijectionImplementation(
       const BijectionImplementation< T1, T2, OtherAlloc, Gen >& toCopy);

    BijectionImplementation(
       BijectionImplementation< T1, T2, Alloc, Gen >&& from) noexcept;

    public:
    // ============================================================================
    // ============================================================================

    ~BijectionImplementation();


    private:
    BijectionImplementation< T1, T2, Alloc, Gen >&
       operator=(const BijectionImplementation< T1, T2, Alloc, Gen >& toCopy);

    template < typename OtherAlloc >
    BijectionImplementation< T1, T2, Alloc, Gen >&
       operator=(const BijectionImplementation< T1, T2, OtherAlloc, Gen >& toCopy);

    BijectionImplementation< T1, T2, Alloc, Gen >&
       operator=(BijectionImplementation< T1, T2, Alloc, Gen >&& toCopy);

    public:
    // ============================================================================
    // ============================================================================

    iterator begin() const;

    const_iterator cbegin() const;

    const iterator& end() const noexcept;

    const const_iterator& cend() const noexcept;

    iterator_safe beginSafe() const;

    const_iterator_safe cbeginSafe() const;

    const iterator_safe& endSafe() const noexcept;

    const const_iterator_safe& cendSafe() const noexcept;

    static const iterator_safe& endSafe4Statics();

    static const iterator& end4Statics();

    // ============================================================================
    // ============================================================================

    const T1& first(const T2& second) const;

    const T1& firstWithDefault(const T2& second, const T1& default_val) const;

    const T2& second(const T1& first) const;

    const T2& secondWithDefault(const T1& second, const T2& default_val) const;

    bool existsFirst(const T1& first) const;

    bool existsSecond(const T2& second) const;

    void insert(const T1& first, const T2& second);

    void insert(T1&& first, T2&& second);

    template < typename... Args >
    void emplace(Args&&... args);

    void clear();

    bool empty() const noexcept;

    Size size() const noexcept;

    void eraseFirst(const T1& first);

    void eraseSecond(const T2& second);

    std::string toString() const;

    // ============================================================================
    // ============================================================================

    Size capacity() const noexcept;

    void resize(Size new_size);

    void setResizePolicy(const bool new_policy) noexcept;

    bool resizePolicy() const noexcept;


    private:
    using HashTable12 = HashTable< T1, T2*, allocator12_type >;
    using HashTable21 = HashTable< T2, T1*, allocator21_type >;

    friend class BijectionIteratorSafe< T1, T2 >;
    friend class BijectionIterator< T1, T2 >;
    friend class Bijection< T1, T2, Alloc >;
    template < typename TT1, typename TT2, typename A, bool >
    friend class BijectionImplementation;

    // Below, we create the two gum::HashTable used by the gum::Bijection. Note
    // that the values of these gum::HashTable are pointers. This enables to
    // create only once objects (T1,T2). When using gum::Bijection with large
    // size objects, this feature is of particular interest.

    HashTable12 __firstToSecond;

    HashTable21 __secondToFirst;

    template < typename OtherAlloc >
    void __copy(const HashTable< T1, T2*, OtherAlloc >& source);

    typename HashTable12::value_type* __insert(const T1& first, const T2& second);

    typename HashTable12::value_type* __insert(T1&& first, T2&& second);
  };

#ifndef DOXYGEN_SHOULD_SKIP_THIS

  // ===========================================================================
  // ===                  SCALAR BIJECTION IMPLEMENTATION                    ===
  // ===========================================================================

  template < typename T1, typename T2, typename Alloc >
  class BijectionImplementation< T1, T2, Alloc, true > {
    public:
    using type1_type = T1;
    using type1_reference = T1&;
    using type1_const_reference = const T1&;
    using type1_pointer = T1*;
    using type1_const_pointer = const T1*;
    using type2_type = T2;
    using type2_reference = T2&;
    using type2_const_reference = const T2&;
    using type2_pointer = T2*;
    using type2_const_pointer = const T2*;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using allocator_type = Alloc;
    using iterator = BijectionIterator< T1, T2 >;
    using const_iterator = BijectionIterator< T1, T2 >;
    using iterator_safe = BijectionIteratorSafe< T1, T2 >;
    using const_iterator_safe = BijectionIteratorSafe< T1, T2 >;

    using allocator12_type =
       typename Alloc::template rebind< std::pair< T1, T2 > >::other;
    using allocator21_type =
       typename Alloc::template rebind< std::pair< T2, T1 > >::other;

    private:
    BijectionImplementation(Size size, bool resize_policy);

    BijectionImplementation(std::initializer_list< std::pair< T1, T2 > > list);

    BijectionImplementation(
       const BijectionImplementation< T1, T2, Alloc, true >& toCopy);

    template < typename OtherAlloc >
    BijectionImplementation(
       const BijectionImplementation< T1, T2, OtherAlloc, true >& toCopy);

    BijectionImplementation(
       BijectionImplementation< T1, T2, Alloc, true >&& from) noexcept;

    public:
    // ============================================================================
    // ============================================================================

    ~BijectionImplementation();


    private:
    BijectionImplementation< T1, T2, Alloc, true >&
       operator=(const BijectionImplementation< T1, T2, Alloc, true >& toCopy);

    template < typename OtherAlloc >
    BijectionImplementation< T1, T2, Alloc, true >& operator=(
       const BijectionImplementation< T1, T2, OtherAlloc, true >& toCopy);

    BijectionImplementation< T1, T2, Alloc, true >&
       operator=(BijectionImplementation< T1, T2, Alloc, true >&& from);

    public:
    // ============================================================================
    // ============================================================================

    iterator begin() const;

    const_iterator cbegin() const;

    const iterator& end() const noexcept;

    const const_iterator& cend() const noexcept;

    iterator_safe beginSafe() const;

    const_iterator_safe cbeginSafe() const;

    const iterator_safe& endSafe() const noexcept;

    const const_iterator_safe& cendSafe() const noexcept;

    static const iterator_safe& endSafe4Statics();

    static const iterator& end4Statics();

    // ============================================================================
    // ============================================================================

    const T1& first(T2 second) const;

    const T1& firstWithDefault(T2 second, T1 default_val) const;

    const T2& second(T1 first) const;

    const T2& secondWithDefault(T1 first, T2 default_val) const;

    bool existsFirst(T1 first) const;

    bool existsSecond(T2 second) const;

    void insert(T1 first, T2 second);

    template < typename... Args >
    void emplace(Args&&... args);

    void clear();

    bool empty() const noexcept;

    Size size() const noexcept;

    void eraseFirst(T1 first);

    void eraseSecond(T2 second);

    std::string toString() const;

    // ============================================================================
    // ============================================================================

    Size capacity() const noexcept;

    void resize(Size new_size);

    void setResizePolicy(const bool new_policy) noexcept;

    bool resizePolicy() const noexcept;


    private:
    using HashTable12 = HashTable< T1, T2, allocator12_type >;
    using HashTable21 = HashTable< T2, T1, allocator21_type >;

    friend class BijectionIteratorSafe< T1, T2 >;
    friend class BijectionIterator< T1, T2 >;
    friend class Bijection< T1, T2, Alloc >;
    template < typename TT1, typename TT2, typename A, bool >
    friend class BijectionImplementation;

    // Below, we create the two gum::HashTable used by the gum::Bijection. Note
    // that the values of these gum::HashTable are pointers. This enables to
    // create only once objects (T1,T2). When using gum::Bijection with large
    // size objects, this feature is of particular interest.

    HashTable12 __firstToSecond;

    HashTable21 __secondToFirst;

    template < typename OtherAlloc >
    void __copy(const HashTable< T1, T2, OtherAlloc >& f2s);

    void __insert(const T1 first, const T2 second);
  };

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

  class BijectionIteratorStaticEnd {
    template < typename T1, typename T2, typename Alloc, bool >
    friend class BijectionImplementation;

    private:
    static const BijectionIteratorSafe< int, int >* __BijectionIterEndSafe;

    static const BijectionIterator< int, int >* __BijectionIterEnd;

    static const BijectionIteratorSafe< int, int >* endSafe4Statics();

    static const BijectionIterator< int, int >* end4Statics();
  };

  template < bool gen >
  struct BijectionIteratorGet {
    template < typename T >
    INLINE static const T& op_second(const T* x) {
      return *x;
    }
  };

  template <>
  struct BijectionIteratorGet< true > {
    template < typename T >
    INLINE static const T& op_second(const T& x) {
      return x;
    }
  };

  // ===========================================================================
  // ===                      BIJECTION SAFE ITERATORS                       ===
  // ===========================================================================

  template < typename T1, typename T2 >
  class BijectionIteratorSafe {
    template < typename TT1, typename TT2, typename Alloc, bool >
    friend class BijectionImplementation;

    public:
    using iterator_category = std::forward_iterator_tag;
    using type1_type = T1;
    using type1_reference = T1&;
    using type1_const_reference = const T1&;
    using type1_pointer = T1*;
    using type1_const_pointer = const T1*;
    using type2_type = T2;
    using type2_reference = T2&;
    using type2_const_reference = const T2&;
    using type2_pointer = T2*;
    using type2_const_pointer = const T2*;
    using difference_type = std::ptrdiff_t;

    private:
    using Getter = BijectionIteratorGet< std::is_scalar< T1 >::value
                                         && std::is_scalar< T2 >::value >;

    template < typename Alloc, bool Gen >
    BijectionIteratorSafe(
       const BijectionImplementation< T1, T2, Alloc, Gen >& bijection);

    public:
    // ============================================================================
    // ============================================================================

    BijectionIteratorSafe() noexcept;

    template < typename Alloc >
    BijectionIteratorSafe(const Bijection< T1, T2, Alloc >& bijection);

    BijectionIteratorSafe(const BijectionIteratorSafe< T1, T2 >& from);

    BijectionIteratorSafe(BijectionIteratorSafe< T1, T2 >&& from) noexcept;

    ~BijectionIteratorSafe() noexcept;

    // ============================================================================
    // ============================================================================

    BijectionIteratorSafe< T1, T2 >&
       operator=(const BijectionIteratorSafe< T1, T2 >& toCopy);

    BijectionIteratorSafe< T1, T2 >&
       operator=(BijectionIteratorSafe< T1, T2 >&& toMove) noexcept;

    BijectionIteratorSafe< T1, T2 >& operator++() noexcept;

    BijectionIteratorSafe< T1, T2 >& operator+=(Size nb) noexcept;

    BijectionIteratorSafe< T1, T2 > operator+(Size nb) noexcept;

    bool operator!=(const BijectionIteratorSafe< T1, T2 >& toCompare) const
       noexcept;

    bool operator==(const BijectionIteratorSafe< T1, T2 >& toCompare) const
       noexcept;

    // ============================================================================
    // ============================================================================

    const T1& first() const;

    const T2& second() const;


    private:
    using HashTable12 = typename std::conditional<
       std::is_scalar< T1 >::value && std::is_scalar< T2 >::value,
       HashTable< T1, T2, std::allocator< std::pair< T1, T2 > > >,
       HashTable< T1, T2*, std::allocator< std::pair< T1, T2* > > > >::type;

    using HashIter = typename HashTable12::const_iterator_safe;

    HashIter __iter;
  };

  // ===========================================================================
  // ===                     BIJECTION UNSAFE ITERATORS                      ===
  // ===========================================================================
  template < typename T1, typename T2 >
  class BijectionIterator {
    template < typename TT1, typename TT2, typename Alloc, bool >
    friend class BijectionImplementation;

    public:
    using iterator_category = std::forward_iterator_tag;
    using type1_type = T1;
    using type1_reference = T1&;
    using type1_const_reference = const T1&;
    using type1_pointer = T1*;
    using type1_const_pointer = const T1*;
    using type2_type = T2;
    using type2_reference = T2&;
    using type2_const_reference = const T2&;
    using type2_pointer = T2*;
    using type2_const_pointer = const T2*;
    using difference_type = std::ptrdiff_t;

    private:
    using Getter = BijectionIteratorGet< std::is_scalar< T1 >::value
                                         && std::is_scalar< T2 >::value >;

    template < typename Alloc, bool Gen >
    BijectionIterator(
       const BijectionImplementation< T1, T2, Alloc, Gen >& bijection);

    public:
    // ============================================================================
    // ============================================================================

    BijectionIterator() noexcept;

    template < typename Alloc >
    BijectionIterator(const Bijection< T1, T2, Alloc >& bijection);

    BijectionIterator(const BijectionIterator< T1, T2 >& from);

    BijectionIterator(BijectionIterator< T1, T2 >&& from) noexcept;

    ~BijectionIterator() noexcept;

    // ============================================================================
    // ============================================================================

    BijectionIterator< T1, T2 >&
       operator=(const BijectionIterator< T1, T2 >& toCopy);

    BijectionIterator< T1, T2 >&
       operator=(BijectionIterator< T1, T2 >&& toMove) noexcept;

    BijectionIterator< T1, T2 >& operator++() noexcept;

    BijectionIterator< T1, T2 >& operator+=(Size nb) noexcept;

    BijectionIterator< T1, T2 > operator+(Size nb) noexcept;

    bool operator!=(const BijectionIterator< T1, T2 >& toCompare) const noexcept;

    bool operator==(const BijectionIterator< T1, T2 >& toCompare) const noexcept;

    // ============================================================================
    // ============================================================================

    const T1& first() const;

    const T2& second() const;


    private:
    using HashTable12 = typename std::conditional<
       std::is_scalar< T1 >::value && std::is_scalar< T2 >::value,
       HashTable< T1, T2, std::allocator< std::pair< T1, T2 > > >,
       HashTable< T1, T2*, std::allocator< std::pair< T1, T2* > > > >::type;
    using HashIter = typename HashTable12::const_iterator;

    HashIter __iter;
  };

  template < typename T1, typename T2, typename Alloc = std::allocator< T2 > >
  class Bijection
      : public BijectionImplementation< T1,
                                        T2,
                                        Alloc,
                                        std::is_scalar< T1 >::value
                                           && std::is_scalar< T2 >::value > {
    public:
    using type1_type = T1;
    using type1_reference = T1&;
    using type1_const_reference = const T1&;
    using type1_pointer = T1*;
    using type1_const_pointer = const T1*;
    using type2_type = T2;
    using type2_reference = T2&;
    using type2_const_reference = const T2&;
    using type2_pointer = T2*;
    using type2_const_pointer = const T2*;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using allocator_type = Alloc;
    using iterator = BijectionIterator< T1, T2 >;
    using const_iterator = BijectionIterator< T1, T2 >;
    using iterator_safe = BijectionIteratorSafe< T1, T2 >;
    using const_iterator_safe = BijectionIteratorSafe< T1, T2 >;

    using allocator1_type = typename Alloc::template rebind< T1* >::other;
    using allocator2_type = typename Alloc::template rebind< T2* >::other;

    using Implementation =
       BijectionImplementation< T1,
                                T2,
                                Alloc,
                                std::is_scalar< T1 >::value
                                   && std::is_scalar< T2 >::value >;

    // ============================================================================
    // ============================================================================

    Bijection(Size size = HashTableConst::default_size,
              bool resize_policy = HashTableConst::default_resize_policy);

    Bijection(std::initializer_list< std::pair< T1, T2 > > list);

    Bijection(const Bijection< T1, T2, Alloc >& toCopy);

    template < typename OtherAlloc >
    Bijection(const Bijection< T1, T2, OtherAlloc >& toCopy);

    Bijection(Bijection< T1, T2, Alloc >&& from) noexcept;

    ~Bijection();

    // ============================================================================
    // ============================================================================

    Bijection< T1, T2, Alloc >&
       operator=(const Bijection< T1, T2, Alloc >& toCopy);

    template < typename OtherAlloc >
    Bijection< T1, T2, Alloc >&
       operator=(const Bijection< T1, T2, OtherAlloc >& toCopy);

    Bijection< T1, T2, Alloc >& operator=(Bijection< T1, T2, Alloc >&& bij);

  };

  template < typename T1, typename T2, typename Alloc >
  std::ostream& operator<<(std::ostream&,
                           const Bijection< T1, T2, Alloc >& bijection);

} /* namespace gum */


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
#  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
extern template class gum::Bijection< int, int >;
#  endif
#endif
#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
#  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
extern template class gum::Bijection< std::string, std::string >;
#  endif
#endif


// always include the template implementations
#include <agrum/core/bijection_tpl.h>

#endif /* GUM_BIJECTION_H */