xtd::collections::object_model::read_only_collection< type_t > Class Template Reference

Inheritance diagram for xtd::collections::object_model::read_only_collection< type_t >:

Definition

template<typename type_t>
class xtd::collections::object_model::read_only_collection< type_t >

Provides the base class for a generic read-only collection.

template<typename type_t>
class read_only_collection : public xtd::object, public xtd::collections::generic::ilist<type_t>

Header

#include <xtd/collections/object_model/read_only_collection>

Namespace

xtd::collections::object_model

Library

xtd.core

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Public Aliases
using	value_type
	Represents the list value type.
using	base_type
	Represents the list base type.
using	size_type
	Represents the list size type (usually xtd::usize).
using	difference_type
	Represents the list difference type (usually xtd::ptrdiff).
using	reference
	Represents the reference of list value type.
using	const_reference
	Represents the const reference of list value type.
using	pointer
	Represents the pointer of list value type.
using	const_pointer
	Represents the const pointer of list value type.
using	iterator
	Represents the iterator of list value type.
using	const_iterator
	Represents the const iterator of list value type.

Public Constructors
	read_only_collection (const xtd::collections::generic::ilist< value_type > &listlist)
	Initializes a new instance of the xtd::collections::object_model::read_only_collection <type_t> class that is a read-only wrapper around the specified list.

Public Properties
auto	count () const noexcept -> xtd::usize override
	Gets the number of elements contained in the xtd::collections::object_model::read_only_collection <type_t> instance.
const xtd::object &	sync_root () const noexcept override
	Gets an object that can be used to synchronize access to the the xtd::collections::generic::icollection <type_t>.
static auto	empty_collection () -> const read_only_collection< value_type > &
	Gets an empty xtd::collections::object_model::read_only_collection <type_t>.

Public Methods
auto	contains (const type_t &item) const noexcept -> bool override
	Determines whether an element is in the xtd::collections::object_model::read_only_collection <type_t>.
auto	copy_to (xtd::array< type_t > &array, xtd::usize array_index) const -> void override
	Copies the entire xtd::collections::object_model::read_only_collection <type_t> to a compatible one-dimensional Array, starting at the specified index of the target array.
generic::enumerator< value_type >	get_enumerator () const noexcept override
	Returns an enumerator that iterates through the xtd::collections::object_model::read_only_collection <type_t>.
auto	index_of (const type_t &item) const noexcept -> xtd::usize override
	Searches for the specified object and returns the zero-based index of the first occurrence within the entire xtd::collections::object_model::read_only_collection <type_t>.
auto	to_string () const noexcept -> xtd::string override
	Returns a xtd::string that represents the current object.

Public Operators
auto	operator[] (size_type index) const -> const_reference override
	Returns a reference to the element at specified location pos.
auto	operator[] (size_type index) -> reference override
	Returns a reference to the element at specified location pos.

Protected Properties
auto	items () noexcept -> base_type
	Returns the xtd::collections::generic::ilist <type_t> that the xtd::collections::object_model::read_only_collection <type_t> wraps.

Additional Inherited Members
using	value_type
	Represents the xtd::collections::generic::icollection value type.
using	value_type
	Represents the xtd::collections::generic::ienumerable value type.
using	iterator
	Represents the iterator of xtd::collections::generic::ienumerable value type.
using	const_iterator
	Represents the const iterator of xtd::collections::generic::ienumerable value type.
using	iterator
	Represents the iterator of enumerable value type.
using	const_iterator
	Represents the const iterator of enumerable value type.
using	enumerable_type
	Represents the ienumerable enumerable type.
using	source_type
	Represents the ienumerable source type.
using	ienumerable
	Represents the ienumerable value type.
using	list
	Represents the list value type.
static constexpr xtd::usize	npos
	Represents a value that is not a valid position in a collection.
static constexpr xtd::usize	bpos
	Represents the index of the first valid element in a collection.
static constexpr xtd::usize	epos
	Represents the index of the last valid element in a collection.
	object ()=default
	Create a new instance of the ultimate base class object.
virtual auto	equals (const object &obj) const noexcept -> bool
	Determines whether the specified object is equal to the current object.
virtual auto	get_hash_code () const noexcept -> xtd::usize
	Serves as a hash function for a particular type.
virtual auto	get_type () const noexcept -> type_object
	Gets the type of the current instance.
template<typename object_t>
auto	memberwise_clone () const -> xtd::unique_ptr_object< object_t >
	Creates a shallow copy of the current object.
virtual auto	begin () const -> const_iterator
	Returns an iterator to the first element of the enumerable.
virtual auto	cbegin () const -> const_iterator
	Returns an iterator to the first element of the enumerable.
virtual auto	cend () const -> const_iterator
	Returns an iterator to the element following the last element of the enumerable.
virtual auto	end () const -> const_iterator
	Returns an iterator to the element following the last element of the enumerable.
auto	aggregate (const std::function< type_t(const type_t &, const type_t &)> &funcfunc) const -> type_t
	Applies an accumulator function over a sequence.
auto	all (const std::function< bool(const type_t &)> &predicatepredicate) const -> bool
	Determines whether all elements of a sequence satisfy a condition.
auto	any () const noexcept -> bool
	Determines whether a sequence contains any elements.
auto	append (const type_t &element) const noexcept
	Appends a value to the end of the sequence.
auto	as_enumerable () const noexcept
	Returns the input typed as xtd::collections::generic::ienumerable <type_t>.
auto	average () const noexcept
	Computes the average of a sequence of source_t values.
auto	cast () const noexcept
	Casts the elements of an xtd::collections::generic::ienumerable to the specified type.
auto	chunk (xtd::usize size) const
	Splits the elements of a sequence into chunks of size at most size.
auto	concat (const ienumerable< type_t > &second) const noexcept
	Concatenates two sequences.
auto	contains (const type_t &value) const noexcept -> bool
	Determines whether a sequence contains a specified element by using the default equality comparer.
auto	count () const noexcept -> xtd::usize
	Returns the number of elements in current sequence.
auto	count_by (const std::function< key_t(const type_t &)> &key_selector) const noexcept
	Returns the count of elements in the current sequence grouped by key.
auto	default_if_empty () const noexcept
	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the current sequence is empty.
auto	distinct () const noexcept
	Returns distinct elements from a sequence by using the default equality comparer to compare values.
auto	first_or_default (const std::function< bool(const type_t &)> &predicatepredicate, const type_t &default_value) const noexcept -> type_t
	Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.
auto	order () const
	Sorts the elements of a sequence in ascending order.
auto	order_by (const std::function< type_t(const type_t &)> &key_selector) const
	Sorts the elements of a sequence in ascending order according to a key.
auto	order_by_descending (const std::function< key_t(const type_t &)> &key_selector) const
	Sorts the elements of a sequence in descending order according to a key.
auto	select (auto &&selector) const
	Projects each element of a sequence into a new form.
auto	to_array () const noexcept -> xtd::array< type_t >
	Creates a xtd::array <type_t> from an xtd::collections::generic::ienumerable <type_t>.
auto	to_list () const noexcept -> xtd::collections::generic::list< type_t >
	Creates a xtd::collections::generic::list <type_t> from an xtd::collections::generic::ienumerable <type_t>.
auto	where (auto &&predicatepredicate) const
	Filters a sequence of values based on a predicate.
virtual auto	empty () const noexcept -> bool
	Checks whether the container is empty.
virtual auto	size () const noexcept -> xtd::usize
	Gets the number of elements contained in the xtd::collections::generic::icollection <type_t>.
virtual auto	operator<< (const type_t &item) -> icollection< type_t > &
	The shift left operator adds an item to the xtd::collections::generic::icollection <type_t>.
virtual auto	operator>> (const type_t &item) -> icollection< type_t > &
	The shift right operator removes the first occurrence of a specific object from the xtd::collections::generic::icollection <type_t>.
template<typename object_a_t, typename object_b_t>
static auto	equals (const object_a_t &object_a, const object_b_t &object_b) noexcept -> bool
	Determines whether the specified object instances are considered equal.
template<typename object_a_t, typename object_b_t>
static auto	reference_equals (const object_a_t &object_a, const object_b_t &object_b) noexcept -> bool
	Determines whether the specified object instances are the same instance.
static auto	to_const_iterator (typename source_collection_t::const_iterator &value, const source_collection_t &source_collection, const target_collection_t &target_collection) noexcept -> typename target_collection_t::const_iterator
	Converts source iterator to target iterator.
static auto	to_iterator (typename source_collection_t::const_iterator &value, const source_collection_t &source_collection, const target_collection_t &target_collection) noexcept -> typename target_collection_t::const_iterator
	Converts source iterator to target iterator.

Member Typedef Documentation

value_type

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::value_type

Represents the list value type.

base_type

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::base_type

Represents the list base type.

size_type

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::size_type

Represents the list size type (usually xtd::usize).

difference_type

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::difference_type

Represents the list difference type (usually xtd::ptrdiff).

reference

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::reference

Represents the reference of list value type.

const_reference

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::const_reference

Represents the const reference of list value type.

pointer

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::pointer

Represents the pointer of list value type.

const_pointer

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::const_pointer

Represents the const pointer of list value type.

iterator

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::iterator

Represents the iterator of list value type.

const_iterator

template<typename type_t>

using xtd::collections::object_model::read_only_collection< type_t >::const_iterator

Represents the const iterator of list value type.

Constructor & Destructor Documentation

read_only_collection()

template<typename type_t>

xtd::collections::object_model::read_only_collection< type_t >::read_only_collection ( const xtd::collections::generic::ilist< value_type > & list )

inlineexplicit

Initializes a new instance of the xtd::collections::object_model::read_only_collection <type_t> class that is a read-only wrapper around the specified list.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

To prevent any modifications to list, expose list only through this wrapper.

A collection that is read-only is simply a collection with a wrapper that prevents modifying the collection; therefore, if changes are made to the underlying collection, the read-only collection reflects those changes.

This constructor is an O(1) operation.

Member Function Documentation

count()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::count ( ) const -> xtd::usize

inlinenodiscardoverridevirtualnoexcept

Gets the number of elements contained in the xtd::collections::object_model::read_only_collection <type_t> instance.

Returns

The number of elements contained in the xtd::collections::object_model::read_only_collection <type_t> instance.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

Retrieving the value of this property is an O(1) operation.

Implements xtd::collections::generic::ilist< type_t >.

empty_collection()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::empty_collection ( ) -> const read_only_collection< value_type > &

inlinestaticnodiscard

Gets an empty xtd::collections::object_model::read_only_collection <type_t>.

Returns

An empty xtd::collections::object_model::read_only_collection <type_t>.

Remarks

The returned instance is immutable and will always be empty.

sync_root()

template<typename type_t>

const xtd::object & xtd::collections::object_model::read_only_collection< type_t >::sync_root ( ) const

inlinenodiscardoverridevirtualnoexcept

Gets an object that can be used to synchronize access to the the xtd::collections::generic::icollection <type_t>.

Returns

An object that can be used to synchronize access to the the xtd::collections::generic::icollection <type_t>.

Remarks

For collections whose underlying store is not publicly available, the expected implementation is to return the current instance. Note that the pointer to the current instance might not be sufficient for collections that wrap other collections; those should return the underlying collection's sync_root property.

Most collection classes in the xts::.collections namespace also implement a synchronized method, which provides a synchronized wrapper around the underlying collection. However, derived classes can provide their own synchronized version of the collection using the xtd::collections::generic::icollection::sync_root property. The synchronizing code must perform operations on the xtd::collections::generic::icollection::sync_root property of the collection, not directly on the collection. This ensures proper operation of collections that are derived from other objects. Specifically, it maintains proper synchronization with other threads that might be simultaneously modifying the collection instance.

In the absence of a synchronized method on a collection, the expected usage for the xtd::collections::generic::icollection::sync_root looks as follows:

icollection& my_collection = some_collection;
lock_(my_collection.sync_root()) {
  // Some operation on the collection, which is now thread safe.
}
@encode
@remarks Enumerating through a collection is intrinsically not a thread-safe procedure. Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.
@remarks The following code example shows how to lock the collection using the xtd::collections::generic::icollection::sync_root property during the entire enumeration.
@code
icollection& my_collection = some_collection;
lock_(my_collection.sync_root()) {
  for (const auto& item : my_collection) {
    // Insert your code here.
  }
}

Implements xtd::collections::generic::ilist< type_t >.

contains()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::contains ( const type_t & item ) const -> bool

inlinenodiscardoverridevirtualnoexcept

Determines whether an element is in the xtd::collections::object_model::read_only_collection <type_t>.

Parameters

item	The object to locate in the xtd::collections::object_model::read_only_collection <type_t>. The value can be null for reference types.

Returns

true if value is found in the xtd::collections::object_model::read_only_collection <type_t>; otherwise, false.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

This method determines equality using the default equality comparer xtd::collections::generic::equality_comparer::default_comparer.

This method performs a linear search; therefore, this method is an O(n) operation, where n is xtd::collections::object_model::read_only_collection::count.

Implements xtd::collections::generic::ilist< type_t >.

copy_to()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::copy_to ( xtd::array< type_t > & array, xtd::usize array_index ) const -> void

inlineoverridevirtual

Copies the entire xtd::collections::object_model::read_only_collection <type_t> to a compatible one-dimensional Array, starting at the specified index of the target array.

Parameters

array	The one-dimensional xtd::array that is the destination of the elements copied from xtd::collections::object_model::read_only_collection <type_t>. The xtd::array must have zero-based indexing.
array_index	The zero-based index in array at which copying begins.

Exceptions

xtd::argument_exception

The number of elements in the source xtd::collections::object_model::read_only_collection <type_t> is greater than the available space from index to the end of the destination array.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

This method uses xtd::array::copy to copy the elements.

The elements are copied to the xtd::array in the same order that the enumerator iterates through the xtd::collections::object_model::read_only_collection <type_t>.

This method is an O(n) operation, where n is xtd::collections::object_model::read_only_collection::count.

Implements xtd::collections::generic::ilist< type_t >.

get_enumerator()

template<typename type_t>

generic::enumerator< value_type > xtd::collections::object_model::read_only_collection< type_t >::get_enumerator ( ) const

inlinenodiscardoverridevirtualnoexcept

Returns an enumerator that iterates through the xtd::collections::object_model::read_only_collection <type_t>.

Returns

An xtd::collections::generic::enumerator<T> for the xtd::collections::object_model::read_only_collection <type_t>.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

The for each statement of the C++ language hides the complexity of the enumerators. Therefore, using for each is recommended, instead of directly manipulating the enumerator.

Enumerators can be used to read the data in the collection, but they cannot be used to modify the underlying collection.

Initially, the enumerator is positioned before the first element in the collection. At this position, xtd::collections::generic::enumerator::current is undefined. Therefore, you must call xtd::collections::generic::enumerator::move_next to advance the enumerator to the first element of the collection before reading the value of xtd::collections::generic::enumerator::current.

xtd::collections::generic::enumerator::current returns the same object until xtd::collections::generic::enumerator::move_next is called. xtd::collections::generic::enumerator::move_next sets xtd::collections::generic::enumerator::current to the next element.

If xtd::collections::generic::enumerator::move_next passes the end of the collection, the enumerator is positioned after the last element in the collection and xtd::collections::generic::enumerator::move_next returns false. When the enumerator is at this position, subsequent calls to MoveNext also return false. If the last call to MoveNext returned false, Current is undefined. You cannot set xtd::collections::generic::enumerator::current to the first element of the collection again; you must create a new enumerator instance instead.

An enumerator remains valid as long as the collection remains unchanged. If changes are made to the collection, such as adding, modifying, or deleting elements, the enumerator is irrecoverably invalidated and its behavior is undefined.

The enumerator does not have exclusive access to the collection; therefore, enumerating through a collection is intrinsically not a thread-safe procedure. To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Default implementations of collections in xtd::collections::generic are not synchronized.

This method is an O(1) operation

Implements xtd::collections::generic::ilist< type_t >.

index_of()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::index_of ( const type_t & item ) const -> xtd::usize

inlinenodiscardoverridevirtualnoexcept

Searches for the specified object and returns the zero-based index of the first occurrence within the entire xtd::collections::object_model::read_only_collection <type_t>.

Parameters

item	The object to locate in the xtd::collections::object_model::read_only_collection <type_t>.

Returns

The zero-based index of the first occurrence of item within the entire xtd::collections::object_model::read_only_collection <type_t>, if found; otherwise, xtd::collections::object_model::read_only_collection::npos.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

The xtd::collections::object_model::read_only_collection <type_t> is searched forward starting at the first element and ending at the last element.

This method determines equality using the default comparer xtd::collections::generic::equality_comparer::default_comparer.

This method performs a linear search; therefore, this method is an O(n) operation, where n is xtd::collections::object_model::read_only_collection::count.

Implements xtd::collections::generic::ilist< type_t >.

to_string()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::to_string ( ) const -> xtd::string

inlinenodiscardoverridevirtualnoexcept

Returns a xtd::string that represents the current object.

Returns

A string that represents the current object.

Reimplemented from xtd::object.

operator[]() [1/2]

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::operator[] ( size_type index ) const -> const_reference

inlineoverridevirtual

Returns a reference to the element at specified location pos.

Parameters

index

The position of the element to return.

Returns

Reference to the requested element.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

Retrieving the value of this property is an O(1) operation.

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

Retrieving the value of this property is an O(1) operation.

Implements xtd::collections::generic::ilist< type_t >.

operator[]() [2/2]

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::operator[] ( size_type index ) -> reference

inlineoverridevirtual

Returns a reference to the element at specified location pos.

Parameters

index

The position of the element to return.

Returns

Reference to the requested element.

Exceptions

xtd::not_supported_exception

is always thrown.

Implements xtd::collections::generic::ilist< type_t >.

items()

template<typename type_t>

auto xtd::collections::object_model::read_only_collection< type_t >::items ( ) -> base_type

inlineprotectednoexcept

Returns the xtd::collections::generic::ilist <type_t> that the xtd::collections::object_model::read_only_collection <type_t> wraps.

Returns

The xtd::collections::generic::ilist <type_t> that the xtd::collections::object_model::read_only_collection <type_t> wraps.

Examples

The following code example demonstrates several members of the xtd::collections::object_model::read_only_collection <type_t> class. The code example creates a xtd::collections::generic::list <type_t> of strings and adds four dinosaur names to it. The code example then wraps the list in a xtd::collections::object_model::read_only_collection <type_t>.

After demonstrating the xtd::collections::object_model::read_only_collection::count, xtd::collections::object_model::read_only_collection::contains, xtd::collections::object_model::read_only_collection:: operator [], and xtd::collections::generic::ilist::index_of members, the code example shows that the xtd::collections::object_model::read_only_collection <type_t> is just a wrapper for the original xtd::collections::generic::list <type_t> by adding a new item to the xtd::collections::generic::list <type_t> and displaying the contents of the xtd::collections::object_model::read_only_collection <type_t>.

Finally, the code example creates an array larger than the collection and uses the xtd::collections::object_model::read_only_collection::copy_to method to insert the elements of the collection into the middle of the array.

#include <xtd/xtd>
 
class example {
public:
  static auto main() -> void {
    auto dinosaurs = list<string> {};
    
    dinosaurs.add("Tyrannosaurus");
    dinosaurs.add("Amargasaurus");
    dinosaurs.add("Deinonychus");
    dinosaurs.add("Compsognathus");
 
    auto read_only_dinosaurs = dinosaurs.as_read_only();
 
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
    
    console::write_line("\ncount: {0}", read_only_dinosaurs.count());
    
    console::write_line("\ncontains(\"Deinonychus\"): {0}", dinosaurs.contains("Deinonychus"));
    
    console::write_line("\nread_only_dinosaurs[3]: {0}", dinosaurs[3]);
    
    console::write_line("\nindex_of(\"Compsognathus\"): {0}", read_only_dinosaurs.index_of("Compsognathus"));
    
    console::write_line("\nInsert into the wrapped List:");
    console::write_line("insert(2, \"Oviraptor\")");
    dinosaurs.insert(2, "Oviraptor");
    
    console::write_line();
    for (auto dinosaur : read_only_dinosaurs)
      console::write_line(dinosaur);
 
    auto dino_array = array<string>(read_only_dinosaurs.count() + 2);
    read_only_dinosaurs.copy_to(dino_array, 1);
    
    console::write_line("\nCopied array has {0} elements:", dino_array.length());
    for (auto dinosaur : dino_array )
      console::write_line("\"{0}\"", dinosaur);
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
// Tyrannosaurus
// Amargasaurus
// Deinonychus
// Compsognathus
//
// count: 4
//
// contains("Deinonychus"): true
//
// read_only_dinosaurs[3]: Compsognathus
//
// index_of("Compsognathus"): 3
//
// Insert into the wrapped List:
// insert(2, "Oviraptor")
//
// Tyrannosaurus
// Amargasaurus
// Oviraptor
// Deinonychus
// Compsognathus
//
// Copied array has 7 elements:
// ""
// "Tyrannosaurus"
// "Amargasaurus"
// "Oviraptor"
// "Deinonychus"
// "Compsognathus"
// ""

Remarks

Retrieving the value of this property is an O(1) operation.

---

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

• xtd.core/include/xtd/collections/object_model/read_only_collection.hpp