xtd::collections::generic::ilist< type_t > Class Template Reference

Inheritance diagram for xtd::collections::generic::ilist< type_t >:

Definition

template<typename type_t>
class xtd::collections::generic::ilist< type_t >

Represents a collection of objects that can be individually accessed by index.

Definition

template<typename type_t>
class ilist : public xtd::collections::generic::icollection<type_t>

Header

#include <xtd/collections/ilist

Namespace

xtd::collections::generic

Library

xtd.core

Examples

The following example implements the xtd::collections::generic::ilist <type_t> interface to create a collection of custom box objects named box_collection. Each box has height, length, and width properties, which are used to define equality. Equality can be defined as all dimensions being the same or the volume being the same. The box class implements the xtd::iequatable <type_t> interface to define the default equality as the dimensions being the same.

The box_collection class implements the xtd::collections::generic::ibox::index_of method to use the default equality to determine whether a box is in the collection. This method is used by the xtd::collections::generic::icollection::add method so that each box added to the collection has a unique set of dimensions. The box_collection class also provides an overload of the xtd::collections::generic::icollection::contains method that takes a specified xtd::collections::generic::iequality_comparer <type_t> interface, such as box_same_dimensionsandbox_same_volume` classes in the example.

This example also implements an xtd::collections::generic::ienumerator <type_t> interface for the box_collection class so that the collection can be enumerated.

#include <xtd/xtd>
 
using namespace xtd;
using namespace xtd::collections::generic;
 
class program {
public:
  static auto main() -> void {
    auto boxes = box_collection {};
    
    boxes.add(program::box {10, 4, 6});
    boxes.add(program::box {4, 6, 10});
    boxes.add(program::box {6, 10, 4});
    boxes.add(program::box {12, 8, 10});
    
    // Same dimensions. Cannot be added:
    boxes.add(program::box {10, 4, 6});
    
    // Test the Remove method.
    display(boxes);
    console::write_line("Removing 6x10x4");
    boxes.remove(program::box {6, 10, 4});
    display(boxes);
    
    // Test the Contains method.
    auto box_check = program::box {8, 12, 10};
    console::write_line("Contains {}x{}x{} by dimensions: {}", box_check.height, box_check.length, box_check.width, boxes.contains(box_check));
    
    // Test the Contains method overload with a specified equality comparer.
    console::write_line("Contains {}x{}x{} by volume: {}", box_check.height, box_check.length, box_check.width, boxes.contains(box_check, box_same_volume {}));
  }
  
  struct box : public object, public iequatable<program::box> {
    // Public Constructors :
    box() = default;
    box(int h, int l, int w) : height {h}, length{l}, width {w} {}
    
    // Public Properties :
    int height = 0;
    int length = 0;
    int width = 0;
    
    // Public Methods :
    bool equals(const object& o) const noexcept override {return is<program::box>(o) && equals(as<program::box>(o));}
    bool equals(const program::box& o) const noexcept override {return box_same_dimensions {}.equals(*this, o);}
  };
  
  class box_collection : public ilist<program::box> {
  public:
    // Public Constructors :
    box_collection(const std::initializer_list<program::box>& boxes) : boxes_(boxes) {}
    
    // Public Properties :
    size count() const noexcept override {return boxes_.count();}
    
    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;}
    
    const object& sync_root() const noexcept override {return sync_root_;}
    
    // Public Methods :
    void add(const program::box& item) override {
      if (!contains(item))
        boxes_.add(item);
      else
        console::write_line("A box with {}x{}x{} dimensions was already added to the collection.", item.height, item.length, item.width);
    }
    
    void clear() override {boxes_.clear();}
    
    bool contains(const program::box& item) const noexcept override {return index_of(item) != npos;}
    
    bool contains(const program::box& item, const iequality_comparer<program::box>& comparer) const noexcept {
      for (auto box : boxes_)
        if (comparer.equals(box, item)) return true;
      return false;
    }
    
    void copy_to(array<program::box>& array, size array_index) const override {boxes_.copy_to(array, array_index);}
    
    enumerator<program::box> get_enumerator() const override {return {new_ptr<box_enumerator>(boxes_)};}
    
    size index_of(const program::box& item) const noexcept override {
      for (auto index = 0_z; index  < count(); ++index)
        if (boxes_[index] == item) return index;
      return npos;
    }
    
    void insert(size index, const program::box& item) override {
      if (index >= count()) throw argument_out_of_range_exception {};
      boxes_.insert(boxes_.begin() + index, item);
    }
    
    bool remove(const program::box& item) override {return boxes_.remove(item);}
    
    void remove_at(size index) override {
      if (index >= count()) throw argument_out_of_range_exception {};
      boxes_.erase(boxes_.begin() + index);
    }
    
    // Public Operators :
    const program::box& operator [](size index) const override {
      if (index >= count()) throw argument_out_of_range_exception {};
      return boxes_[index];
    }
    
    program::box& operator [](size index) override {
      if (index >= count()) throw argument_out_of_range_exception {};
      return boxes_[index];
    }
    
  private:
    list<program::box> boxes_;
    object sync_root_;
  };
  
  class box_enumerator : public ienumerator<program::box> {
  public:
    // Public Constructors :
    explicit box_enumerator(const list<program::box>& items) : items_(items) {}
    
    // Public Properties :
    const program::box& current() const override {return items_[index_];}
    
    // Public Methods :
    bool move_next() override {return ++index_ < items_.size();}
    void reset() override {index_ = box_integer<size>::max_value;}
    
  protected:
    const list<program::box>& items_;
    size index_ = box_integer<size>::max_value;
  };
  
  // Defines two boxes as equal if they have the same dimensions.
  class box_same_dimensions : public iequality_comparer<program::box> {
  public:
    // Public Methods :
    bool equals(const program::box& b1, const program::box& b2) const noexcept override {return b1.height == b2.height && b1.length == b2.length && b1.width == b2.width;}
    
    size get_hash_code(const program::box& box) const noexcept override {return hash_code::combine(box.height, box.length, box.width);}
  };
  
  // Defines two boxes as equal if they have the same volume.
  class box_same_volume : public iequality_comparer<program::box> {
  public:
    // Public Methods :
    bool equals(const program::box& b1, const program::box& b2) const noexcept override {return b1.height * b1.length * b1.width == b2.height * b2.length * b2.width;}
    
    size get_hash_code(const program::box& box) const noexcept override {
      auto hash_code = hash_code::combine(box.height, box.length, box.width);
      console::write_line("HC: {}", hash_code);
      return hash_code;
    }
  };
  
  static void display(const box_collection& boxes) {
    console::write_line("\nheight  length  width   hash code");
    for (auto index = 0_z; index < boxes.count(); ++index)
      console::write_line("{,-6}  {,-6}  {,-6}  {}", boxes[index].height, boxes[index].length, boxes[index].width, boxes[index].get_hash_code());
    
    // Results by manipulating the iterator directly:
    
    //console::write_line("\nheight  length  width   hash code");
    //for (auto box : boxes)
    //  console::write_line("{,-6}  {,-6}  {,-6}  {}", box.height, box.length, box.width, box.get_hash_code());
    
    
    // Results by manipulating the enumerator directly:
    
    //auto enumerator = boxes.get_enumerator();
    //console::write_line("\nheight  length  width   hash code");
    //while (enumerator.move_next()) {
    //  auto b = enumerator.current();
    //  console::write_line("{,-6}  {,-6}  {,-6}  {}", b.height, b.length, b.width, b.get_hash_code());
    //}
    
    console::write_line();
  }
};
 
startup_(program::main);
 
// This code can produce the following output :
//
// A box with 10x4x6 dimensions was already added to the collection.
//
// height  length  width   hash code
// 10      4       6       215240349697
// 4       6       10      215240349697
// 6       10      4       215240349697
// 12      8       10      215240349697
//
// Removing 6x10x4
//
// height  length  width   hash code
// 10      4       6       215240349697
// 4       6       10      215240349697
// 12      8       10      215240349697
//
// Contains 8x12x10 by dimensions: false
// Contains 8x12x10 by volume: true

Remarks

The xtd::collections::generic::ilist <type_t> interface is the base interface for classes in the xtd::collections::generic namespace.

The xtd::collections::generic::ilist <type_t> interface extends xtd::collections::generic::ienumerable <type_t>; xtd::collections::generic::idictionary <key_t, value_t> and xtd::collections::generic::ilist <type_t> are more specialized interfaces that extend xtd::collections::generic::ilist <type_t>. A xtd::collections::generic::idictionary <key_t, value_t> implementation is a collection of key/value pairs, like the xtd::collections::generic::dictoinary <key_t, value_t> class. A xtd::collections::generic::ilist <type_t> implementation is a collection of values, and its members can be accessed by index, like the xtd::collections::generic::list <type_t> class.

If neither the xtd::collections::generic::idictionary <key_t, value_t> interface nor the xtd::collections::generic::ilist <type_t> interface meet the requirements of the required collection, derive the new collection class from the xtd::collections::generic::ilist <type_t> interface instead for more flexibility.

Examples

generic_ilist.cpp, and ilist.cpp.

Public Aliases
using	iterator = typename icollection< type_t >::iterator
	Represents the iterator of xtd::collections::generic::ienumerable value type.
using	const_iterator = typename icollection< type_t >::const_iterator
	Represents the const iterator of xtd::collections::generic::ienumerable value type.

Public Fields
static constexpr xtd::size	npos
	This is a special value equal to the maximum value representable by the type xtd::size.

Public Properties
virtual bool	is_fixed_size () const noexcept=0
	Gets a value indicating whether the xtd::collections::generic::ilist <type_t> has a fixed size.

Public Methods
virtual xtd::size	index_of (const type_t &item) const noexcept=0
	Determines the index of a specific item in the xtd::collections::generic::ilist <type_t>.
virtual void	insert (xtd::size index, const type_t &item)=0
	Inserts an item to the xtd::collections::generic::ilist <type_t> at the specified index.
virtual void	remove_at (xtd::size index)=0
	Removes the xtd::collections::generic::ilist <type_t> item at the specified index.

Public Operators
virtual const type_t &	operator[] (xtd::size index) const =0
	Gets the element at the specified index.
virtual type_t &	operator[] (xtd::size index)=0
	Sets the element at the specified index.

Additional Inherited Members
Public Types inherited from xtd::collections::generic::icollection< type_t >
using	iterator = typename ienumerable< type_t >::iterator
	Represents the iterator of xtd::collections::generic::ienumerable value type.
using	const_iterator = typename ienumerable< type_t >::const_iterator
	Represents the const iterator of xtd::collections::generic::ienumerable value type.
Public Types inherited from xtd::collections::generic::ienumerable< type_t >
using	iterator = typename enumerable_iterators< type_t, ienumerable< type_t > >::iterator
	Represents the iterator of xtd::collections::generic::ienumerable value type.
using	const_iterator = typename enumerable_iterators< type_t, ienumerable< type_t > >::const_iterator
	Represents the const iterator of xtd::collections::generic::ienumerable value type.
Public Types inherited from xtd::collections::generic::enumerable_iterators< type_t, ienumerable< type_t > >
using	const_iterator = const iterator
	Represents the const iterator of enumarable value type.
Public Member Functions inherited from xtd::collections::generic::icollection< type_t >
virtual xtd::size	count () const noexcept=0
	Gets the number of elements contained in the xtd::collections::generic::icollection <type_t>.
virtual bool	is_read_only () const noexcept=0
	Gets a value indicating whether the xtd::collections::generic::icollection <type_t> is read-only.
virtual bool	is_synchronized () const noexcept=0
	Gets a value indicating whether access to the xtd::collections::generic::icollection <type_t> is synchronized (thread safe).
virtual const xtd::object &	sync_root () const noexcept=0
	Gets an object that can be used to synchronize access to the the xtd::collections::generic::icollection <type_t>.
virtual void	add (const type_t &item)=0
	Adds an item to the xtd::collections::generic::icollection <type_t>.
virtual void	clear ()=0
	Removes all items from the xtd::collections::generic::icollection <type_t>.
virtual bool	contains (const type_t &item) const noexcept=0
	Determines whether the xtd::collections::generic::icollection <type_t> contains a specific value.
virtual void	copy_to (xtd::array< type_t > &array, xtd::size array_index) const =0
	Copies the elements of the xtd::collections::generic::icollection <type_t> to an xtd::array, starting at a particular xtd::array index.
virtual bool	remove (const type_t &item)=0
	Removes the first occurrence of a specific object from the xtd::collections::generic::icollection <type_t>.
Public Member Functions inherited from xtd::collections::generic::ienumerable< type_t >
virtual enumerator< type_t >	get_enumerator () const =0
	Returns an enumerator that iterates through a collection.
Public Member Functions inherited from xtd::collections::generic::enumerable_iterators< type_t, ienumerable< type_t > >
virtual const_iterator	begin () const
	Returns an iterator to the first element of the enumarable.
virtual iterator	begin ()
	Returns an iterator to the first element of the enumarable.
virtual const_iterator	cbegin () const
	Returns an iterator to the first element of the enumarable.
virtual const_iterator	cend () const
	Returns an iterator to the element following the last element of the enumarable.
virtual const_iterator	end () const
	Returns an iterator to the element following the last element of the enumarable.
virtual iterator	end ()
	Returns an iterator to the element following the last element of the enumarable.

Member Typedef Documentation

iterator

template<typename type_t >

using xtd::collections::generic::ilist< type_t >::iterator = typename icollection<type_t>::iterator

Represents the iterator of xtd::collections::generic::ienumerable value type.

const_iterator

template<typename type_t >

using xtd::collections::generic::ilist< type_t >::const_iterator = typename icollection<type_t>::const_iterator

Represents the const iterator of xtd::collections::generic::ienumerable value type.

Member Function Documentation

is_fixed_size()

template<typename type_t >

virtual bool xtd::collections::generic::ilist< type_t >::is_fixed_size ( ) const

pure virtualnoexcept

Gets a value indicating whether the xtd::collections::generic::ilist <type_t> has a fixed size.

Returns

true if the xtd::collections::generic::ilist <type_t> has a fixed size; otherwise, false.

Remarks

A collection with a fixed size does not allow the addition or removal of elements after the collection is created, but it allows the modification of existing elements.

Implemented in xtd::basic_array< type_t, allocator_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< value_type, allocator_t >, and xtd::collections::generic::list< type_t, allocator_t >.

index_of()

template<typename type_t >

virtual xtd::size xtd::collections::generic::ilist< type_t >::index_of ( const type_t &  item ) const

pure virtualnoexcept

Determines the index of a specific item in the xtd::collections::generic::ilist <type_t>.

Parameters

item	The object to locate in the xtd::collections::generic::ilist <type_t>.

Returns

The index of item if found in the list; otherwise, xtd::collections::generic::ilist::npos.

Remarks

If an object occurs multiple times in the list, the xtd::collections::generic::ilist::index_of method always returns the first instance found.

Implemented in xtd::collections::object_model::read_only_collection< type_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< type_t, allocator_t >, and xtd::collections::generic::list< type_t, allocator_t >.

insert()

template<typename type_t >

virtual void xtd::collections::generic::ilist< type_t >::insert ( xtd::size  index, const type_t &  item  )

pure virtual

Inserts an item to the xtd::collections::generic::ilist <type_t> at the specified index.

Parameters

index	The zero-based index at which item should be inserted.
item	The object to insert into the xtd::collections::generic::ilist <type_t>.

Exceptions

xtd::argument_out_of_range_exception	`index` is not a valid index in the xtd::collections::generic::ilist <type_t>.
xtd::not_supported_exception	The xtd::collections::generic::ilist <type_t> is read-only.

Remarks

If index equals the number of items in the xtd::collections::generic::ilist <type_t>, then item is appended to the list.

In collections of contiguous elements, such as lists, the elements that follow the insertion point move down to accommodate the new element. If the collection is indexed, the indexes of the elements that are moved are also updated. This behavior does not apply to collections where elements are conceptually grouped into buckets, such as a hash table.

Implemented in xtd::collections::generic::list< type_t, allocator_t >.

remove_at()

template<typename type_t >

virtual void xtd::collections::generic::ilist< type_t >::remove_at ( xtd::size  index )

pure virtual

Removes the xtd::collections::generic::ilist <type_t> item at the specified index.

Parameters

index

The zero-based index of the item to remove.

Exceptions

xtd::argument_out_of_range_exception	`index` is not a valid index in the xtd::collections::generic::ilist <type_t>.
xtd::not_supported_exception	The xtd::collections::generic::ilist <type_t> is read-only.

Remarks

In collections of contiguous elements, such as lists, the elements that follow the removed element move up to occupy the vacated spot. If the collection is indexed, the indexes of the elements that are moved are also updated. This behavior does not apply to collections where elements are conceptually grouped into buckets, such as a hash table.

Implemented in xtd::collections::generic::list< type_t, allocator_t >.

operator[]() [1/2]

template<typename type_t >

virtual const type_t & xtd::collections::generic::ilist< type_t >::operator[] ( xtd::size  index ) const

pure virtual

Gets the element at the specified index.

Parameters

index

The zero-based index of the element to get.

Remarks

This operator provides the ability to access a specific element in the collection by using the following syntax: my_collection[index].

Implemented in xtd::array< type_t, 1, allocator_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< value_type, allocator_t >, xtd::collections::generic::list< type_t, allocator_t >, and xtd::collections::object_model::read_only_collection< type_t >.

operator[]() [2/2]

template<typename type_t >

virtual type_t & xtd::collections::generic::ilist< type_t >::operator[] ( xtd::size  index )

pure virtual

Sets the element at the specified index.

Parameters

index

The zero-based index of the element to set.

Remarks

This operator provides the ability to access a specific element in the collection by using the following syntax: my_collection[index].

Implemented in xtd::array< type_t, 1, allocator_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< type_t, allocator_t >, xtd::basic_array< value_type, allocator_t >, and xtd::collections::generic::list< type_t, allocator_t >.

Member Data Documentation

npos

template<typename type_t >

constexpr xtd::size xtd::collections::generic::ilist< type_t >::npos

inlinestaticconstexpr

This is a special value equal to the maximum value representable by the type xtd::size.

---

The documentation for this class was generated from the following file:

• xtd.core/include/xtd/collections/generic/ilist.h