xml_writer_abstract – Lib_VTK

type, public, abstract :: xml_writer_abstract

Inherits

Inherited by

Variables

format_ch topology indent ioffset xml vtm_block error tag is_volatile xml_volatile

Type-Bound Procedures

Source Code

xml_writer_abstract

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, 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 Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: location

character, 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,	intent(in)		::	data_type
integer(kind=I4P),	intent(in)		::	number_of_components
character,	intent(in)		::	data_name
character,	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,	intent(in)		::	data_type
integer(kind=I4P),	intent(in)		::	number_of_components
character,	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, 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, 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,	intent(in)		::	data_name
character,	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,	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 Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: name

character, intent(in), optional :: attributes

procedure, public, pass(self) :: write_start_tag

private subroutine write_start_tag(self, name, attributes)

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: name

character, 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,	intent(in)		::	name
character,	intent(in),	optional	::	attributes
character,	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,	intent(in),	optional	::	mesh_kind

procedure(initialize_interface), public, deferred, pass(self) :: initialize

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

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	intent(in)		::	format
character,	intent(in)		::	filename
character,	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,	intent(in),	optional	::	mesh_kind

Return Value integer(kind=I4P)

procedure(finalize_interface), public, deferred, pass(self) :: finalize

function finalize_interface(self) result(error)Prototype

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

Return Value integer(kind=I4P)

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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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,	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 Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: location

character, 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 Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, 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, 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,	intent(in)		::	filename
character,	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 Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: filenames(:)

character, 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,	intent(in)		::	filenames
character,	intent(in),	optional	::	names
character,	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 Optional Attributes 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(write_dataarray1_rank1_R8P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_R8P

function write_dataarray1_rank1_R8P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank1_R4P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_R4P

function write_dataarray1_rank1_R4P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank1_I8P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_I8P

function write_dataarray1_rank1_I8P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank1_I4P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_I4P

function write_dataarray1_rank1_I4P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank1_I2P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_I2P

function write_dataarray1_rank1_I2P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank1_I1P_interface), public, deferred, pass(self) :: write_dataarray1_rank1_I1P

function write_dataarray1_rank1_I1P_interface(self, data_name, x, is_tuples) result(error)Prototype

Arguments

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

Return Value integer(kind=I4P)

procedure(write_dataarray1_rank2_R8P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_R8P

function write_dataarray1_rank2_R8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank2_R4P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_R4P

function write_dataarray1_rank2_R4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank2_I8P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_I8P

function write_dataarray1_rank2_I8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank2_I4P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_I4P

function write_dataarray1_rank2_I4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank2_I2P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_I2P

function write_dataarray1_rank2_I2P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank2_I1P_interface), public, deferred, pass(self) :: write_dataarray1_rank2_I1P

function write_dataarray1_rank2_I1P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_R8P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_R8P

function write_dataarray1_rank3_R8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_R4P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_R4P

function write_dataarray1_rank3_R4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_I8P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_I8P

function write_dataarray1_rank3_I8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_I4P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_I4P

function write_dataarray1_rank3_I4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_I2P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_I2P

function write_dataarray1_rank3_I2P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank3_I1P_interface), public, deferred, pass(self) :: write_dataarray1_rank3_I1P

function write_dataarray1_rank3_I1P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_R8P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_R8P

function write_dataarray1_rank4_R8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_R4P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_R4P

function write_dataarray1_rank4_R4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_I8P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_I8P

function write_dataarray1_rank4_I8P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_I4P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_I4P

function write_dataarray1_rank4_I4P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_I2P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_I2P

function write_dataarray1_rank4_I2P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray1_rank4_I1P_interface), public, deferred, pass(self) :: write_dataarray1_rank4_I1P

function write_dataarray1_rank4_I1P_interface(self, data_name, x, one_component, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_R8P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_R8P

function write_dataarray3_rank1_R8P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_R4P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_R4P

function write_dataarray3_rank1_R4P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_I8P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_I8P

function write_dataarray3_rank1_I8P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_I4P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_I4P

function write_dataarray3_rank1_I4P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_I2P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_I2P

function write_dataarray3_rank1_I2P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank1_I1P_interface), public, deferred, pass(self) :: write_dataarray3_rank1_I1P

function write_dataarray3_rank1_I1P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_R8P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_R8P

function write_dataarray3_rank3_R8P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_R4P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_R4P

function write_dataarray3_rank3_R4P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_I8P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_I8P

function write_dataarray3_rank3_I8P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_I4P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_I4P

function write_dataarray3_rank3_I4P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_I2P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_I2P

function write_dataarray3_rank3_I2P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray3_rank3_I1P_interface), public, deferred, pass(self) :: write_dataarray3_rank3_I1P

function write_dataarray3_rank3_I1P_interface(self, data_name, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_R8P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_R8P

function write_dataarray6_rank1_R8P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_R4P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_R4P

function write_dataarray6_rank1_R4P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_I8P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_I8P

function write_dataarray6_rank1_I8P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_I4P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_I4P

function write_dataarray6_rank1_I4P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_I2P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_I2P

function write_dataarray6_rank1_I2P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank1_I1P_interface), public, deferred, pass(self) :: write_dataarray6_rank1_I1P

function write_dataarray6_rank1_I1P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_R8P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_R8P

function write_dataarray6_rank3_R8P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_R4P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_R4P

function write_dataarray6_rank3_R4P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_I8P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_I8P

function write_dataarray6_rank3_I8P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_I4P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_I4P

function write_dataarray6_rank3_I4P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_I2P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_I2P

function write_dataarray6_rank3_I2P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray6_rank3_I1P_interface), public, deferred, pass(self) :: write_dataarray6_rank3_I1P

function write_dataarray6_rank3_I1P_interface(self, data_name, u, v, w, x, y, z, is_tuples) result(error)Prototype

Arguments

Type	Intent	Optional		Name
class(xml_writer_abstract),	intent(inout)		::	self
character,	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(write_dataarray_appended_interface), public, deferred, pass(self) :: write_dataarray_appended

subroutine write_dataarray_appended_interface(self)Prototype

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

procedure, private, pass(self) :: write_fielddata1_rank0

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

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: data_name

class(*), intent(in) :: x

Return Value integer(kind=I4P)

procedure, private, pass(self) :: write_fielddata_tag

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

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: action

Return Value integer(kind=I4P)

procedure, private, pass(self) :: write_geo_strg_data1_rank2_R8P

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)

procedure, private, pass(self) :: write_geo_strg_data1_rank2_R4P

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)

procedure, private, pass(self) :: write_geo_strg_data1_rank4_R8P

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)

procedure, private, pass(self) :: write_geo_strg_data1_rank4_R4P

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)

procedure, private, pass(self) :: write_geo_strg_data3_rank1_R8P

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)

procedure, private, pass(self) :: write_geo_strg_data3_rank1_R4P

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)

procedure, private, pass(self) :: write_geo_strg_data3_rank3_R8P

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)

procedure, private, pass(self) :: write_geo_strg_data3_rank3_R4P

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)

procedure, private, pass(self) :: write_geo_rect_data3_rank1_R8P

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)

procedure, private, pass(self) :: write_geo_rect_data3_rank1_R4P

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)

procedure, private, pass(self) :: write_geo_unst_data1_rank2_R8P

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)

procedure, private, pass(self) :: write_geo_unst_data1_rank2_R4P

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)

procedure, private, pass(self) :: write_geo_unst_data3_rank1_R8P

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)

procedure, private, pass(self) :: write_geo_unst_data3_rank1_R4P

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)

procedure, private, pass(self) :: write_piece_start_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)

procedure, private, pass(self) :: write_piece_start_tag_unst

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

Arguments

Type Intent Optional Attributes 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)

procedure, private, pass(self) :: write_piece_end_tag

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, private, pass(self) :: write_parallel_block_file

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,	intent(in)		::	filename
character,	intent(in),	optional	::	name

Return Value integer(kind=I4P)

procedure, private, pass(self) :: write_parallel_block_files_array

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

Arguments

Type Intent Optional Attributes Name

class(xml_writer_abstract), intent(inout) :: self

character, intent(in) :: filenames(:)

character, intent(in), optional :: names(:)

Return Value integer(kind=I4P)

procedure, private, pass(self) :: write_parallel_block_files_string

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,	intent(in)		::	filenames
character,	intent(in),	optional	::	names
character,	intent(in),	optional	::	delimiter

Return Value integer(kind=I4P)

Source Code

type, abstract :: xml_writer_abstract
  !< VTK file abstract XML writer.
  type(string)  :: format_ch                       !< Output format, string code.
  type(string)  :: topology                        !< Mesh topology.
  integer(I4P)  :: indent=0_I4P                    !< Indent count.
  integer(I8P)  :: ioffset=0_I8P                   !< Offset count.
  integer(I4P)  :: xml=0_I4P                       !< XML Logical unit.
  integer(I4P)  :: vtm_block(1:2)=[-1_I4P, -1_I4P] !< Block indexes.
  integer(I4P)  :: error=0_I4P                     !< IO Error status.
  type(xml_tag) :: tag                             !< XML tags handler.
  logical       :: is_volatile=.false.             !< Flag to check volatile writer.
  type(string)  :: xml_volatile                    !< XML file volatile (not a physical file).
  contains
    ! public methods (some deferred)
    procedure,                                 pass(self) :: close_xml_file               !< Close xml file.
    procedure,                                 pass(self) :: open_xml_file                !< Open xml file.
    procedure,                                 pass(self) :: free                         !< Free allocated memory.
    procedure,                                 pass(self) :: get_xml_volatile             !< Return the XML volatile string file.
    procedure,                                 pass(self) :: write_connectivity           !< Write connectivity.
    procedure,                                 pass(self) :: write_dataarray_location_tag !< Write dataarray location tag.
    procedure,                                 pass(self) :: write_dataarray_tag          !< Write dataarray tag.
    procedure,                                 pass(self) :: write_dataarray_tag_appended !< Write dataarray appended tag.
    procedure,                                 pass(self) :: write_end_tag                !< Write `</tag_name>` end tag.
    procedure,                                 pass(self) :: write_header_tag             !< Write header tag.
    procedure,                                 pass(self) :: write_parallel_open_block    !< Write parallel open block.
    procedure,                                 pass(self) :: write_parallel_close_block   !< Write parallel close block.
    procedure,                                 pass(self) :: write_parallel_dataarray     !< Write parallel dataarray.
    procedure,                                 pass(self) :: write_parallel_geo           !< Write parallel geo.
    procedure,                                 pass(self) :: write_self_closing_tag       !< Write self closing tag.
    procedure,                                 pass(self) :: write_start_tag              !< Write start tag.
    procedure,                                 pass(self) :: write_tag                    !< Write tag.
    procedure,                                 pass(self) :: write_topology_tag           !< Write topology tag.
    procedure(initialize_interface), deferred, pass(self) :: initialize                   !< Initialize writer.
    procedure(finalize_interface),   deferred, pass(self) :: finalize                     !< Finalize writer.
    generic :: 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 !< Write data (array).
    generic :: write_fielddata =>      &
               write_fielddata1_rank0, &
               write_fielddata_tag !< Write FieldData tag.
    generic :: 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 !< Write mesh.
    generic :: write_parallel_block_files =>     &
               write_parallel_block_file,        &
               write_parallel_block_files_array, &
               write_parallel_block_files_string !< Write block list of files.
    generic :: write_piece =>              &
               write_piece_start_tag,      &
               write_piece_start_tag_unst, &
               write_piece_end_tag !< Write Piece start/end tag.
    ! deferred methods
    procedure(write_dataarray1_rank1_R8P_interface), deferred, pass(self) :: write_dataarray1_rank1_R8P !< Data 1, rank 1, R8P.
    procedure(write_dataarray1_rank1_R4P_interface), deferred, pass(self) :: write_dataarray1_rank1_R4P !< Data 1, rank 1, R4P.
    procedure(write_dataarray1_rank1_I8P_interface), deferred, pass(self) :: write_dataarray1_rank1_I8P !< Data 1, rank 1, I8P.
    procedure(write_dataarray1_rank1_I4P_interface), deferred, pass(self) :: write_dataarray1_rank1_I4P !< Data 1, rank 1, I4P.
    procedure(write_dataarray1_rank1_I2P_interface), deferred, pass(self) :: write_dataarray1_rank1_I2P !< Data 1, rank 1, I2P.
    procedure(write_dataarray1_rank1_I1P_interface), deferred, pass(self) :: write_dataarray1_rank1_I1P !< Data 1, rank 1, I1P.
    procedure(write_dataarray1_rank2_R8P_interface), deferred, pass(self) :: write_dataarray1_rank2_R8P !< Data 1, rank 2, R8P.
    procedure(write_dataarray1_rank2_R4P_interface), deferred, pass(self) :: write_dataarray1_rank2_R4P !< Data 1, rank 2, R4P.
    procedure(write_dataarray1_rank2_I8P_interface), deferred, pass(self) :: write_dataarray1_rank2_I8P !< Data 1, rank 2, I8P.
    procedure(write_dataarray1_rank2_I4P_interface), deferred, pass(self) :: write_dataarray1_rank2_I4P !< Data 1, rank 2, I4P.
    procedure(write_dataarray1_rank2_I2P_interface), deferred, pass(self) :: write_dataarray1_rank2_I2P !< Data 1, rank 2, I2P.
    procedure(write_dataarray1_rank2_I1P_interface), deferred, pass(self) :: write_dataarray1_rank2_I1P !< Data 1, rank 2, I1P.
    procedure(write_dataarray1_rank3_R8P_interface), deferred, pass(self) :: write_dataarray1_rank3_R8P !< Data 1, rank 3, R8P.
    procedure(write_dataarray1_rank3_R4P_interface), deferred, pass(self) :: write_dataarray1_rank3_R4P !< Data 1, rank 3, R4P.
    procedure(write_dataarray1_rank3_I8P_interface), deferred, pass(self) :: write_dataarray1_rank3_I8P !< Data 1, rank 3, I8P.
    procedure(write_dataarray1_rank3_I4P_interface), deferred, pass(self) :: write_dataarray1_rank3_I4P !< Data 1, rank 3, I4P.
    procedure(write_dataarray1_rank3_I2P_interface), deferred, pass(self) :: write_dataarray1_rank3_I2P !< Data 1, rank 3, I2P.
    procedure(write_dataarray1_rank3_I1P_interface), deferred, pass(self) :: write_dataarray1_rank3_I1P !< Data 1, rank 3, I1P.
    procedure(write_dataarray1_rank4_R8P_interface), deferred, pass(self) :: write_dataarray1_rank4_R8P !< Data 1, rank 4, R8P.
    procedure(write_dataarray1_rank4_R4P_interface), deferred, pass(self) :: write_dataarray1_rank4_R4P !< Data 1, rank 4, R4P.
    procedure(write_dataarray1_rank4_I8P_interface), deferred, pass(self) :: write_dataarray1_rank4_I8P !< Data 1, rank 4, I8P.
    procedure(write_dataarray1_rank4_I4P_interface), deferred, pass(self) :: write_dataarray1_rank4_I4P !< Data 1, rank 4, I4P.
    procedure(write_dataarray1_rank4_I2P_interface), deferred, pass(self) :: write_dataarray1_rank4_I2P !< Data 1, rank 4, I2P.
    procedure(write_dataarray1_rank4_I1P_interface), deferred, pass(self) :: write_dataarray1_rank4_I1P !< Data 1, rank 4, I1P.
    procedure(write_dataarray3_rank1_R8P_interface), deferred, pass(self) :: write_dataarray3_rank1_R8P !< Data 3, rank 1, R8P.
    procedure(write_dataarray3_rank1_R4P_interface), deferred, pass(self) :: write_dataarray3_rank1_R4P !< Data 3, rank 1, R4P.
    procedure(write_dataarray3_rank1_I8P_interface), deferred, pass(self) :: write_dataarray3_rank1_I8P !< Data 3, rank 1, I8P.
    procedure(write_dataarray3_rank1_I4P_interface), deferred, pass(self) :: write_dataarray3_rank1_I4P !< Data 3, rank 1, I4P.
    procedure(write_dataarray3_rank1_I2P_interface), deferred, pass(self) :: write_dataarray3_rank1_I2P !< Data 3, rank 1, I2P.
    procedure(write_dataarray3_rank1_I1P_interface), deferred, pass(self) :: write_dataarray3_rank1_I1P !< Data 3, rank 1, I1P.
    procedure(write_dataarray3_rank3_R8P_interface), deferred, pass(self) :: write_dataarray3_rank3_R8P !< Data 3, rank 3, R8P.
    procedure(write_dataarray3_rank3_R4P_interface), deferred, pass(self) :: write_dataarray3_rank3_R4P !< Data 3, rank 3, R4P.
    procedure(write_dataarray3_rank3_I8P_interface), deferred, pass(self) :: write_dataarray3_rank3_I8P !< Data 3, rank 3, I8P.
    procedure(write_dataarray3_rank3_I4P_interface), deferred, pass(self) :: write_dataarray3_rank3_I4P !< Data 3, rank 3, I4P.
    procedure(write_dataarray3_rank3_I2P_interface), deferred, pass(self) :: write_dataarray3_rank3_I2P !< Data 3, rank 3, I2P.
    procedure(write_dataarray3_rank3_I1P_interface), deferred, pass(self) :: write_dataarray3_rank3_I1P !< Data 3, rank 3, I1P.
    procedure(write_dataarray6_rank1_R8P_interface), deferred, pass(self) :: write_dataarray6_rank1_R8P !< Data 3, rank 1, R8P.
    procedure(write_dataarray6_rank1_R4P_interface), deferred, pass(self) :: write_dataarray6_rank1_R4P !< Data 3, rank 1, R4P.
    procedure(write_dataarray6_rank1_I8P_interface), deferred, pass(self) :: write_dataarray6_rank1_I8P !< Data 3, rank 1, I8P.
    procedure(write_dataarray6_rank1_I4P_interface), deferred, pass(self) :: write_dataarray6_rank1_I4P !< Data 3, rank 1, I4P.
    procedure(write_dataarray6_rank1_I2P_interface), deferred, pass(self) :: write_dataarray6_rank1_I2P !< Data 3, rank 1, I2P.
    procedure(write_dataarray6_rank1_I1P_interface), deferred, pass(self) :: write_dataarray6_rank1_I1P !< Data 3, rank 1, I1P.
    procedure(write_dataarray6_rank3_R8P_interface), deferred, pass(self) :: write_dataarray6_rank3_R8P !< Data 3, rank 3, R8P.
    procedure(write_dataarray6_rank3_R4P_interface), deferred, pass(self) :: write_dataarray6_rank3_R4P !< Data 3, rank 3, R4P.
    procedure(write_dataarray6_rank3_I8P_interface), deferred, pass(self) :: write_dataarray6_rank3_I8P !< Data 3, rank 3, I8P.
    procedure(write_dataarray6_rank3_I4P_interface), deferred, pass(self) :: write_dataarray6_rank3_I4P !< Data 3, rank 3, I4P.
    procedure(write_dataarray6_rank3_I2P_interface), deferred, pass(self) :: write_dataarray6_rank3_I2P !< Data 3, rank 3, I2P.
    procedure(write_dataarray6_rank3_I1P_interface), deferred, pass(self) :: write_dataarray6_rank3_I1P !< Data 3, rank 3, I1P.
    procedure(write_dataarray_appended_interface),   deferred, pass(self) :: write_dataarray_appended   !< Write appended.
    ! private methods
    procedure, pass(self), private :: write_fielddata1_rank0            !< Write FieldData tag (data 1, rank 0, R8P).
    procedure, pass(self), private :: write_fielddata_tag               !< Write FieldData tag.
    procedure, pass(self), private :: write_geo_strg_data1_rank2_R8P    !< Write **StructuredGrid** mesh (data 1, rank 2, R8P).
    procedure, pass(self), private :: write_geo_strg_data1_rank2_R4P    !< Write **StructuredGrid** mesh (data 1, rank 2, R4P).
    procedure, pass(self), private :: write_geo_strg_data1_rank4_R8P    !< Write **StructuredGrid** mesh (data 1, rank 4, R8P).
    procedure, pass(self), private :: write_geo_strg_data1_rank4_R4P    !< Write **StructuredGrid** mesh (data 1, rank 4, R4P).
    procedure, pass(self), private :: write_geo_strg_data3_rank1_R8P    !< Write **StructuredGrid** mesh (data 3, rank 1, R8P).
    procedure, pass(self), private :: write_geo_strg_data3_rank1_R4P    !< Write **StructuredGrid** mesh (data 3, rank 1, R4P).
    procedure, pass(self), private :: write_geo_strg_data3_rank3_R8P    !< Write **StructuredGrid** mesh (data 3, rank 3, R8P).
    procedure, pass(self), private :: write_geo_strg_data3_rank3_R4P    !< Write **StructuredGrid** mesh (data 3, rank 3, R4P).
    procedure, pass(self), private :: write_geo_rect_data3_rank1_R8P    !< Write **RectilinearGrid** mesh (data 3, rank 1, R8P).
    procedure, pass(self), private :: write_geo_rect_data3_rank1_R4P    !< Write **RectilinearGrid** mesh (data 3, rank 1, R4P).
    procedure, pass(self), private :: write_geo_unst_data1_rank2_R8P    !< Write **UnstructuredGrid** mesh (data 1, rank 2, R8P).
    procedure, pass(self), private :: write_geo_unst_data1_rank2_R4P    !< Write **UnstructuredGrid** mesh (data 1, rank 2, R4P).
    procedure, pass(self), private :: write_geo_unst_data3_rank1_R8P    !< Write **UnstructuredGrid** mesh (data 3, rank 1, R8P).
    procedure, pass(self), private :: write_geo_unst_data3_rank1_R4P    !< Write **UnstructuredGrid** mesh (data 3, rank 1, R4P).
    procedure, pass(self), private :: write_piece_start_tag             !< Write `<Piece ...>` start tag.
    procedure, pass(self), private :: write_piece_start_tag_unst        !< Write `<Piece ...>` start tag for unstructured topology.
    procedure, pass(self), private :: write_piece_end_tag               !< Write `</Piece>` end tag.
    procedure, pass(self), private :: write_parallel_block_file         !< Write single file that belong to the current block.
    procedure, pass(self), private :: write_parallel_block_files_array  !< Write block list of files (array input).
    procedure, pass(self), private :: write_parallel_block_files_string !< Write block list of files (string input).
endtype xml_writer_abstract

xml_writer_abstract Derived Type

Contents

Variables

Type-Bound Procedures

Source Code

type, public, abstract :: xml_writer_abstract

Inherits

Inherited by

Contents

Variables

Type-Bound Procedures

Source Code

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

procedure(initialize_interface), public, deferred, pass(self) :: initialize

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

Arguments

Return Value integer(kind=I4P)

procedure(finalize_interface), public, deferred, pass(self) :: finalize

function finalize_interface(self) result(error)Prototype