xml_writer_binary_local

type, public, extends(xml_writer_abstract) :: xml_writer_binary_local

Inherits

Help

Components

Type	Visibility		Name		Initial
type(string),	public	::	format_ch
type(string),	public	::	topology
integer(kind=I4P),	public	::	indent	=	0_I4P
integer(kind=I8P),	public	::	ioffset	=	0_I8P
integer(kind=I4P),	public	::	xml	=	0_I4P
integer(kind=I4P),	public	::	vtm_block(1:2)	=	[-1_I4P, -1_I4P]
integer(kind=I4P),	public	::	error	=	0_I4P
type(xml_tag),	public	::	tag
logical,	public	::	is_volatile	=	.false.
type(string),	public	::	xml_volatile

Type-Bound Procedures

procedure, public, pass(self) :: close_xml_file

private subroutine close_xml_file(self)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self

procedure, public, pass(self) :: open_xml_file

private subroutine open_xml_file(self, filename)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
character(len=*),	intent(in)			::	filename

procedure, public, pass(self) :: free

private elemental subroutine free(self, error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
integer(kind=I4P),	intent(out),	optional		::	error

procedure, public, pass(self) :: get_xml_volatile

private pure subroutine get_xml_volatile(self, xml_volatile, error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(in)			::	self
character(len=:),	intent(out),		allocatable	::	xml_volatile
integer(kind=I4P),	intent(out),	optional		::	error

procedure, public, pass(self) :: write_connectivity

private function write_connectivity(self, nc, connectivity, offset, cell_type, face, faceoffset) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
integer(kind=I4P),	intent(in)		::	nc
integer(kind=I4P),	intent(in)		::	connectivity(1:)
integer(kind=I4P),	intent(in)		::	offset(1:)
integer(kind=I1P),	intent(in)		::	cell_type(1:)
integer(kind=I4P),	intent(in),	optional	::	face(1:)
integer(kind=I4P),	intent(in),	optional	::	faceoffset(1:)

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray_location_tag

private function write_dataarray_location_tag(self, location, action) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
character(len=*),	intent(in)	::	location
character(len=*),	intent(in)	::	action

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray_tag

private subroutine write_dataarray_tag(self, data_type, number_of_components, data_name, data_content, is_tuples)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_type
integer(kind=I4P),	intent(in)		::	number_of_components
character(len=*),	intent(in)		::	data_name
character(len=*),	intent(in),	optional	::	data_content
logical,	intent(in),	optional	::	is_tuples

procedure, public, pass(self) :: write_dataarray_tag_appended

private subroutine write_dataarray_tag_appended(self, data_type, number_of_components, data_name, is_tuples)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_type
integer(kind=I4P),	intent(in)		::	number_of_components
character(len=*),	intent(in)		::	data_name
logical,	intent(in),	optional	::	is_tuples

procedure, public, pass(self) :: write_end_tag

private subroutine write_end_tag(self, name)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
character(len=*),	intent(in)			::	name

procedure, public, pass(self) :: write_header_tag

private subroutine write_header_tag(self)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self

procedure, public, pass(self) :: write_parallel_open_block

private function write_parallel_open_block(self, name) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
character(len=*),	intent(in),	optional		::	name

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_close_block

private function write_parallel_close_block(self) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_dataarray

private function write_parallel_dataarray(self, data_name, data_type, number_of_components) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
character(len=*),	intent(in)		::	data_type
integer(kind=I4P),	intent(in),	optional	::	number_of_components

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_geo

private function write_parallel_geo(self, source, nx1, nx2, ny1, ny2, nz1, nz2) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	source
integer(kind=I4P),	intent(in),	optional	::	nx1
integer(kind=I4P),	intent(in),	optional	::	nx2
integer(kind=I4P),	intent(in),	optional	::	ny1
integer(kind=I4P),	intent(in),	optional	::	ny2
integer(kind=I4P),	intent(in),	optional	::	nz1
integer(kind=I4P),	intent(in),	optional	::	nz2

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_self_closing_tag

private subroutine write_self_closing_tag(self, name, attributes)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	name
character(len=*),	intent(in),	optional	::	attributes

procedure, public, pass(self) :: write_start_tag

private subroutine write_start_tag(self, name, attributes)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	name
character(len=*),	intent(in),	optional	::	attributes

procedure, public, pass(self) :: write_tag

private subroutine write_tag(self, name, attributes, content)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	name
character(len=*),	intent(in),	optional	::	attributes
character(len=*),	intent(in),	optional	::	content

procedure, public, pass(self) :: write_topology_tag

private subroutine write_topology_tag(self, nx1, nx2, ny1, ny2, nz1, nz2, mesh_kind)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
integer(kind=I4P),	intent(in),	optional	::	nx1
integer(kind=I4P),	intent(in),	optional	::	nx2
integer(kind=I4P),	intent(in),	optional	::	ny1
integer(kind=I4P),	intent(in),	optional	::	ny2
integer(kind=I4P),	intent(in),	optional	::	nz1
integer(kind=I4P),	intent(in),	optional	::	nz2
character(len=*),	intent(in),	optional	::	mesh_kind

generic, public :: write_dataarray => write_dataarray1_rank1_R8P, write_dataarray1_rank1_R4P, write_dataarray1_rank1_I8P, write_dataarray1_rank1_I4P, write_dataarray1_rank1_I2P, write_dataarray1_rank1_I1P, write_dataarray1_rank2_R8P, write_dataarray1_rank2_R4P, write_dataarray1_rank2_I8P, write_dataarray1_rank2_I4P, write_dataarray1_rank2_I2P, write_dataarray1_rank2_I1P, write_dataarray1_rank3_R8P, write_dataarray1_rank3_R4P, write_dataarray1_rank3_I8P, write_dataarray1_rank3_I4P, write_dataarray1_rank3_I2P, write_dataarray1_rank3_I1P, write_dataarray1_rank4_R8P, write_dataarray1_rank4_R4P, write_dataarray1_rank4_I8P, write_dataarray1_rank4_I4P, write_dataarray1_rank4_I2P, write_dataarray1_rank4_I1P, write_dataarray3_rank1_R8P, write_dataarray3_rank1_R4P, write_dataarray3_rank1_I8P, write_dataarray3_rank1_I4P, write_dataarray3_rank1_I2P, write_dataarray3_rank1_I1P, write_dataarray3_rank3_R8P, write_dataarray3_rank3_R4P, write_dataarray3_rank3_I8P, write_dataarray3_rank3_I4P, write_dataarray3_rank3_I2P, write_dataarray3_rank3_I1P, write_dataarray6_rank1_R8P, write_dataarray6_rank1_R4P, write_dataarray6_rank1_I8P, write_dataarray6_rank1_I4P, write_dataarray6_rank1_I2P, write_dataarray6_rank1_I1P, write_dataarray6_rank3_R8P, write_dataarray6_rank3_R4P, write_dataarray6_rank3_I8P, write_dataarray6_rank3_I4P, write_dataarray6_rank3_I2P, write_dataarray6_rank3_I1P, write_dataarray_location_tag

private function write_dataarray1_rank1_R8P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_R4P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I8P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I4P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I2P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I1P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank2_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank3_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray1_rank4_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_R8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:)
real(kind=R8P),	intent(in)		::	y(1:)
real(kind=R8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_R4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:)
real(kind=R4P),	intent(in)		::	y(1:)
real(kind=R4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_I8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:)
integer(kind=I8P),	intent(in)		::	y(1:)
integer(kind=I8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_I4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:)
integer(kind=I4P),	intent(in)		::	y(1:)
integer(kind=I4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_I2P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:)
integer(kind=I2P),	intent(in)		::	y(1:)
integer(kind=I2P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank1_I1P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:)
integer(kind=I1P),	intent(in)		::	y(1:)
integer(kind=I1P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_R8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
real(kind=R8P),	intent(in)		::	y(1:,1:,1:)
real(kind=R8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_R4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
real(kind=R4P),	intent(in)		::	y(1:,1:,1:)
real(kind=R4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_I8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_I4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_I2P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray3_rank3_I1P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_R8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	u(1:)
real(kind=R8P),	intent(in)		::	v(1:)
real(kind=R8P),	intent(in)		::	w(1:)
real(kind=R8P),	intent(in)		::	x(1:)
real(kind=R8P),	intent(in)		::	y(1:)
real(kind=R8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_R4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	u(1:)
real(kind=R4P),	intent(in)		::	v(1:)
real(kind=R4P),	intent(in)		::	w(1:)
real(kind=R4P),	intent(in)		::	x(1:)
real(kind=R4P),	intent(in)		::	y(1:)
real(kind=R4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_I8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	u(1:)
integer(kind=I8P),	intent(in)		::	v(1:)
integer(kind=I8P),	intent(in)		::	w(1:)
integer(kind=I8P),	intent(in)		::	x(1:)
integer(kind=I8P),	intent(in)		::	y(1:)
integer(kind=I8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_I4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	u(1:)
integer(kind=I4P),	intent(in)		::	v(1:)
integer(kind=I4P),	intent(in)		::	w(1:)
integer(kind=I4P),	intent(in)		::	x(1:)
integer(kind=I4P),	intent(in)		::	y(1:)
integer(kind=I4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_I2P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	u(1:)
integer(kind=I2P),	intent(in)		::	v(1:)
integer(kind=I2P),	intent(in)		::	w(1:)
integer(kind=I2P),	intent(in)		::	x(1:)
integer(kind=I2P),	intent(in)		::	y(1:)
integer(kind=I2P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank1_I1P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	u(1:)
integer(kind=I1P),	intent(in)		::	v(1:)
integer(kind=I1P),	intent(in)		::	w(1:)
integer(kind=I1P),	intent(in)		::	x(1:)
integer(kind=I1P),	intent(in)		::	y(1:)
integer(kind=I1P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_R8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	u(1:,1:,1:)
real(kind=R8P),	intent(in)		::	v(1:,1:,1:)
real(kind=R8P),	intent(in)		::	w(1:,1:,1:)
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
real(kind=R8P),	intent(in)		::	y(1:,1:,1:)
real(kind=R8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_R4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	u(1:,1:,1:)
real(kind=R4P),	intent(in)		::	v(1:,1:,1:)
real(kind=R4P),	intent(in)		::	w(1:,1:,1:)
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
real(kind=R4P),	intent(in)		::	y(1:,1:,1:)
real(kind=R4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_I8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_I4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_I2P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray6_rank3_I1P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

private function write_dataarray_location_tag(self, location, action) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
character(len=*),	intent(in)	::	location
character(len=*),	intent(in)	::	action

Return Value integer(kind=I4P)

generic, public :: write_fielddata => write_fielddata1_rank0, write_fielddata_tag

private function write_fielddata1_rank0(self, data_name, x) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
character(len=*),	intent(in)	::	data_name
class(*),	intent(in)	::	x

Return Value integer(kind=I4P)

private function write_fielddata_tag(self, action) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
character(len=*),	intent(in)			::	action

Return Value integer(kind=I4P)

generic, public :: write_geo => write_geo_strg_data1_rank2_R8P, write_geo_strg_data1_rank2_R4P, write_geo_strg_data1_rank4_R8P, write_geo_strg_data1_rank4_R4P, write_geo_strg_data3_rank1_R8P, write_geo_strg_data3_rank1_R4P, write_geo_strg_data3_rank3_R8P, write_geo_strg_data3_rank3_R4P, write_geo_rect_data3_rank1_R8P, write_geo_rect_data3_rank1_R4P, write_geo_unst_data1_rank2_R8P, write_geo_unst_data1_rank2_R4P, write_geo_unst_data3_rank1_R8P, write_geo_unst_data3_rank1_R4P

private function write_geo_strg_data1_rank2_R8P(self, xyz) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
real(kind=R8P),	intent(in)			::	xyz(1:,1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data1_rank2_R4P(self, xyz) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
real(kind=R4P),	intent(in)			::	xyz(1:,1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data1_rank4_R8P(self, xyz) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
real(kind=R8P),	intent(in)			::	xyz(1:,1:,1:,1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data1_rank4_R4P(self, xyz) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self
real(kind=R4P),	intent(in)			::	xyz(1:,1:,1:,1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data3_rank1_R8P(self, n, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	n
real(kind=R8P),	intent(in)	::	x(1:)
real(kind=R8P),	intent(in)	::	y(1:)
real(kind=R8P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data3_rank1_R4P(self, n, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	n
real(kind=R4P),	intent(in)	::	x(1:)
real(kind=R4P),	intent(in)	::	y(1:)
real(kind=R4P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data3_rank3_R8P(self, n, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	n
real(kind=R8P),	intent(in)	::	x(1:,1:,1:)
real(kind=R8P),	intent(in)	::	y(1:,1:,1:)
real(kind=R8P),	intent(in)	::	z(1:,1:,1:)

Return Value integer(kind=I4P)

private function write_geo_strg_data3_rank3_R4P(self, n, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	n
real(kind=R4P),	intent(in)	::	x(1:,1:,1:)
real(kind=R4P),	intent(in)	::	y(1:,1:,1:)
real(kind=R4P),	intent(in)	::	z(1:,1:,1:)

Return Value integer(kind=I4P)

private function write_geo_rect_data3_rank1_R8P(self, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
real(kind=R8P),	intent(in)	::	x(1:)
real(kind=R8P),	intent(in)	::	y(1:)
real(kind=R8P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

private function write_geo_rect_data3_rank1_R4P(self, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
real(kind=R4P),	intent(in)	::	x(1:)
real(kind=R4P),	intent(in)	::	y(1:)
real(kind=R4P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

private function write_geo_unst_data1_rank2_R8P(self, np, nc, xyz) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	np
integer(kind=I4P),	intent(in)	::	nc
real(kind=R8P),	intent(in)	::	xyz(1:,1:)

Return Value integer(kind=I4P)

private function write_geo_unst_data1_rank2_R4P(self, np, nc, xyz) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	np
integer(kind=I4P),	intent(in)	::	nc
real(kind=R4P),	intent(in)	::	xyz(1:,1:)

Return Value integer(kind=I4P)

private function write_geo_unst_data3_rank1_R8P(self, np, nc, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	np
integer(kind=I4P),	intent(in)	::	nc
real(kind=R8P),	intent(in)	::	x(1:)
real(kind=R8P),	intent(in)	::	y(1:)
real(kind=R8P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

private function write_geo_unst_data3_rank1_R4P(self, np, nc, x, y, z) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	np
integer(kind=I4P),	intent(in)	::	nc
real(kind=R4P),	intent(in)	::	x(1:)
real(kind=R4P),	intent(in)	::	y(1:)
real(kind=R4P),	intent(in)	::	z(1:)

Return Value integer(kind=I4P)

generic, public :: write_parallel_block_files => write_parallel_block_file, write_parallel_block_files_array, write_parallel_block_files_string

private function write_parallel_block_file(self, file_index, filename, name) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
integer(kind=I4P),	intent(in)		::	file_index
character(len=*),	intent(in)		::	filename
character(len=*),	intent(in),	optional	::	name

Return Value integer(kind=I4P)

private function write_parallel_block_files_array(self, filenames, names) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	filenames(:)
character(len=*),	intent(in),	optional	::	names(:)

Return Value integer(kind=I4P)

private function write_parallel_block_files_string(self, filenames, names, delimiter) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character(len=*),	intent(in)		::	filenames
character(len=*),	intent(in),	optional	::	names
character(len=*),	intent(in),	optional	::	delimiter

Return Value integer(kind=I4P)

generic, public :: write_piece => write_piece_start_tag, write_piece_start_tag_unst, write_piece_end_tag

private function write_piece_start_tag(self, nx1, nx2, ny1, ny2, nz1, nz2) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	nx1
integer(kind=I4P),	intent(in)	::	nx2
integer(kind=I4P),	intent(in)	::	ny1
integer(kind=I4P),	intent(in)	::	ny2
integer(kind=I4P),	intent(in)	::	nz1
integer(kind=I4P),	intent(in)	::	nz2

Return Value integer(kind=I4P)

private function write_piece_start_tag_unst(self, np, nc) result(error)

Arguments

Type	Intent		Name
class(xml_writer_abstract),	intent(inout)	::	self
integer(kind=I4P),	intent(in)	::	np
integer(kind=I4P),	intent(in)	::	nc

Return Value integer(kind=I4P)

private function write_piece_end_tag(self) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_abstract),	intent(inout)			::	self

Return Value integer(kind=I4P)

procedure, public, pass(self) :: initialize

private function initialize(self, format, filename, mesh_topology, nx1, nx2, ny1, ny2, nz1, nz2, is_volatile, mesh_kind) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	format
character(len=*),	intent(in)		::	filename
character(len=*),	intent(in)		::	mesh_topology
integer(kind=I4P),	intent(in),	optional	::	nx1
integer(kind=I4P),	intent(in),	optional	::	nx2
integer(kind=I4P),	intent(in),	optional	::	ny1
integer(kind=I4P),	intent(in),	optional	::	ny2
integer(kind=I4P),	intent(in),	optional	::	nz1
integer(kind=I4P),	intent(in),	optional	::	nz2
logical,	intent(in),	optional	::	is_volatile
character(len=*),	intent(in),	optional	::	mesh_kind

Return Value integer(kind=I4P)

procedure, public, pass(self) :: finalize

private function finalize(self) result(error)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_binary_local),	intent(inout)			::	self

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_R8P

private function write_dataarray1_rank1_R8P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_R4P

private function write_dataarray1_rank1_R4P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_I8P

private function write_dataarray1_rank1_I8P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_I4P

private function write_dataarray1_rank1_I4P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_I2P

private function write_dataarray1_rank1_I2P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_I1P

private function write_dataarray1_rank1_I1P(self, data_name, x, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_R8P

private function write_dataarray1_rank2_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_R4P

private function write_dataarray1_rank2_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_I8P

private function write_dataarray1_rank2_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_I4P

private function write_dataarray1_rank2_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_I2P

private function write_dataarray1_rank2_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank2_I1P

private function write_dataarray1_rank2_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_R8P

private function write_dataarray1_rank3_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_R4P

private function write_dataarray1_rank3_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_I8P

private function write_dataarray1_rank3_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_I4P

private function write_dataarray1_rank3_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_I2P

private function write_dataarray1_rank3_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank3_I1P

private function write_dataarray1_rank3_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_R8P

private function write_dataarray1_rank4_R8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_R4P

private function write_dataarray1_rank4_R4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_I8P

private function write_dataarray1_rank4_I8P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_I4P

private function write_dataarray1_rank4_I4P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_I2P

private function write_dataarray1_rank4_I2P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank4_I1P

private function write_dataarray1_rank4_I1P(self, data_name, x, one_component, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:,1:)
logical,	intent(in),	optional	::	one_component
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_R8P

private function write_dataarray3_rank1_R8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:)
real(kind=R8P),	intent(in)		::	y(1:)
real(kind=R8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_R4P

private function write_dataarray3_rank1_R4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:)
real(kind=R4P),	intent(in)		::	y(1:)
real(kind=R4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_I8P

private function write_dataarray3_rank1_I8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:)
integer(kind=I8P),	intent(in)		::	y(1:)
integer(kind=I8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_I4P

private function write_dataarray3_rank1_I4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:)
integer(kind=I4P),	intent(in)		::	y(1:)
integer(kind=I4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_I2P

private function write_dataarray3_rank1_I2P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:)
integer(kind=I2P),	intent(in)		::	y(1:)
integer(kind=I2P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank1_I1P

private function write_dataarray3_rank1_I1P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:)
integer(kind=I1P),	intent(in)		::	y(1:)
integer(kind=I1P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_R8P

private function write_dataarray3_rank3_R8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
real(kind=R8P),	intent(in)		::	y(1:,1:,1:)
real(kind=R8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_R4P

private function write_dataarray3_rank3_R4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
real(kind=R4P),	intent(in)		::	y(1:,1:,1:)
real(kind=R4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_I8P

private function write_dataarray3_rank3_I8P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_I4P

private function write_dataarray3_rank3_I4P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_I2P

private function write_dataarray3_rank3_I2P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray3_rank3_I1P

private function write_dataarray3_rank3_I1P(self, data_name, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_R8P

private function write_dataarray6_rank1_R8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	u(1:)
real(kind=R8P),	intent(in)		::	v(1:)
real(kind=R8P),	intent(in)		::	w(1:)
real(kind=R8P),	intent(in)		::	x(1:)
real(kind=R8P),	intent(in)		::	y(1:)
real(kind=R8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_R4P

private function write_dataarray6_rank1_R4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	u(1:)
real(kind=R4P),	intent(in)		::	v(1:)
real(kind=R4P),	intent(in)		::	w(1:)
real(kind=R4P),	intent(in)		::	x(1:)
real(kind=R4P),	intent(in)		::	y(1:)
real(kind=R4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_I8P

private function write_dataarray6_rank1_I8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	u(1:)
integer(kind=I8P),	intent(in)		::	v(1:)
integer(kind=I8P),	intent(in)		::	w(1:)
integer(kind=I8P),	intent(in)		::	x(1:)
integer(kind=I8P),	intent(in)		::	y(1:)
integer(kind=I8P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_I4P

private function write_dataarray6_rank1_I4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	u(1:)
integer(kind=I4P),	intent(in)		::	v(1:)
integer(kind=I4P),	intent(in)		::	w(1:)
integer(kind=I4P),	intent(in)		::	x(1:)
integer(kind=I4P),	intent(in)		::	y(1:)
integer(kind=I4P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_I2P

private function write_dataarray6_rank1_I2P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	u(1:)
integer(kind=I2P),	intent(in)		::	v(1:)
integer(kind=I2P),	intent(in)		::	w(1:)
integer(kind=I2P),	intent(in)		::	x(1:)
integer(kind=I2P),	intent(in)		::	y(1:)
integer(kind=I2P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank1_I1P

private function write_dataarray6_rank1_I1P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	u(1:)
integer(kind=I1P),	intent(in)		::	v(1:)
integer(kind=I1P),	intent(in)		::	w(1:)
integer(kind=I1P),	intent(in)		::	x(1:)
integer(kind=I1P),	intent(in)		::	y(1:)
integer(kind=I1P),	intent(in)		::	z(1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_R8P

private function write_dataarray6_rank3_R8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R8P),	intent(in)		::	u(1:,1:,1:)
real(kind=R8P),	intent(in)		::	v(1:,1:,1:)
real(kind=R8P),	intent(in)		::	w(1:,1:,1:)
real(kind=R8P),	intent(in)		::	x(1:,1:,1:)
real(kind=R8P),	intent(in)		::	y(1:,1:,1:)
real(kind=R8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_R4P

private function write_dataarray6_rank3_R4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
real(kind=R4P),	intent(in)		::	u(1:,1:,1:)
real(kind=R4P),	intent(in)		::	v(1:,1:,1:)
real(kind=R4P),	intent(in)		::	w(1:,1:,1:)
real(kind=R4P),	intent(in)		::	x(1:,1:,1:)
real(kind=R4P),	intent(in)		::	y(1:,1:,1:)
real(kind=R4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_I8P

private function write_dataarray6_rank3_I8P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I8P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I8P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_I4P

private function write_dataarray6_rank3_I4P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I4P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I4P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_I2P

private function write_dataarray6_rank3_I2P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I2P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I2P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray6_rank3_I1P

private function write_dataarray6_rank3_I1P(self, data_name, u, v, w, x, y, z, is_tuples) result(error)

Arguments

Type	Intent	Optional		Name
class(xml_writer_binary_local),	intent(inout)		::	self
character(len=*),	intent(in)		::	data_name
integer(kind=I1P),	intent(in)		::	u(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	v(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	w(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	x(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	y(1:,1:,1:)
integer(kind=I1P),	intent(in)		::	z(1:,1:,1:)
logical,	intent(in),	optional	::	is_tuples

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray_appended

private subroutine write_dataarray_appended(self)

Arguments

Type	Intent	Optional	Attributes		Name
class(xml_writer_binary_local),	intent(inout)			::	self

Source Code

type, extends(xml_writer_abstract) :: xml_writer_binary_local
   !< VTK file XML writer, binary local.
   contains
      ! deferred methods
      procedure, pass(self) :: initialize                 !< Initialize writer.
      procedure, pass(self) :: finalize                   !< Finalize writer.
      procedure, pass(self) :: write_dataarray1_rank1_R8P !< Write dataarray 1, rank 1, R8P.
      procedure, pass(self) :: write_dataarray1_rank1_R4P !< Write dataarray 1, rank 1, R4P.
      procedure, pass(self) :: write_dataarray1_rank1_I8P !< Write dataarray 1, rank 1, I8P.
      procedure, pass(self) :: write_dataarray1_rank1_I4P !< Write dataarray 1, rank 1, I4P.
      procedure, pass(self) :: write_dataarray1_rank1_I2P !< Write dataarray 1, rank 1, I2P.
      procedure, pass(self) :: write_dataarray1_rank1_I1P !< Write dataarray 1, rank 1, I1P.
      procedure, pass(self) :: write_dataarray1_rank2_R8P !< Write dataarray 1, rank 2, R8P.
      procedure, pass(self) :: write_dataarray1_rank2_R4P !< Write dataarray 1, rank 2, R4P.
      procedure, pass(self) :: write_dataarray1_rank2_I8P !< Write dataarray 1, rank 2, I8P.
      procedure, pass(self) :: write_dataarray1_rank2_I4P !< Write dataarray 1, rank 2, I4P.
      procedure, pass(self) :: write_dataarray1_rank2_I2P !< Write dataarray 1, rank 2, I2P.
      procedure, pass(self) :: write_dataarray1_rank2_I1P !< Write dataarray 1, rank 2, I1P.
      procedure, pass(self) :: write_dataarray1_rank3_R8P !< Write dataarray 1, rank 3, R8P.
      procedure, pass(self) :: write_dataarray1_rank3_R4P !< Write dataarray 1, rank 3, R4P.
      procedure, pass(self) :: write_dataarray1_rank3_I8P !< Write dataarray 1, rank 3, I8P.
      procedure, pass(self) :: write_dataarray1_rank3_I4P !< Write dataarray 1, rank 3, I4P.
      procedure, pass(self) :: write_dataarray1_rank3_I2P !< Write dataarray 1, rank 3, I2P.
      procedure, pass(self) :: write_dataarray1_rank3_I1P !< Write dataarray 1, rank 3, I1P.
      procedure, pass(self) :: write_dataarray1_rank4_R8P !< Write dataarray 1, rank 4, R8P.
      procedure, pass(self) :: write_dataarray1_rank4_R4P !< Write dataarray 1, rank 4, R4P.
      procedure, pass(self) :: write_dataarray1_rank4_I8P !< Write dataarray 1, rank 4, I8P.
      procedure, pass(self) :: write_dataarray1_rank4_I4P !< Write dataarray 1, rank 4, I4P.
      procedure, pass(self) :: write_dataarray1_rank4_I2P !< Write dataarray 1, rank 4, I2P.
      procedure, pass(self) :: write_dataarray1_rank4_I1P !< Write dataarray 1, rank 4, I1P.
      procedure, pass(self) :: write_dataarray3_rank1_R8P !< Write dataarray 3, rank 1, R8P.
      procedure, pass(self) :: write_dataarray3_rank1_R4P !< Write dataarray 3, rank 1, R4P.
      procedure, pass(self) :: write_dataarray3_rank1_I8P !< Write dataarray 3, rank 1, I8P.
      procedure, pass(self) :: write_dataarray3_rank1_I4P !< Write dataarray 3, rank 1, I4P.
      procedure, pass(self) :: write_dataarray3_rank1_I2P !< Write dataarray 3, rank 1, I2P.
      procedure, pass(self) :: write_dataarray3_rank1_I1P !< Write dataarray 3, rank 1, I1P.
      procedure, pass(self) :: write_dataarray3_rank3_R8P !< Write dataarray 3, rank 3, R8P.
      procedure, pass(self) :: write_dataarray3_rank3_R4P !< Write dataarray 3, rank 3, R4P.
      procedure, pass(self) :: write_dataarray3_rank3_I8P !< Write dataarray 3, rank 3, I8P.
      procedure, pass(self) :: write_dataarray3_rank3_I4P !< Write dataarray 3, rank 3, I4P.
      procedure, pass(self) :: write_dataarray3_rank3_I2P !< Write dataarray 3, rank 3, I2P.
      procedure, pass(self) :: write_dataarray3_rank3_I1P !< Write dataarray 3, rank 3, I1P.
      procedure, pass(self) :: write_dataarray6_rank1_R8P !< Write dataarray 6, rank 1, R8P.
      procedure, pass(self) :: write_dataarray6_rank1_R4P !< Write dataarray 6, rank 1, R4P.
      procedure, pass(self) :: write_dataarray6_rank1_I8P !< Write dataarray 6, rank 1, I8P.
      procedure, pass(self) :: write_dataarray6_rank1_I4P !< Write dataarray 6, rank 1, I4P.
      procedure, pass(self) :: write_dataarray6_rank1_I2P !< Write dataarray 6, rank 1, I2P.
      procedure, pass(self) :: write_dataarray6_rank1_I1P !< Write dataarray 6, rank 1, I1P.
      procedure, pass(self) :: write_dataarray6_rank3_R8P !< Write dataarray 6, rank 3, R8P.
      procedure, pass(self) :: write_dataarray6_rank3_R4P !< Write dataarray 6, rank 3, R4P.
      procedure, pass(self) :: write_dataarray6_rank3_I8P !< Write dataarray 6, rank 3, I8P.
      procedure, pass(self) :: write_dataarray6_rank3_I4P !< Write dataarray 6, rank 3, I4P.
      procedure, pass(self) :: write_dataarray6_rank3_I2P !< Write dataarray 6, rank 3, I2P.
      procedure, pass(self) :: write_dataarray6_rank3_I1P !< Write dataarray 6, rank 3, I1P.
      procedure, pass(self) :: write_dataarray_appended   !< Write appended.
endtype xml_writer_binary_local

xml_writer_binary_local Derived Type

Contents

Variables

Type-Bound Procedures

Source Code

type, public, extends(xml_writer_abstract) :: xml_writer_binary_local

Inherits

Components

Type-Bound Procedures

procedure, public, pass(self) :: close_xml_file

private subroutine close_xml_file(self)

Arguments

procedure, public, pass(self) :: open_xml_file

private subroutine open_xml_file(self, filename)

Arguments

procedure, public, pass(self) :: free

private elemental subroutine free(self, error)

Arguments

procedure, public, pass(self) :: get_xml_volatile

private pure subroutine get_xml_volatile(self, xml_volatile, error)

Arguments

procedure, public, pass(self) :: write_connectivity

private function write_connectivity(self, nc, connectivity, offset, cell_type, face, faceoffset) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray_location_tag

private function write_dataarray_location_tag(self, location, action) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray_tag

private subroutine write_dataarray_tag(self, data_type, number_of_components, data_name, data_content, is_tuples)

Arguments

procedure, public, pass(self) :: write_dataarray_tag_appended

private subroutine write_dataarray_tag_appended(self, data_type, number_of_components, data_name, is_tuples)

Arguments

procedure, public, pass(self) :: write_end_tag

private subroutine write_end_tag(self, name)

Arguments

procedure, public, pass(self) :: write_header_tag

private subroutine write_header_tag(self)

Arguments

procedure, public, pass(self) :: write_parallel_open_block

private function write_parallel_open_block(self, name) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_close_block

private function write_parallel_close_block(self) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_dataarray

private function write_parallel_dataarray(self, data_name, data_type, number_of_components) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_parallel_geo

private function write_parallel_geo(self, source, nx1, nx2, ny1, ny2, nz1, nz2) result(error)

Arguments

Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_self_closing_tag

private subroutine write_self_closing_tag(self, name, attributes)

Arguments

procedure, public, pass(self) :: write_start_tag

private subroutine write_start_tag(self, name, attributes)

Arguments

procedure, public, pass(self) :: write_tag

private subroutine write_tag(self, name, attributes, content)

Arguments

procedure, public, pass(self) :: write_topology_tag

private subroutine write_topology_tag(self, nx1, nx2, ny1, ny2, nz1, nz2, mesh_kind)

Arguments

private function write_dataarray1_rank1_R8P(self, data_name, x, is_tuples) result(error)

Arguments

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_R4P(self, data_name, x, is_tuples) result(error)

Arguments

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I8P(self, data_name, x, is_tuples) result(error)

Arguments

Return Value integer(kind=I4P)

private function write_dataarray1_rank1_I4P(self, data_name, x, is_tuples) result(error)

Arguments