linked_list_node.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/allocator.hpp"
#include "../../null.hpp"
#include "../../nullopt.hpp"
#include "../../object.hpp"
#include "../../optional.hpp"
#include "../../ref.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      template<class type_t, class allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
      class linked_list;
      
      template<class type_t>
      class linked_list_node final : public xtd::object {
      public:
        
        using value_type = type_t;
        using linked_list_type = linked_list<value_type>;
        using base_type = typename linked_list_type::base_type;
        using size_type = typename linked_list_type::size_type;
        
        
        linked_list_node(const value_type & value) {data_->value = value;}
        
        linked_list_node(value_type&& value) {data_->value = std::move(value);}
        linked_list_node(linked_list_node&&) = default;
        linked_list_node(const linked_list_node&) = default;
        
        
        auto list() const noexcept -> xtd::ref<const linked_list<type_t>> {return data_->list ? ref {*data_->list} : xtd::ref<linked_list<type_t>> {};}
        
        auto next() const -> xtd::optional<linked_list_node> {
          check_stale();
          if (!data_->list || !data_->list->count() || data_->iterator == end()) return xtd::nullopt;
          auto tmp = data_->iterator;
          if (++tmp == end()) return xtd::nullopt;
          return linked_list_node {*data_->list, tmp, data_->version};
        }
        
        auto previous() const -> xtd::optional<linked_list_node> {
          check_stale();
          if (!data_->list || !data_->list->count() || data_->iterator == begin()) return xtd::nullopt;
          auto tmp = data_->iterator;
          return linked_list_node {*data_->list, --tmp, data_->version};
        }
        
        auto value() const -> const value_type& {
          check_stale();
          return data_->value.has_value() ? data_->value.value() : *data_->iterator;
        }

        auto value() -> value_type& {
          check_stale();
          return data_->value.has_value() ? data_->value.value() : *data_->iterator;
        }

        
        auto operator =(linked_list_node&&) -> linked_list_node& = default;
        auto operator =(const linked_list_node&) -> linked_list_node& = default;
        
      private:
        friend class linked_list<type_t>;
        using iterator_type = typename base_type::iterator;
        
        linked_list_node(linked_list_type & list, iterator_type iterator, size_type version) {
          data_->list = &list;
          data_->iterator = iterator;
          data_->version = version;
        }
        
        auto begin() const -> iterator_type {return data_->list->data_->items.begin();}
        auto check_stale() const -> void {if (data_->list && data_->list->data_->version != data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; node operation may not execute.");}
        auto end() const -> iterator_type {return data_->list->data_->items.end();}
        
        struct node_data {
          linked_list<type_t>* list = null;
          iterator_type iterator;
          xtd::optional < value_type > value;
          size_type version;
        };
        
        xtd::ptr < node_data > data_ = xtd::new_ptr < node_data > ();
      };
    }
  }
}