BiMap working

//  bimap.cpp

#include "bimap.h"

struct BiMap::Impl {

    Impl() {};
    Impl(const Impl& other) = default;
    Impl& operator=(const Impl& other) = default;

    bool Add(std::string_view key, std::string_view value) {
        // TODO: Реализуйте метод самостоятельно
        if (k2v_.find(key) != k2v_.end() || v2k_.find(value) != v2k_.end()) {
            return false;
        }
        try {
            dictionary_.emplace_back(value);
            std::string_view val_ref = dictionary_.back();

            dictionary_.emplace_back(key);
            std::string_view key_ref = dictionary_.back();

            v2k_.emplace(val_ref, key_ref);
            k2v_.emplace(key_ref, val_ref);

        } catch (std::bad_alloc& ba) {
            throw new std::bad_alloc;
        }
        return true;
    }

    std::optional<std::string_view> FindValue(std::string_view key) const noexcept {
        // TODO: Реализуйте метод самостоятельно
        try {
            return k2v_.at(key);
        }
        catch (std::out_of_range& oor) {
            return std::nullopt;
        }
    }

    std::optional<std::string_view> FindKey(std::string_view value) const noexcept {
        // TODO: Реализуйте метод самостоятельно
        try {
            return v2k_.at(value);
        }
        catch (std::out_of_range& oor) {
            return std::nullopt;
        }
    }
private:
    std::deque<std::string> dictionary_;
    std::unordered_map<std::string_view, std::string_view> k2v_;
    std::unordered_map<std::string_view, std::string_view> v2k_;
};

BiMap::BiMap()
    : impl_(std::make_unique<Impl>()) {
}

BiMap::~BiMap() = default;

BiMap::BiMap(BiMap&&) noexcept = default;

BiMap& BiMap::operator=(BiMap&&) noexcept = default;

BiMap::BiMap(const BiMap& other)
    : impl_(other.impl_ ? std::make_unique<Impl>(*other.impl_) : nullptr) {
}

BiMap& BiMap::operator=(const BiMap& other) {
    if (this != std::addressof(other)) {
        impl_ = std::make_unique<Impl>(*other.impl_);
        if (!other.impl_) {     // Правый аргумент пуст?
            impl_.reset();
        } else if (impl_) {     // Левый и правый аргументы не пустые?
            assert(other.impl_);
            *impl_ = *other.impl_;
        } else {                // Левый аргумент пуст, а правый не пуст
            assert(!impl_ && other.impl_);
        }
    }
    return *this;
}

bool BiMap::Add(std::string_view key, std::string_view value) {
    return impl_->Add(key, value);
}

std::optional<std::string_view> BiMap::FindValue(std::string_view key) const noexcept {
    return impl_->FindValue(key);
}

std::optional<std::string_view> BiMap::FindKey(std::string_view value) const noexcept {
    return impl_->FindKey(value);
}

// bimap.h
#pragma once
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <deque>
#include <memory>
#include <stdexcept>
#include <cassert>

class BiMap {
public:
    /**
     * Добавляет в словарь пару "ключ-значение".
     * В случае успеха возвращает true.
     * Возвращает false, если ключ или значение были ранее добавлены.
     *
     * Метод обеспечивает строгую гарантию безопасности исключений
     */
    BiMap();
    ~BiMap();
    BiMap(BiMap&&) noexcept;
    BiMap& operator=(BiMap&&) noexcept;
    BiMap(const BiMap& other);
    BiMap& operator=(const BiMap& other);

    bool Add(std::string_view key, std::string_view value);

    /**
     * Возвращает значение, связанное с ключом, либо nullopt, если такого ключа нет
     */
    std::optional<std::string_view> FindValue(std::string_view key) const noexcept;

    /**
     * Возвращает ключ, связанный с value, либо nullopt, если такого значения нет
     */
    std::optional<std::string_view> FindKey(std::string_view value) const noexcept;

private:
    /* Класс должен использовать идиому Pimpl, поддерживать копирование и перемещение */
    struct Impl;
    // unique_ptr автоматически удалит связанные с классом данные
    std::unique_ptr<Impl> impl_;
};