AMap.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * 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 http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
#include <map>
#include <unordered_map>
#include "AUI/Core.h"
#include "AException.h"
#include <AUI/Common/AVector.h>
#include <AUI/Traits/containers.h>
#include <AUI/Reflect/AClass.h>
#include "AContainerPrototypes.h"

template <class KeyType, class ValueType, class Parent>
class ABaseMap: public Parent
{
public:
   using iterator = typename Parent::iterator;
   using const_iterator = typename Parent::const_iterator;
 
   using Parent::Parent;
 
   ValueType& operator[](KeyType&& k)
   {
       return Parent::operator[](std::move(k));
   }
 
   ValueType& operator[](const KeyType& k)
   {
       return Parent::operator[](k);
   }
 
   const ValueType& operator[](KeyType&& k) const
   {
       return Parent::at(std::move(k));
   }
 
   const ValueType& operator[](const KeyType& k) const
   {
       return Parent::at(k);
   }
 
   // ================
 
   struct contains_iterator
   {
   private:
       iterator mIterator;
       bool mValid;
       
   public:
       contains_iterator(const iterator& p, bool valid):
           mIterator(p),
           mValid(valid)
       {
           
       }
       contains_iterator(const contains_iterator& c):
           mIterator(c.mIterator),
           mValid(c.mValid)
       {
           
       }
 
       operator bool() const noexcept {
           return mValid;
       }
 
       iterator operator->() const noexcept
       {
           return mIterator;
       }
       iterator operator*() const noexcept
       {
           return mIterator;
       }
   };
   struct const_contains_iterator
   {
   private:
       const_iterator mIterator;
       bool mValid;
 
   public:
       const_contains_iterator(const const_iterator& p, bool valid):
           mIterator(p),
           mValid(valid)
       {
 
       }
       const_contains_iterator(const const_contains_iterator& c):
           mIterator(c.mIterator),
           mValid(c.mValid)
       {
 
       }
 
       operator bool() const noexcept {
           return mValid;
       }
 
       const_iterator operator->() const noexcept
       {
           return mIterator;
       }
       const_iterator operator*() const noexcept
       {
           return mIterator;
       }
   };
 
   ValueType& at(const KeyType& key) {
       auto it = Parent::find(key);
       if (it == Parent::end())
           throw AException("no such element: " + AClass<KeyType>::toString(key));
       return it->second;
   }
   const ValueType& at(const KeyType& key) const {
       auto it = Parent::find(key);
       if (it == Parent::end())
           throw AException("no such element: " + AClass<KeyType>::toString(key));
       return it->second;
   }
 
   [[nodiscard]]
   const_contains_iterator contains(const KeyType& key) const noexcept
   {
       auto it = Parent::find(key);
       return const_contains_iterator(it, it != Parent::end());
   }
 
   [[nodiscard]]
   contains_iterator contains(const KeyType& key) noexcept
   {
       auto it = Parent::find(key);
       return contains_iterator(it, it != Parent::end());
   }
 
   [[nodiscard]]
   AOptional<ValueType> optional(const KeyType& key) const noexcept {
       auto it = Parent::find(key);
       if (it == Parent::end()) {
           return std::nullopt;
       }
       return it->second;
   }
 
   AVector<KeyType> keyVector() {
       AVector<KeyType> r;
       r.reserve(Parent::size());
       for (auto& p : *this) {
           r << p.first;
       }
       return r;
   }
   AVector<ValueType> valueVector() {
       AVector<ValueType> r;
       r.reserve(Parent::size());
       for (auto& p : *this) {
           r << p.second;
       }
       return r;
   }

   template<typename Factory>
   ValueType& getOrInsert(const KeyType& keyType, Factory&& factory) noexcept(noexcept(factory())) {
       static_assert(std::is_constructible_v<ValueType>, "ValueType is expected to be default-constructible");
       auto[it, isElementCreated] = Parent::insert(typename Parent::value_type(keyType, ValueType{}));
       static_assert(std::is_same_v<decltype(it), typename Parent::iterator>, "govno");
       if (isElementCreated) {
           it->second = factory();
       }
       return it->second;
   }
 
   template<typename BinaryOperation>
   auto toVector(BinaryOperation&& transformer) const -> AVector<decltype(transformer(std::declval<KeyType>(), std::declval<ValueType>()))> {
       AVector<decltype(transformer(std::declval<KeyType>(), std::declval<ValueType>()))> result;
       result.reserve(Parent::size());
       std::transform(Parent::begin(), Parent::end(), std::back_inserter(result), [transformer = std::forward<BinaryOperation>(transformer)](const typename Parent::value_type& p){
           return transformer(p.first, p.second);
       });
       return result;
   }
 
   AVector<std::tuple<KeyType, ValueType>> toVector() const {
       return toVector([](const KeyType& k, const ValueType& v) {
           return std::make_tuple(k, v);
       });
   }
};

template <class KeyType, class ValueType, class Predicate, class Allocator>
class AMap: public ABaseMap<KeyType, ValueType, std::map<KeyType, ValueType, Predicate, Allocator>>
{
   using parent = ABaseMap<KeyType, ValueType, std::map<KeyType, ValueType, Predicate, Allocator>>;
 
   using parent::parent;
};

template <class KeyType, class ValueType, class Hasher, class Comparer, class Allocator>
class AUnorderedMap: public ABaseMap<KeyType, ValueType, std::unordered_map<KeyType, ValueType, Hasher, Comparer, Allocator>>
{
   using parent = ABaseMap<KeyType, ValueType, std::unordered_map<KeyType, ValueType, Hasher, Comparer, Allocator>>;
 
   using parent::parent;
};
 
template<typename Iterator, typename UnaryOperation>
inline auto aui::container::to_map(Iterator begin,
                                  Iterator end,
                                  UnaryOperation&& transformer) {
   AMap<decltype(transformer(*begin).first),
        decltype(transformer(*begin).second)> result;
 
   for (auto it = begin; it != end; ++it) {
       auto[key, value] = transformer(*it);
       result[std::move(key)] = std::move(value);
   }
   return result;
}
 
template<typename Iterator, typename UnaryOperation>
inline auto aui::container::to_unordered_map(Iterator begin,
                                            Iterator end,
                                            UnaryOperation&& transformer) {
   AUnorderedMap<decltype(transformer(*begin).first),
                 decltype(transformer(*begin).second)> result;
 
   for (auto it = begin; it != end; ++it) {
       auto[key, value] = transformer(*it);
       result[std::move(key)] = std::move(value);
   }
   return result;
}

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.