read_only_collection.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace collections {
    namespace object_model {
      template<class type_t>
      class read_only_collection : public xtd::object, public xtd::collections::generic::ilist<type_t> {
        template<class 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;
          
          inline static constexpr xtd::size npos = std::numeric_limits<xtd::size>::max();
          
          bool contains(const list_type_t& item) const noexcept override {return false;}
          void copy_to(xtd::array<list_type_t>& array, xtd::size array_index) const override {}
          generic::enumerator<list_type_t> get_enumerator() const noexcept {
            class empty_enumerator : public generic::ienumerator<list_type_t> {
            public:
              const list_type_t& current() const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
              bool move_next() override {return false;}
              void reset() override {}
            private:
            };
            return {new_ptr<empty_enumerator>()};
          }
          xtd::size index_of(const list_type_t& item) const noexcept override {return npos;}
          
          const list_type_t& operator [](xtd::size index) const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
          list_type_t& operator [](xtd::size index) override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
          
        private:
          bool is_fixed_size() const noexcept override {return false;}
          bool is_synchronized() const noexcept override {return false;}
          void add(const list_type_t& item) override {}
          void clear() override  {}
          void insert(xtd::size index, const list_type_t& item) override {}
          bool remove(const list_type_t& item) override {return false;}
          void remove_at(xtd::size index) override {}
        };
      public:
        
        using value_type = type_t;
        using base_type = const xtd::collections::generic::ilist<value_type>& ;
        using size_type = xtd::size;
        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;
        
        
        inline static constexpr xtd::size npos = std::numeric_limits<xtd::size>::max();
        
        
        explicit read_only_collection(const generic::ilist<value_type>& list) : items_(list) {}
        
        
        xtd::size count() const noexcept override {return items_.count();}
        
        static const read_only_collection<value_type>& empty() {
          static auto el = empty_list<value_type> {};
          static auto roc_el = read_only_collection<value_type> {el};
          return roc_el;
        }
        static const read_only_collection<value_type>& empty() {…}
        
        const xtd::object& sync_root() const noexcept override {return items_.sync_root();}
        
        
        bool contains(const type_t& item) const noexcept override {return items_.contains(item);}
        
        void copy_to(xtd::array<type_t>& array, xtd::size array_index) const override {return items_.copy_to(array, array_index);}
        
        generic::enumerator<type_t> get_enumerator() const noexcept override {return items_.get_enumerator();}
        
        xtd::size index_of(const type_t& item) const noexcept override {return items_.index_of(item);}
        
        
        const_reference operator [](size_type index) const override {return items_[index];}
        reference operator [](size_type index) override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_supported, "Collection is read-only.");}
        
      protected:
        
        base_type items() noexcept {return items_;}
        
      private:
        bool is_fixed_size() const noexcept override {return false;}
        bool is_read_only() const noexcept override {return false;}
        bool is_synchronized() const noexcept override {return false;}
        void add(const value_type& item) override {}
        void clear() override {}
        void insert(xtd::size index, const value_type& item) override {}
        bool remove(const value_type& item) override {return false;}
        void remove_at(xtd::size index) override {}
        base_type items_;
      };
      class read_only_collection : public xtd::object, public xtd::collections::generic::ilist<type_t> {…};
    }
    namespace object_model {…}
  }
}