read_only_collection.hpp

Go to the documentation of this file.

#pragma once
#include "../generic/ilist.hpp"
#include "../../helpers/throw_helper.hpp"
#include "../../string.hpp"
#include "../../usize.hpp"
#include <limits>

namespace xtd {
  namespace collections {
    namespace object_model {
      template<typename type_t>
      class read_only_collection : public xtd::object, public xtd::collections::generic::ilist<type_t> {
        template<typename list_type_t>
        class empty_list : public generic::ilist<list_type_t> {
        public:
          using iterator = typename generic::ilist<list_type_t>::iterator;
          using const_iterator = typename generic::ilist<list_type_t>::const_iterator;
          
          [[nodiscard]] auto contains(const list_type_t& item) const noexcept -> bool override {return false;}
          auto copy_to(xtd::array<list_type_t>& array, xtd::usize array_index) const -> void override {}
          [[nodiscard]] generic::enumerator<list_type_t> get_enumerator() const noexcept override {
            struct empty_list_enumerator : public generic::ienumerator<list_type_t> {
              [[nodiscard]] const list_type_t& current() const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
              [[nodiscard]] bool move_next() override {return false;}
              void reset() override {}
            };
            return {new_ptr<empty_list_enumerator>()};
          }
          [[nodiscard]] auto index_of(const list_type_t& item) const noexcept -> xtd::usize override {return npos;}
          
          const list_type_t& operator [](xtd::usize index) const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
          list_type_t& operator [](xtd::usize index) override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
          
        private:
          auto is_fixed_size() const noexcept -> bool override {return false;}
          auto is_synchronized() const noexcept -> bool override {return false;}
          auto add(const list_type_t& item) -> void override {}
          auto clear() -> void override {}
          auto insert(xtd::usize index, const list_type_t& item) -> void override {}
          auto remove(const list_type_t& item) -> bool override {return false;}
          auto remove_at(xtd::usize index) -> void override {}
        };
        
      public:
        
        using value_type = type_t;
        using base_type = const xtd::collections::generic::ilist<value_type>& ;
        using size_type = xtd::usize;
        using difference_type = xtd::ptrdiff;
        using reference = value_type&;
        using const_reference = const value_type&;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using iterator = typename generic::icollection<type_t>::iterator;
        using const_iterator = typename generic::icollection<type_t>::const_iterator;
        
        
        explicit read_only_collection(const xtd::collections::generic::ilist<value_type>& list) : items_(list) {}
        
        
        [[nodiscard]] auto count() const noexcept -> xtd::usize override {return items_.count();}
        
        [[nodiscard]] static auto empty_collection() -> const read_only_collection<value_type>& {
          static auto el = empty_list<value_type> {};
          static auto roc_el = read_only_collection<value_type> {el};
          return roc_el;
        }
        
        [[nodiscard]] const xtd::object& sync_root() const noexcept override {return items_.sync_root();}
        
        
        [[nodiscard]] auto contains(const type_t& item) const noexcept -> bool override {return items_.contains(item);}
        
        auto copy_to(xtd::array<type_t>& array, xtd::usize array_index) const -> void override {return items_.copy_to(array, array_index);}
        
        [[nodiscard]] generic::enumerator<value_type> get_enumerator() const noexcept override {return items_.get_enumerator();}
        
        [[nodiscard]] auto index_of(const type_t& item) const noexcept -> xtd::usize override {return items_.index_of(item);}
        
        [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return xtd::string::format("[{}]", xtd::string::join(", ", self_));}
        
        
        auto operator [](size_type index) const -> const_reference override {return items_[index];}
        auto operator [](size_type index) -> reference override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_supported, "Collection is read-only.");}
        
      protected:
        
        auto items() noexcept -> base_type {return items_;}
        
      private:
        auto is_fixed_size() const noexcept -> bool override {return false;}
        auto is_read_only() const noexcept -> bool override {return true;}
        auto is_synchronized() const noexcept -> bool override {return false;}
        auto add(const value_type& item) -> void override {}
        auto clear() -> void override {}
        auto insert(xtd::usize index, const value_type& item) -> void override {}
        auto remove(const value_type& item) -> bool override {return false;}
        auto remove_at(xtd::usize index) -> void override {}
        base_type items_;
      };

      // Deduction guides for xtd::collections::object_model::list
      // {
      template<typename type_t>
      read_only_collection(const xtd::collections::generic::ilist<type_t>&) -> read_only_collection<type_t>;
      // }
    }
  }
}