xml_writer_binary_local Derived Type

type, public, extends(xml_writer_abstract) :: xml_writer_binary_local


Inherits

type~~xml_writer_binary_local~~InheritsGraph type~xml_writer_binary_local xml_writer_binary_local type~xml_writer_abstract xml_writer_abstract type~xml_writer_binary_local->type~xml_writer_abstract type~string string type~xml_writer_abstract->type~string format_ch, topology, xml_volatile type~xml_tag xml_tag type~xml_writer_abstract->type~xml_tag tag type~xml_tag->type~string tag_name, tag_content, attribute

Contents

close_xml_file open_xml_file free get_xml_volatile write_connectivity write_dataarray_location_tag write_dataarray_tag write_dataarray_tag_appended write_end_tag write_header_tag write_parallel_open_block write_parallel_close_block write_parallel_dataarray write_parallel_geo write_self_closing_tag write_start_tag write_tag write_topology_tag write_dataarray write_fielddata write_geo write_parallel_block_files write_piece initialize finalize 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_appended

Components

TypeVisibilityAttributesNameInitial
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

procedure, public, pass(self) :: open_xml_file

  • private subroutine open_xml_file(self, filename)

    Arguments

    TypeIntentOptionalAttributesName
    class(xml_writer_abstract), intent(inout) :: self
    character, intent(in) :: filename

procedure, public, pass(self) :: free

  • private elemental subroutine free(self, error)

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    class(xml_writer_abstract), intent(inout) :: self
    character, intent(in) :: name

procedure, public, pass(self) :: write_header_tag

procedure, public, pass(self) :: write_parallel_open_block

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

    Arguments

    TypeIntentOptionalAttributesName
    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

procedure, public, pass(self) :: write_parallel_dataarray

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

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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
  • private function write_dataarray1_rank1_R8P(self, data_name, x, is_tuples) result(error)

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    class(xml_writer_abstract), intent(inout) :: self
    character, intent(in) :: action

    Return Value integer(kind=I4P)

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

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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)

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

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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)

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

    Arguments

    TypeIntentOptionalAttributesName
    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

    TypeIntentOptionalAttributesName
    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

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

    Return Value integer(kind=I4P)

procedure, public, pass(self) :: initialize

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

    Arguments

    TypeIntentOptionalAttributesName
    class(xml_writer_binary_local), 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, public, pass(self) :: finalize

  • private function finalize(self) result(error)

    Arguments

    TypeIntentOptionalAttributesName
    class(xml_writer_binary_local), intent(inout) :: self

    Return Value integer(kind=I4P)

procedure, public, pass(self) :: write_dataarray1_rank1_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank1_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank1_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank1_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank1_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank1_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank2_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank3_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray1_rank4_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank1_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray3_rank3_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank1_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_R8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_R4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_I8P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_I4P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_I2P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray6_rank3_I1P

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

    Arguments

    TypeIntentOptionalAttributesName
    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)

procedure, public, pass(self) :: write_dataarray_appended

Source Code

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