二次元配列クラス More...

#include <Grid.hpp>

Public Types
using	container_type = Array< Type, Allocator >

using	value_type = typename container_type::value_type

using	pointer = typename container_type::pointer

using	const_pointer = typename container_type::const_pointer

using	reference = typename container_type::reference

using	const_reference = typename container_type::const_reference

using	iterator = typename container_type::iterator

using	const_iterator = typename container_type::const_iterator

using	reverse_iterator = typename container_type::reverse_iterator

using	const_reverse_iterator = typename container_type::const_reverse_iterator

using	size_type = typename container_type::size_type

using	difference_type = typename container_type::difference_type

using	allocator_type = typename container_type::allocator_type

Public Member Functions
SIV3D_NODISCARD_CXX20	Grid ()=default

SIV3D_NODISCARD_CXX20	Grid (const Grid &)=default

SIV3D_NODISCARD_CXX20	Grid (Grid &&)=default

SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h)

SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h, const value_type &value)

SIV3D_NODISCARD_CXX20	Grid (Size size)

SIV3D_NODISCARD_CXX20	Grid (Size size, const value_type &value)

SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h, const Array< value_type > &data)

SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h, Array< value_type > &&data)

SIV3D_NODISCARD_CXX20	Grid (Size size, const Array< value_type > &data)

SIV3D_NODISCARD_CXX20	Grid (Size size, Array< value_type > &&data)

SIV3D_NODISCARD_CXX20	Grid (const std::initializer_list< std::initializer_list< value_type >> &set)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>
SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h, Arg::generator_< Fty > generator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>
SIV3D_NODISCARD_CXX20	Grid (Size size, Arg::generator_< Fty > generator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>
SIV3D_NODISCARD_CXX20	Grid (size_type w, size_type h, Arg::indexedGenerator_< Fty > indexedGenerator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>
SIV3D_NODISCARD_CXX20	Grid (Size size, Arg::indexedGenerator_< Fty > indexedGenerator)

Grid &	operator= (const Grid &)=default

Grid &	operator= (Grid &&)=default
	ムーブ代入演算子 More...

void	swap (Grid &other) noexcept
	他の配列と要素を入れ替えます。 More...

allocator_type	get_allocator () const noexcept

void	assign (size_type w, size_type h, const value_type &value)

void	assign (Size size, const value_type &value)

void	assign (const std::initializer_list< std::initializer_list< value_type >> &set)

value_type &	at (size_type y, size_type x) &

const value_type &	at (size_type y, size_type x) const &

value_type	at (size_type y, size_type x) &&

value_type &	at (Point pos) &

const value_type &	at (Point pos) const &

value_type	at (Point pos) &&

value_type *	operator[] (size_t index)

const value_type *	operator[] (size_t index) const

value_type &	operator[] (Point pos) &

const value_type &	operator[] (Point pos) const &

value_type	operator[] (Point pos) &&

bool	inBounds (int64 y, int64 x) const noexcept

bool	inBounds (Point pos) const noexcept

pointer	data () noexcept

const_pointer	data () const noexcept

bool	empty () const noexcept
	配列が空であるかを返します。 More...

bool	isEmpty () const noexcept
	配列が空であるかを返します。 More...

	operator bool () const noexcept
	配列が要素を持っているかを返します。 More...

size_type	width () const noexcept

size_type	height () const noexcept

Size	size () const noexcept

size_type	num_elements () const noexcept

size_t	size_bytes () const noexcept
	配列の要素の合計サイズ（バイト）を返します。 More...

const container_type &	asArray () const noexcept

void	reserve (size_type w, size_type h)

void	reserve (Size size)

size_type	capacity () const noexcept

void	shrink_to_fit ()

void	clear () noexcept

void	release ()
	配列の要素を全て消去し、メモリも解放します。 More...

iterator	begin () noexcept

iterator	end () noexcept

const_iterator	begin () const noexcept

const_iterator	end () const noexcept

const_iterator	cbegin () const noexcept

const_iterator	cend () const noexcept

reverse_iterator	rbegin () noexcept

reverse_iterator	rend () noexcept

const_reverse_iterator	rbegin () const noexcept

const_reverse_iterator	rend () const noexcept

const_reverse_iterator	crbegin () const noexcept

const_reverse_iterator	crend () const noexcept

void	push_back_row (const value_type &value)

void	pop_back_row ()

void	pop_back_row_N (size_t n)

void	push_back_column (const value_type &value)

void	pop_back_column ()

void	pop_back_column_N (size_t n)

void	insert_row (size_type pos, const value_type &value)

void	insert_rows (size_type pos, size_type rows, const value_type &value)

void	insert_column (size_type pos, const value_type &value)

void	insert_columns (size_type pos, size_type columns, const value_type &value)

void	remove_row (size_type pos)

void	remove_rows (size_type pos, size_type count)

void	remove_column (size_type pos)

void	remove_columns (size_type pos, size_type count)

void	resize (size_type w, size_type h)

void	resize (Size size)

void	resize (size_type w, size_type h, const value_type &value)

void	resize (Size size, const value_type &value)

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>
auto	operator>> (Fty f) const

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
bool	all (Fty f=Identity) const

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
bool	any (Fty f=Identity) const

value_type &	choice ()

const value_type &	choice () const

SIV3D_CONCEPT_URBG value_type &	choice (URBG &&rbg)

const SIV3D_CONCEPT_URBG value_type &	choice (URBG &&rbg) const

SIV3D_CONCEPT_INTEGRAL Array< Type >	choice (Int n) const

template<class Size_t , class URBG , std::enable_if_t< std::is_integral_v< Size_t >> * = nullptr, std::enable_if_t< std::conjunction_v< std::is_invocable< URBG & >, std::is_unsigned< std::invoke_result_t< URBG & >>>> * = nullptr>
Array< Type >	choice (Size_t n, URBG &&rbg) const

size_t	count (const value_type &value) const

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
size_t	count_if (Fty f) const

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type & >> * = nullptr>
Grid &	each (Fty f)

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>
const Grid &	each (Fty f) const

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Point, Type & >> * = nullptr>
Grid &	each_index (Fty f)

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Point, Type >> * = nullptr>
const Grid &	each_index (Fty f) const

const value_type &	fetch (size_type y, size_type x, const value_type &defaultValue) const

const value_type &	fetch (Point pos, const value_type &defaultValue) const

Grid &	fill (const value_type &value)

bool	includes (const value_type &value) const

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
bool	includes_if (Fty f) const

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>
auto	map (Fty f) const

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
bool	none (Fty f=Identity) const

template<class Fty , class R = std::decay_t<std::invoke_result_t<Fty, Type, Type>>>
auto	reduce (Fty f, R init) const

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type, Type >> * = nullptr>
auto	reduce1 (Fty f) const

Grid &	replace (const value_type &oldValue, const value_type &newValue)

Grid	replaced (const value_type &oldValue, const value_type &newValue) const &

Grid	replaced (const value_type &oldValue, const value_type &newValue) &&

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
Grid &	replace_if (Fty f, const value_type &newValue)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
Grid	replaced_if (Fty f, const value_type &newValue) const &

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>
Grid	replaced_if (Fty f, const value_type &newValue) &&

Grid &	reverse ()

Grid &	reverse_columns ()

Grid &	reverse_rows ()

Grid	reversed () const &

Grid	reversed () &&

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type & >> * = nullptr>
Grid &	reverse_each (Fty f)

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>
const Grid &	reverse_each (Fty f) const

Grid &	rotate (std::ptrdiff_t count=1)

Grid	rotated (std::ptrdiff_t count=1) const &

Grid	rotated (std::ptrdiff_t count=1) &&

Grid &	rotate_rows (std::ptrdiff_t count=1)

Grid	rotated_rows (std::ptrdiff_t count=1) const &

Grid	rotated_rows (std::ptrdiff_t count=1) &&

Grid &	shuffle ()

SIV3D_CONCEPT_URBG Grid &	shuffle (URBG &&rbg)

Grid	shuffled () const &

Grid	shuffled () &&

SIV3D_CONCEPT_URBG Grid	shuffled (URBG &&rbg) const &

SIV3D_CONCEPT_URBG Grid	shuffled (URBG &&rbg) &&

Array< Type >	slice (size_type y, size_type x) const

Array< Type >	slice (Point pos) const

Array< Type >	slice (size_type y, size_type x, size_t length) const

Array< Type >	slice (Point pos, size_t length) const

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid &	sort ()

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid &	stable_sort ()

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid &	sort_by (Fty f)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid &	stable_sort_by (Fty f)

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid	sorted () const &

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid	stable_sorted () const &

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid	sorted () &&

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>
Grid	stable_sorted () &&

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid	sorted_by (Fty f) const &

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid	stable_sorted_by (Fty f) const &

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid	sorted_by (Fty f) &&

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>
Grid	stable_sorted_by (Fty f) &&

template<class T = Type, std::enable_if_t< Meta::HasPlus_v< T >> * = nullptr>
auto	sum () const

template<class T = Type, std::enable_if_t< not Meta::HasPlus_v< T >> * = nullptr>
void	sum () const =delete

template<class T = Type, std::enable_if_t< std::is_floating_point_v< T >> * = nullptr>
auto	sumF () const

template<class T = Type, std::enable_if_t< not std::is_floating_point_v< T >> * = nullptr>
auto	sumF () const =delete

Grid &	swap_columns (size_t a, size_t b)

Grid &	swap_rows (size_t a, size_t b)

Array< Type >	values_at (std::initializer_list< Point > indices) const

Static Public Member Functions
template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>
static Grid	Generate (size_type w, size_type h, Fty generator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>
static Grid	Generate (Size size, Fty generator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>
static Grid	IndexedGenerate (size_type w, size_type h, Fty indexedGenerator)

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>
static Grid	IndexedGenerate (Size size, Fty indexedGenerator)

Friends
bool	operator== (const Grid &lhs, const Grid &rhs)

bool	operator!= (const Grid &lhs, const Grid &rhs)

std::ostream &	operator<< (std::ostream &output, const Grid &value)

std::wostream &	operator<< (std::wostream &output, const Grid &value)

std::basic_ostream< char32 > &	operator<< (std::basic_ostream< char32 > &output, const Grid &value)

void	Formatter (FormatData &formatData, const Grid &value)

Detailed Description

template<class Type, class Allocator = std::allocator<Type>>
class s3d::Grid< Type, Allocator >

二次元配列クラス

Template Parameters

Type	要素の型
Allocator	アロケータの型

Member Typedef Documentation

◆ allocator_type

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::allocator_type = typename container_type::allocator_type

◆ const_iterator

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::const_iterator = typename container_type::const_iterator

◆ const_pointer

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::const_pointer = typename container_type::const_pointer

◆ const_reference

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::const_reference = typename container_type::const_reference

◆ const_reverse_iterator

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::const_reverse_iterator = typename container_type::const_reverse_iterator

◆ container_type

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::container_type = Array<Type, Allocator>

◆ difference_type

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::difference_type = typename container_type::difference_type

◆ iterator

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::iterator = typename container_type::iterator

◆ pointer

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::pointer = typename container_type::pointer

◆ reference

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::reference = typename container_type::reference

◆ reverse_iterator

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::reverse_iterator = typename container_type::reverse_iterator

◆ size_type

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::size_type = typename container_type::size_type

◆ value_type

template<class Type , class Allocator = std::allocator<Type>>

using s3d::Grid< Type, Allocator >::value_type = typename container_type::value_type

Constructor & Destructor Documentation

◆ Grid() [1/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid ( )

default

◆ Grid() [2/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid ( const Grid< Type, Allocator > & )

default

◆ Grid() [3/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid ( Grid< Type, Allocator > && )

default

◆ Grid() [4/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h
	)

◆ Grid() [5/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h,
		const value_type &	value
	)

◆ Grid() [6/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid ( Size size )

explicit

◆ Grid() [7/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	Size	size,
		const value_type &	value
	)

◆ Grid() [8/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h,
		const Array< value_type > &	data
	)

◆ Grid() [9/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h,
		Array< value_type > &&	data
	)

◆ Grid() [10/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	Size	size,
		const Array< value_type > &	data
	)

◆ Grid() [11/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	Size	size,
		Array< value_type > &&	data
	)

◆ Grid() [12/16]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid ( const std::initializer_list< std::initializer_list< value_type >> & set )

◆ Grid() [13/16]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h,
		Arg::generator_< Fty >	generator
	)

◆ Grid() [14/16]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	Size	size,
		Arg::generator_< Fty >	generator
	)

◆ Grid() [15/16]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	size_type	w,
		size_type	h,
		Arg::indexedGenerator_< Fty >	indexedGenerator
	)

◆ Grid() [16/16]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>

SIV3D_NODISCARD_CXX20 s3d::Grid< Type, Allocator >::Grid	(	Size	size,
		Arg::indexedGenerator_< Fty >	indexedGenerator
	)

Member Function Documentation

◆ all()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

bool s3d::Grid< Type, Allocator >::all ( Fty f = Identity ) const

◆ any()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

bool s3d::Grid< Type, Allocator >::any ( Fty f = Identity ) const

◆ asArray()

template<class Type , class Allocator = std::allocator<Type>>

const container_type& s3d::Grid< Type, Allocator >::asArray ( ) const

noexcept

◆ assign() [1/3]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::assign ( const std::initializer_list< std::initializer_list< value_type >> & set )

◆ assign() [2/3]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::assign	(	Size	size,
		const value_type &	value
	)

◆ assign() [3/3]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::assign	(	size_type	w,
		size_type	h,
		const value_type &	value
	)

◆ at() [1/6]

template<class Type , class Allocator = std::allocator<Type>>

value_type& s3d::Grid< Type, Allocator >::at ( Point pos ) &

◆ at() [2/6]

template<class Type , class Allocator = std::allocator<Type>>

value_type s3d::Grid< Type, Allocator >::at ( Point pos ) &&

◆ at() [3/6]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::at ( Point pos ) const &

◆ at() [4/6]

template<class Type , class Allocator = std::allocator<Type>>

value_type& s3d::Grid< Type, Allocator >::at	(	size_type	y,
		size_type	x
	)		&

◆ at() [5/6]

template<class Type , class Allocator = std::allocator<Type>>

value_type s3d::Grid< Type, Allocator >::at	(	size_type	y,
		size_type	x
	)		&&

◆ at() [6/6]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::at	(	size_type	y,
		size_type	x
	)		const &

◆ begin() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const_iterator s3d::Grid< Type, Allocator >::begin ( ) const

noexcept

◆ begin() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

iterator s3d::Grid< Type, Allocator >::begin ( )

noexcept

◆ capacity()

template<class Type , class Allocator = std::allocator<Type>>

size_type s3d::Grid< Type, Allocator >::capacity ( ) const

noexcept

◆ cbegin()

template<class Type , class Allocator = std::allocator<Type>>

const_iterator s3d::Grid< Type, Allocator >::cbegin ( ) const

noexcept

◆ cend()

template<class Type , class Allocator = std::allocator<Type>>

const_iterator s3d::Grid< Type, Allocator >::cend ( ) const

noexcept

◆ choice() [1/6]

template<class Type , class Allocator = std::allocator<Type>>

value_type& s3d::Grid< Type, Allocator >::choice ( )

◆ choice() [2/6]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::choice ( ) const

◆ choice() [3/6]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_CONCEPT_INTEGRAL Array<Type> s3d::Grid< Type, Allocator >::choice ( Int n ) const

◆ choice() [4/6]

template<class Type , class Allocator = std::allocator<Type>>

template<class Size_t , class URBG , std::enable_if_t< std::is_integral_v< Size_t >> * = nullptr, std::enable_if_t< std::conjunction_v< std::is_invocable< URBG & >, std::is_unsigned< std::invoke_result_t< URBG & >>>> * = nullptr>

Array<Type> s3d::Grid< Type, Allocator >::choice	(	Size_t	n,
		URBG &&	rbg
	)		const

◆ choice() [5/6]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_CONCEPT_URBG value_type& s3d::Grid< Type, Allocator >::choice ( URBG && rbg )

◆ choice() [6/6]

template<class Type , class Allocator = std::allocator<Type>>

const SIV3D_CONCEPT_URBG value_type& s3d::Grid< Type, Allocator >::choice ( URBG && rbg ) const

◆ clear()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::clear ( )

noexcept

◆ count()

template<class Type , class Allocator = std::allocator<Type>>

size_t s3d::Grid< Type, Allocator >::count ( const value_type & value ) const

◆ count_if()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

size_t s3d::Grid< Type, Allocator >::count_if ( Fty f ) const

◆ crbegin()

template<class Type , class Allocator = std::allocator<Type>>

const_reverse_iterator s3d::Grid< Type, Allocator >::crbegin ( ) const

noexcept

◆ crend()

template<class Type , class Allocator = std::allocator<Type>>

const_reverse_iterator s3d::Grid< Type, Allocator >::crend ( ) const

noexcept

◆ data() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const_pointer s3d::Grid< Type, Allocator >::data ( ) const

noexcept

◆ data() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

pointer s3d::Grid< Type, Allocator >::data ( )

noexcept

◆ each() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type & >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::each ( Fty f )

◆ each() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>

const Grid& s3d::Grid< Type, Allocator >::each ( Fty f ) const

◆ each_index() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Point, Type & >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::each_index ( Fty f )

◆ each_index() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Point, Type >> * = nullptr>

const Grid& s3d::Grid< Type, Allocator >::each_index ( Fty f ) const

◆ empty()

template<class Type , class Allocator = std::allocator<Type>>

bool s3d::Grid< Type, Allocator >::empty ( ) const

noexcept

配列が空であるかを返します。

Returns: 配列が空である場合 true, それ以外の場合は false

◆ end() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const_iterator s3d::Grid< Type, Allocator >::end ( ) const

noexcept

◆ end() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

iterator s3d::Grid< Type, Allocator >::end ( )

noexcept

◆ fetch() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::fetch	(	Point	pos,
		const value_type &	defaultValue
	)		const

◆ fetch() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::fetch	(	size_type	y,
		size_type	x,
		const value_type &	defaultValue
	)		const

◆ fill()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::fill ( const value_type & value )

◆ Generate() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>

static Grid s3d::Grid< Type, Allocator >::Generate	(	Size	size,
		Fty	generator
	)

static

◆ Generate() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty >> * = nullptr>

static Grid s3d::Grid< Type, Allocator >::Generate	(	size_type	w,
		size_type	h,
		Fty	generator
	)

static

◆ get_allocator()

template<class Type , class Allocator = std::allocator<Type>>

allocator_type s3d::Grid< Type, Allocator >::get_allocator ( ) const

noexcept

◆ height()

template<class Type , class Allocator = std::allocator<Type>>

size_type s3d::Grid< Type, Allocator >::height ( ) const

noexcept

◆ inBounds() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

bool s3d::Grid< Type, Allocator >::inBounds	(	int64	y,
		int64	x
	)		const

noexcept

◆ inBounds() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

bool s3d::Grid< Type, Allocator >::inBounds ( Point pos ) const

noexcept

◆ includes()

template<class Type , class Allocator = std::allocator<Type>>

bool s3d::Grid< Type, Allocator >::includes ( const value_type & value ) const

◆ includes_if()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

bool s3d::Grid< Type, Allocator >::includes_if ( Fty f ) const

◆ IndexedGenerate() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>

static Grid s3d::Grid< Type, Allocator >::IndexedGenerate	(	Size	size,
		Fty	indexedGenerator
	)

static

◆ IndexedGenerate() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< Type, Fty, Point >> * = nullptr>

static Grid s3d::Grid< Type, Allocator >::IndexedGenerate	(	size_type	w,
		size_type	h,
		Fty	indexedGenerator
	)

static

◆ insert_column()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::insert_column	(	size_type	pos,
		const value_type &	value
	)

◆ insert_columns()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::insert_columns	(	size_type	pos,
		size_type	columns,
		const value_type &	value
	)

◆ insert_row()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::insert_row	(	size_type	pos,
		const value_type &	value
	)

◆ insert_rows()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::insert_rows	(	size_type	pos,
		size_type	rows,
		const value_type &	value
	)

◆ isEmpty()

template<class Type , class Allocator = std::allocator<Type>>

bool s3d::Grid< Type, Allocator >::isEmpty ( ) const

noexcept

配列が空であるかを返します。

Returns: 配列が空である場合 true, それ以外の場合は false

◆ map()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>

auto s3d::Grid< Type, Allocator >::map ( Fty f ) const

◆ none()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty = decltype(Identity), std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

bool s3d::Grid< Type, Allocator >::none ( Fty f = Identity ) const

◆ num_elements()

template<class Type , class Allocator = std::allocator<Type>>

size_type s3d::Grid< Type, Allocator >::num_elements ( ) const

noexcept

◆ operator bool()

template<class Type , class Allocator = std::allocator<Type>>

s3d::Grid< Type, Allocator >::operator bool ( ) const

explicitnoexcept

配列が要素を持っているかを返します。

Returns: 配列が要素を持っている場合 true, それ以外の場合は false

◆ operator=() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::operator= ( const Grid< Type, Allocator > & )

default

◆ operator=() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::operator= ( Grid< Type, Allocator > && )

default

ムーブ代入演算子

Parameters

other ムーブする配列

Returns: *this

◆ operator>>()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>

auto s3d::Grid< Type, Allocator >::operator>> ( Fty f ) const

◆ operator[]() [1/5]

template<class Type , class Allocator = std::allocator<Type>>

value_type& s3d::Grid< Type, Allocator >::operator[] ( Point pos ) &

◆ operator[]() [2/5]

template<class Type , class Allocator = std::allocator<Type>>

value_type s3d::Grid< Type, Allocator >::operator[] ( Point pos ) &&

◆ operator[]() [3/5]

template<class Type , class Allocator = std::allocator<Type>>

const value_type& s3d::Grid< Type, Allocator >::operator[] ( Point pos ) const &

◆ operator[]() [4/5]

template<class Type , class Allocator = std::allocator<Type>>

value_type* s3d::Grid< Type, Allocator >::operator[] ( size_t index )

◆ operator[]() [5/5]

template<class Type , class Allocator = std::allocator<Type>>

const value_type* s3d::Grid< Type, Allocator >::operator[] ( size_t index ) const

◆ pop_back_column()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::pop_back_column ( )

◆ pop_back_column_N()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::pop_back_column_N ( size_t n )

◆ pop_back_row()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::pop_back_row ( )

◆ pop_back_row_N()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::pop_back_row_N ( size_t n )

◆ push_back_column()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::push_back_column ( const value_type & value )

◆ push_back_row()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::push_back_row ( const value_type & value )

◆ rbegin() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const_reverse_iterator s3d::Grid< Type, Allocator >::rbegin ( ) const

noexcept

◆ rbegin() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

reverse_iterator s3d::Grid< Type, Allocator >::rbegin ( )

noexcept

◆ reduce()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , class R = std::decay_t<std::invoke_result_t<Fty, Type, Type>>>

auto s3d::Grid< Type, Allocator >::reduce	(	Fty	f,
		R	init
	)		const

◆ reduce1()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type, Type >> * = nullptr>

auto s3d::Grid< Type, Allocator >::reduce1 ( Fty f ) const

◆ release()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::release ( )

配列の要素を全て消去し、メモリも解放します。

◆ remove_column()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::remove_column ( size_type pos )

◆ remove_columns()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::remove_columns	(	size_type	pos,
		size_type	count
	)

◆ remove_row()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::remove_row ( size_type pos )

◆ remove_rows()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::remove_rows	(	size_type	pos,
		size_type	count
	)

◆ rend() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

const_reverse_iterator s3d::Grid< Type, Allocator >::rend ( ) const

noexcept

◆ rend() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

reverse_iterator s3d::Grid< Type, Allocator >::rend ( )

noexcept

◆ replace()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::replace	(	const value_type &	oldValue,
		const value_type &	newValue
	)

◆ replace_if()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::replace_if	(	Fty	f,
		const value_type &	newValue
	)

◆ replaced() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::replaced	(	const value_type &	oldValue,
		const value_type &	newValue
	)		&&

◆ replaced() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::replaced	(	const value_type &	oldValue,
		const value_type &	newValue
	)		const &

◆ replaced_if() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::replaced_if	(	Fty	f,
		const value_type &	newValue
	)		&&

◆ replaced_if() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::replaced_if	(	Fty	f,
		const value_type &	newValue
	)		const &

◆ reserve() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::reserve ( Size size )

◆ reserve() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::reserve	(	size_type	w,
		size_type	h
	)

◆ resize() [1/4]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::resize ( Size size )

◆ resize() [2/4]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::resize	(	Size	size,
		const value_type &	value
	)

◆ resize() [3/4]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::resize	(	size_type	w,
		size_type	h
	)

◆ resize() [4/4]

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::resize	(	size_type	w,
		size_type	h,
		const value_type &	value
	)

◆ reverse()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::reverse ( )

◆ reverse_columns()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::reverse_columns ( )

◆ reverse_each() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type & >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::reverse_each ( Fty f )

◆ reverse_each() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_v< Fty, Type >> * = nullptr>

const Grid& s3d::Grid< Type, Allocator >::reverse_each ( Fty f ) const

◆ reverse_rows()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::reverse_rows ( )

◆ reversed() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::reversed ( ) &&

◆ reversed() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::reversed ( ) const &

◆ rotate()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::rotate ( std::ptrdiff_t count = 1 )

◆ rotate_rows()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::rotate_rows ( std::ptrdiff_t count = 1 )

◆ rotated() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::rotated ( std::ptrdiff_t count = 1 ) &&

◆ rotated() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::rotated ( std::ptrdiff_t count = 1 ) const &

◆ rotated_rows() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::rotated_rows ( std::ptrdiff_t count = 1 ) &&

◆ rotated_rows() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::rotated_rows ( std::ptrdiff_t count = 1 ) const &

◆ shrink_to_fit()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::shrink_to_fit ( )

◆ shuffle() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::shuffle ( )

◆ shuffle() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_CONCEPT_URBG Grid& s3d::Grid< Type, Allocator >::shuffle ( URBG && rbg )

◆ shuffled() [1/4]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::shuffled ( ) &&

◆ shuffled() [2/4]

template<class Type , class Allocator = std::allocator<Type>>

Grid s3d::Grid< Type, Allocator >::shuffled ( ) const &

◆ shuffled() [3/4]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_CONCEPT_URBG Grid s3d::Grid< Type, Allocator >::shuffled ( URBG && rbg ) &&

◆ shuffled() [4/4]

template<class Type , class Allocator = std::allocator<Type>>

SIV3D_CONCEPT_URBG Grid s3d::Grid< Type, Allocator >::shuffled ( URBG && rbg ) const &

◆ size()

template<class Type , class Allocator = std::allocator<Type>>

Size s3d::Grid< Type, Allocator >::size ( ) const

noexcept

◆ size_bytes()

template<class Type , class Allocator = std::allocator<Type>>

size_t s3d::Grid< Type, Allocator >::size_bytes ( ) const

noexcept

配列の要素の合計サイズ（バイト）を返します。

Returns: 配列の要素の合計サイズ（バイト）

◆ slice() [1/4]

template<class Type , class Allocator = std::allocator<Type>>

Array<Type> s3d::Grid< Type, Allocator >::slice ( Point pos ) const

◆ slice() [2/4]

template<class Type , class Allocator = std::allocator<Type>>

Array<Type> s3d::Grid< Type, Allocator >::slice	(	Point	pos,
		size_t	length
	)		const

◆ slice() [3/4]

template<class Type , class Allocator = std::allocator<Type>>

Array<Type> s3d::Grid< Type, Allocator >::slice	(	size_type	y,
		size_type	x
	)		const

◆ slice() [4/4]

template<class Type , class Allocator = std::allocator<Type>>

Array<Type> s3d::Grid< Type, Allocator >::slice	(	size_type	y,
		size_type	x,
		size_t	length
	)		const

◆ sort()

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::sort ( )

◆ sort_by()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::sort_by ( Fty f )

◆ sorted() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::sorted ( ) &&

◆ sorted() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::sorted ( ) const &

◆ sorted_by() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::sorted_by ( Fty f ) &&

◆ sorted_by() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::sorted_by ( Fty f ) const &

◆ stable_sort()

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::stable_sort ( )

◆ stable_sort_by()

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid& s3d::Grid< Type, Allocator >::stable_sort_by ( Fty f )

◆ stable_sorted() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::stable_sorted ( ) &&

◆ stable_sorted() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasLessThan_v< T >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::stable_sorted ( ) const &

◆ stable_sorted_by() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::stable_sorted_by ( Fty f ) &&

◆ stable_sorted_by() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class Fty , std::enable_if_t< std::is_invocable_r_v< bool, Fty, Type, Type >> * = nullptr>

Grid s3d::Grid< Type, Allocator >::stable_sorted_by ( Fty f ) const &

◆ sum() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< Meta::HasPlus_v< T >> * = nullptr>

auto s3d::Grid< Type, Allocator >::sum ( ) const

◆ sum() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< not Meta::HasPlus_v< T >> * = nullptr>

void s3d::Grid< Type, Allocator >::sum ( ) const

delete

◆ sumF() [1/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< std::is_floating_point_v< T >> * = nullptr>

auto s3d::Grid< Type, Allocator >::sumF ( ) const

◆ sumF() [2/2]

template<class Type , class Allocator = std::allocator<Type>>

template<class T = Type, std::enable_if_t< not std::is_floating_point_v< T >> * = nullptr>

auto s3d::Grid< Type, Allocator >::sumF ( ) const

delete

◆ swap()

template<class Type , class Allocator = std::allocator<Type>>

void s3d::Grid< Type, Allocator >::swap ( Grid< Type, Allocator > & other )

noexcept

他の配列と要素を入れ替えます。

Parameters

other 入れ替える配列

◆ swap_columns()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::swap_columns	(	size_t	a,
		size_t	b
	)

◆ swap_rows()

template<class Type , class Allocator = std::allocator<Type>>

Grid& s3d::Grid< Type, Allocator >::swap_rows	(	size_t	a,
		size_t	b
	)

◆ values_at()

template<class Type , class Allocator = std::allocator<Type>>

Array<Type> s3d::Grid< Type, Allocator >::values_at ( std::initializer_list< Point > indices ) const

◆ width()

template<class Type , class Allocator = std::allocator<Type>>

size_type s3d::Grid< Type, Allocator >::width ( ) const

noexcept

Friends And Related Function Documentation

◆ Formatter

template<class Type , class Allocator = std::allocator<Type>>

void Formatter	(	FormatData &	formatData,
		const Grid< Type, Allocator > &	value
	)

friend

◆ operator!=

template<class Type , class Allocator = std::allocator<Type>>

bool operator!=	(	const Grid< Type, Allocator > &	lhs,
		const Grid< Type, Allocator > &	rhs
	)

friend

◆ operator<< [1/3]

template<class Type , class Allocator = std::allocator<Type>>

std::basic_ostream<char32>& operator<<	(	std::basic_ostream< char32 > &	output,
		const Grid< Type, Allocator > &	value
	)

friend

◆ operator<< [2/3]

template<class Type , class Allocator = std::allocator<Type>>

std::ostream& operator<<	(	std::ostream &	output,
		const Grid< Type, Allocator > &	value
	)

friend

◆ operator<< [3/3]

template<class Type , class Allocator = std::allocator<Type>>

std::wostream& operator<<	(	std::wostream &	output,
		const Grid< Type, Allocator > &	value
	)

friend

◆ operator==

template<class Type , class Allocator = std::allocator<Type>>

bool operator==	(	const Grid< Type, Allocator > &	lhs,
		const Grid< Type, Allocator > &	rhs
	)

friend

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

OpenSiv3D/Siv3D/include/Siv3D/Grid.hpp

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

template<class Type, class Allocator = std::allocator<Type>> class s3d::Grid< Type, Allocator >

Member Typedef Documentation

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ container_type

◆ difference_type

◆ iterator

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ Grid() [1/16]

◆ Grid() [2/16]

◆ Grid() [3/16]

◆ Grid() [4/16]

◆ Grid() [5/16]

◆ Grid() [6/16]

◆ Grid() [7/16]

◆ Grid() [8/16]

◆ Grid() [9/16]

◆ Grid() [10/16]

◆ Grid() [11/16]

◆ Grid() [12/16]

◆ Grid() [13/16]

◆ Grid() [14/16]

◆ Grid() [15/16]

◆ Grid() [16/16]

Member Function Documentation

◆ all()

◆ any()

◆ asArray()

◆ assign() [1/3]

◆ assign() [2/3]

◆ assign() [3/3]

◆ at() [1/6]

◆ at() [2/6]

◆ at() [3/6]

◆ at() [4/6]

◆ at() [5/6]

◆ at() [6/6]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ choice() [1/6]

◆ choice() [2/6]

◆ choice() [3/6]

◆ choice() [4/6]

◆ choice() [5/6]

◆ choice() [6/6]

◆ clear()

◆ count()

◆ count_if()

◆ crbegin()

◆ crend()

◆ data() [1/2]

◆ data() [2/2]

◆ each() [1/2]

◆ each() [2/2]

◆ each_index() [1/2]

◆ each_index() [2/2]

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ fetch() [1/2]

◆ fetch() [2/2]

◆ fill()

◆ Generate() [1/2]

◆ Generate() [2/2]

template<class Type, class Allocator = std::allocator<Type>>
class s3d::Grid< Type, Allocator >