Bimap.h

Go to the documentation of this file.

#ifndef BIMAP_PROJECT_COMMA_H
#define BIMAP_PROJECT_COMMA_H
 
/*
 * CoMMA
 *
 * Copyright © 2024 ONERA
 *
 * Authors: Nicolas Lantos, Alberto Remigi, and Riccardo Milani
 * Contributors: Karim Anemiche
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#include <cassert>
#include <iostream>
#include <map>
#include <type_traits>
 
namespace comma {
 
template<typename A, typename B>
class Bimap {
public:
  Bimap() = default;
  ~Bimap() = default;
 
  //  using container= std::map<A, const B*>;
  //  using iterator=typename container::iterator;
  //  inline iterator begin() noexcept { return _mapB.begin(); }
  //  inline iterator end() noexcept { return _mapB.end(); }
 
  void insert(const A &a, const B &b) {
    auto aitr = _mapA.insert({b, nullptr}).first;  // creates first pair
    const B *bp = &(aitr->first);  // get pointer of our stored copy of b
    auto bitr =
      _mapB.insert({a, bp}).first;  // insert second pair {a, pointer_to_b}
    const A *ap = &(bitr->first);  // update pointer in _mapA to point to a
    _mapA.insert_or_assign(b, ap);
  }
 
  void print() {
    for (const auto &[key, value] : _mapB) {
      std::cout << '[' << key << "] = " << *value << "; ";
    }
  }
 
  void update_nodeB(const A &a_old, const A &a_new) {
    auto node = _mapB.extract(a_old);
    if (!node.empty()) {
      node.key() = a_new;
      _mapB.insert(std::move(node));
    }
  }
 
  void update_nodeA(const B &b_old, const B &b_new) {
    auto node = _mapA.extract(b_old);
    if (!node.empty()) {
      node.key() = b_new;
      _mapA.insert(std::move(node));
    }
  }
 
  B get_B(const A &a) {
    // We pass the associated value we want to search to the member
    // variable
    auto it = _mapB.find(a);
    return (*(it->second));
  }
 
  A get_A(const B &b) {
    // We pass the associated value we want to search to the member
    // variable
    auto it = _mapA.find(b);
    return (*(it->second));
  }
 
  void erase_B(const A &a) {
    // We pass the associated value we want to search to the member
    // variable
    auto itB = _mapB.find(a);
    auto be = *(itB->second);
    auto itA = _mapA.find(be);
    _mapB.erase(itB);
    _mapA.erase(itA);
  }
 
  inline bool empty() { return (_mapA.empty()); }
 
  inline size_t lung() { return (_mapB.size()); }
 
protected:
  std::map<B, const A *> _mapA;
  std::map<A, const B *> _mapB;
};
 
}  // end namespace comma
 
#endif