The PDI specification tree is expressed in YAML.

specification tree root

The specification tree root is a mapping that contains the following keys:

key	value
`"types"` (optional)	a types_map
`"data"` (optional)	a data_map
`"metadata"` (optional)	a data_map
`"plugins"` (optional)	a plugin_map
`"logging"` (optional)	a logging
`"plugin_path"` (optional)	a plugin_path
`"."` (optional*)	anything

the types section specifies user-defined datatypes
the data and metadata sections specify the type of the data in buffers exposed by the application; for metadata, PDI keeps a copy while it only keeps references for data,
the plugins section specifies the list of plugins to load and their configuration,
the plugin_path section specifies the path to a directory where PDI should search for plugins
the logging section specify logger properties
additional sections are ignored.

Example:

metadata:
  my_metadata: int
data:
  my_data:
    type: array
    subtype: double
    size: 5
plugins:
  decl_hdf5: #...
  mpi: #...

array_type

A array_type is a mapping that contains the following keys:

key	value
`"type"`	`"array"`
`"size"`	a intexpr_or_seq
`"subtype"` (optional)	a datatype
`"subsize"` (optional, deprecated)	a intexpr_or_seq
`"start"` (optional, deprecated)	a intexpr_or_seq
`"\+."` (optional*)	anything

A array_type_node represents a potentially multi-dimensional array where:

the value associated to the size key represents the size of the array in each dimension (C order),
the value associated to the subtype key represents the type of the elements in the array,
the value associated to the subsize key represents the number of elements to actually use in each dimension (slicing), if specified it must have the same number of elements as size, this defaults to the full array size in each dimension,
the value associated to the start key represents the index of the first element to actually use in each dimension (slicing), if specified it must have the same number of elements as size, this defaults to the first (0) element in each dimension,
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: array
subtype: double
size: 5

type: array
subtype: { type: character, kind: 4 }
size: [ '$size_1d', '$size_2d' ]

byte_type

A byte_type is a mapping that contains the following keys:

key	value
`"type"`	`"byte"`
`"\+."` (optional*)	anything

A byte_type represents the C++ byte type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: byte

char_type

A char_type is a mapping that contains the following keys:

key	value
`"type"`	`"char"`
`"\+."` (optional*)	anything

A char_type represents the C char datatype; it accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: char

character_type

A character_type is a mapping that contains the following keys:

key	value
`"type"`	`"character"`
`"kind"` (optional)	a integer-valued $-expression
`"\+."` (optional*)	anything

A character_type_node represents the Fortran character datatype, where:

the value associated to the kind key corresponds to the Fortran kind parameter (character(kind=...)), if missing, the default kind of the Fortran implementation is used,
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: character

kind: 4

data_map

A data_map is a mapping that contains the following keys:

key	value
`"."` (optional*)	a datatype

each key identifies the name of a buffer exposed to PDI associated to its type.

Example:

my_data_1: int

my_data_2: {type: array, subtype: double, size: 5}

datatype

A datatype can be any of:

simple_datatype is just a string that identifies the referenced type. All others cases are dictionaries whose type key identifies the type.

A datatype represents the memory layout and interpretation for data exposed by the user in the data store.

Optional attributes can be added to any datatype. An attribute is identified by a key that starts with the + character. The value can be anything (scalar, sequence or mapping).

Warning: Some additional types that are not listed here might be made available by plugins.

Example:

data_name:
  type: int
  +first_attr: attr_value_1
  +second_attr: [attr, value]
  +third_attr: {key_0: 0, key_1: 1}

datatype_with_disp

A datatype_with_disp is a mapping that must be a valid datatype with an additional disp key:

key	value
`"disp"`	a integer-valued $-expression
`"type"`	a type identifier
`"."` (datatype *)	see datatype

the value associated to the disp key specifies the offset in bytes from the base address of the container to this specific member,
the other keys and values are interpreted as for a datatype .

double_type

A double_type is a mapping that contains the following keys:

key	value
`"type"`	`"double"`
`"\+."` (optional*)	anything

A double_type represents the C double type; it accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: double

$-expression

A $-expression is a scalar whose content matches the following grammar:

/* parsing as a REFERENCE is preferred over OPERATION
   parsing as an OPERATION is preferred over STRING_LITERAL
*/
EXPRESSION     := REFERENCE | OPERATION | STRING_LITERAL
 
STRING_LITERAL := ( CHAR | '\' '\' | '\' '$'
                  | REFERENCE
                  | '$' '(' OPERATION ')'
                  )*
 
/* The operator descending precedence order is:
   1. *, /, %: multiplication, division and modulo,
   2. +, -: addition and subtraction,
   3. <, >: less than and greater than,
   4. =: equality,
   5. &: logical AND,
   6. |: logical OR.
*/
OPERATION      := TERM ( OPERATOR TERM )*
 
TERM           := ( INT_LITERAL | REFERENCE | '(' OPERATION ')' )
 
REFERENCE      := '$' ( IREFERENCE | '{' IREFERENCE '}' )
 
IREFERENCE     := ID ( '[' OPERATION ']' | '.' ID )*
 
 
 
INT_LITERAL ~= (0x)? [0-9]+ ( \.  )
ID          ~= [a-zA-Z_][a-zA-Z0-9_]*
CHAR        ~= [^$\\]
OPERATOR    ~= [|&=<>+\-\*/%]

The rules for evaluating an expression are close to those of BASH for example.

In addition to raw text, a STRING_LITERAL can contain references to the string value of some data in the store as well as the result of an operation by enclosing it inside a dollar-parenthesis $().

An OPERATION can include logical and arithmetic operators grouped by parenthesis. The basic terms manipulated in an operation can be integer literals or references to the integer value of some data in the store.

A REFERENCE is introduced by a dollar $ sign and optionally enclosed in curly braces {, }. Its value is that of the data or metadata with the associated name. It is always a good idea to have referenced values in the metadata section as it prevents dangling references. Value formatting can be applied using a FMT format_spec string by adding a column : followed by the format_spec after a column just before the closing bracket } (see: https://fmt.dev/latest/syntax.html#grammar-token-format_spec). A direct reference is possible as well as sub-references to:

array elements using the square brackets [, ] operator,
record member using dot . operator.

The value-type of an EXPRESSION is as follow:

if it's a REFERENCE, it has the type of the referenced data in the store,
if it's a OPERATION, it is integer-valued,
if it's a STRING_LITERAL, it is string-valued.

In addition, an integer can be interpreted as a string or as a boolean value where zero is interpreted as false and any other value as true.

The following strings can also be interpreted as a boolean integer values:

true (1): y, Y, yes, Yes, YES, true, True, TRUE, on, On, ON.
false (0): n, N, no, No, NO, false, False, FALSE, Off, Off, OFF.

Example:

'$my_data'

'($my_data + 3) % 6'

'${my_data.subarray[0]} * 42'

'my name is ${my_name}'

'${my_data:05d}'
'${my_data:b}'
'${my_data:1.5f}'
'${my_data:>15s}'

float_type

A float_type is a mapping that contains the following keys:

key	value
`"type"`	`"float"`
`"\+."` (optional*)	anything

A float_type represents the C float type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: float

int_type

A int_type is a mapping that contains the following keys:

key	value
`"type"`	`"int"`
`"\+."` (optional*)	anything

A int_type represents the C int type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int

int16_type

A int16_type is a mapping that contains the following keys:

key	value
`"type"`	`"int16" or "int16_t"`
`"\+."` (optional*)	anything

A int16_type represents the C int16_t type from the <stdtypes.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int16

int32_type

A int32_type is a mapping that contains the following keys:

key	value
`"type"`	`"int32"`
`"\+."` (optional*)	anything

A int32_type represents the C int32_t type from the <stdtypes.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int32

int64_type

A int64_type is a mapping that contains the following keys:

key	value
`"type"`	`"int64"`
`"\+."` (optional*)	anything

A int64_type represents the C int64_t type from the <stdtypes.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int64

int8_type

A int8_type is a mapping that contains the following keys:

key	value
`"type"`	`"int8"`
`"\+."` (optional*)	anything

A int8_type represents the C int8_t type from the <stdtypes.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int8

integer_type

A integer_type is a mapping that contains the following keys:

key	value
`"type"`	`"integer"`
`"kind"` (optional)	a integer-valued $-expression
`"\+."` (optional*)	anything

A integer_type represents the Fortran integer datatype.

The value associated to the kind key corresponds to the Fortran kind parameter (integer(kind=...)). If missing, the default kind of the Fortran implementation is used.
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: integer

kind: 2

intexpr_or_seq

A intexpr_or_seq can be any of:

a integer-valued $-expression,
a intexpr_seq.

In that context, a simple $-expression is interpreted as a shortcut for a sequence containing a single $-expression.

For example, the following value:

"$x + 2"

is interpreted as if it was:

[ "$x + 2" ]

intexpr_seq

A intexpr_seq is a sequence where each element of the sequence is a integer-valued $-expression.

Example:

[ 1, '2', '$size', '$other_size + 2' ]

int_fast16_type

A int_fast16_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_fast16" or "int_fast16_t"`
`"\+."` (optional*)	anything

A int_fast16_type represents the C int_fast16_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_fast16

int_fast32_type

A int_fast32_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_fast32" or "int_fast32_t"`
`"\+."` (optional*)	anything

A int_fast32_type represents the C int_fast32_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_fast32

int_fast64_type

A int_fast64_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_fast64" or "int_fast64_t"`
`"\+."` (optional*)	anything

A int_fast64_type represents the C int_fast64_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_fast64

int_fast8_type

A int_fast8_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_fast8" or "int_fast8_t"`
`"\+."` (optional*)	anything

A int_fast8_type represents the C int_fast8_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_fast8

int_least16_type

A int_least16_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_least16" or "int_least16_t"`
`"\+."` (optional*)	anything

A int_least16_type represents the C int_least16_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_least16

int_least32_type

A int_least32_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_least32" or "int_least32_t"`
`"\+."` (optional*)	anything

A int_least32_type represents the C int_least32_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_least32

int_least64_type

A int_least64_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_least64" or "int_least64_t"`
`"\+."` (optional*)	anything

A int_least64_type represents the C int_least64_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_least64

int_least8_type

A int_least8_type is a mapping that contains the following keys:

key	value
`"type"`	`"int_least8" or "int_least8_t"`
`"\+."` (optional*)	anything

A int_least8_type represents the C int_least8_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: int_least8

intmax_type

A intmax_type is a mapping that contains the following keys:

key	value
`"type"`	`"intmax" or "intmax_t"`
`"\+."` (optional*)	anything

A intmax_type represents the C intmax_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: intmax

intptr_type

A intptr_type is a mapping that contains the following keys:

key	value
`"type"`	`"intptr" or "intptr_t"`
`"\+."` (optional*)	anything

A intptr_type represents the C intptr_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: intptr

logging

A logging can be any of:

a logging_map,
a logging_level,

A logging is fully supported in specification tree root and any plugin_map .

logging_level

A logging_level is a scalar which determines verbosity level. It can be set to (from the most to the least verbose):

"debug" - shows a log when a normal situation of the execution might be useful to understand the behavior of the library,
"info" - shows a log when a normal situation of the execution is likely useful to understand the behavior of the library,
"warn" - shows a log when a very likely invalid situation has been detected by the library (user input that is technically valid, but very unusual for example),
"error" - shows a log when an invalid situation has been detected by the library (invalid user input, invalid hardware behaviour, etc.),
"off" - logs are disabled.

Examples:

logging: "debug"

by default level is set to info

logging_map

A logging_map is a mapping that contains the following keys:

key	value
`"level"` (optional)	a logging_level
`"pattern"` (optional)	a logger prefix pattern of spdlog
`"output"` (optional)	a logging_output_map

spdlog pattern is a string that is parsed by spdlog library, (see more: https://github.com/gabime/spdlog/wiki/3.-Custom-formatting)
PDI introduces new special flag %{<EXPR>}, where <EXPR> represents a string-valued $-expression|a $-expression that will be evaluated just after all plugins have been initialized,
pattern by default is set to (where n is PDI or a plugin name):
[%T][%n] *** %^%l%$: %v

for serial execution and:
[%T][%{MPI_COMM_WORLD.rank:06d}][%n] *** %^%l%$: %v

when running application with MPI/

Example:

logging:
  level: "debug"
  pattern: "[%{MPI_COMM_WORLD.rank:04d}][%n][%l]"

logging_output_map

A logging_output_map is a mapping that contains the following keys:

key	value
`"file"` (optional)	a path of the file where to write logs
`"console"` (optional)	`on` or `off`

by default when file is defined, console is set to off.

Example:

logging:
  level: "debug"
  output:
    file: "test.log"
    console: "on"

Example:

type: struct
members:
  - my_char: char

type: struct
members:
  - my_long: int64
  - my_array:
      type: array
      subtype: int64
      size: [10, 10]

See struct_type for more examples.

logical_type

A logical_type is a mapping that contains the following keys:

key	value
`"type"`	`"logical"`
`"kind"` (optional)	a integer-valued $-expression
`"\+."` (optional*)	anything

A logical_type represents the Fortran logical datatype.

The value associated to the kind key corresponds to the Fortran kind parameter (logical(kind=...)). If missing, the default kind of the Fortran implementation is used.
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: logical

kind: 1

long_type

A long_type is a mapping that contains the following keys:

key	value
`"type"`	`"long"`
`"\+."` (optional*)	anything

A long_type represents the C long type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: long

long_long_type

A long_long_type is a mapping that contains the following keys:

key	value
`"type"`	`"long long"`
`"\+."` (optional*)	anything

A long_long_type represents the C long long type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: long long

plugin_map

A plugin_map is a mapping that contains the following keys:

key	value
`"."` (optional*)	anything

each key identifies the name of a plugin to load associated to its configuration; the content of the configuration depends on the plugin.

Have a look at the plugins documentation to see the specification tree they accept.

See specification tree root for an example.

plugin_path

A path to directory where PDI should search for plugins. It can be single path:

plugin_path: "/home/user123/plugins"

or array of paths (PDI will take first match):

plugin_path: ["/home/user123/plugins", "/usr/lib/pdi/plugins"]

ptrdiff_t_type

A ptrdiff_t_type is a mapping that contains the following keys:

key	value
`"type"`	`"ptrdiff_t"`
`"\+."` (optional*)	anything

A ptrdiff_t_type represents the C ptrdiff_t type from the <stddef.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: ptrdiff_t

real_type

A real_type is a mapping that contains the following keys:

key	value
`"type"`	`"real"`
`"kind"` (optional)	a integer-valued $-expression
`"\+."` (optional*)	anything

A real_type represents the Fortran real datatype.

The value associated to the kind key corresponds to the Fortran kind parameter (real(kind=...)). If missing, the default kind of the Fortran implementation is used.
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: real

kind: 8

record_members_map

A record_members_map is a mapping that contains the following keys:

key	value
`"."` (optional*)	a datatype_with_disp

each key identifies the name of a member of the record and the value associated to it describes the member itself.

See record_type for an example.

record_type

A record_type is a mapping that contains the following keys:

key	value
`"type"`	`"record"`
`"buffersize"`	a integer-valued $-expression
`"members"` (optional)	a record_members_map
`"\+."` (optional*)	anything

A record_type represents a "record" where:

the value associated to the buffersize key represents the overall size of the record, including potential padding,
the value associated to the members key lists all members of the record with their offset,
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Examples:

type: record
buffersize: 8
members:
  first_int:
    disp: 0
    type: int32
  seconf_int:
    disp: 4
    type: int32

type: record
buffersize: 1
members:
  my_char:
        disp: 0
        type: char

type: record
buffersize: 808 
members:
  my_long:
    disp: 0
    type: int64
  my_array:
    disp: 8
    type: array
    subtype: int64
    size: [10, 10]

short_type

A short_type is a mapping that contains the following keys:

key	value
`"type"`	`"short"`
`"\+."` (optional*)	anything

A short_type represents the C short type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: short

simple_datatype

A simple_datatype is a scalar.

It is interpreted as a shortcut for a mapping with a single key type whose value is the provided scalar and therefore another datatype.

For example, the following value:

"my_type"

is interpreted as if it was:

{ type: "my_type" }

size_t_type

A size_t_type is a mapping that contains the following keys:

key	value
`"type"`	`"size_t"`
`"\+."` (optional*)	anything

A size_t_type represents the C size_t type from the <stddef.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: size_t

struct_members_omap

A struct_members_omap is an ordered mapping that contains the following keys:

key	value
`"."` (optional*)	a datatype

each key identifies the name of a member and the associated value specifies its type.

See struct_type for an example.

struct_type

A struct_type is a mapping that contains the following keys:

key	value
`"type"`	`"struct"`
`"members"` (optional)	a struct_members_omap
`"\+."` (optional*)	anything

A struct_type represents a C "struct" or C++ "class" using the default C memory layout, where:

the value associated to the members key lists all members of the struct in order,
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: struct
members:
  - first_int: int32
  - seconf_int: int32

matches:

struct {
  int32_t first_int;
  int32_t seconf_int;
};

tuple_element

A tuple_elements_seq is a sequence where each element of the sequence is a datatype_with_disp where disp key is optional.

See tuple_type for an example.

tuple_elements_seq

A tuple_elements_seq is a sequence where each element of the sequence is either a datatype or a datatype_with_disp.

If datatypes with no explicit offset are used, the minimum offset that does not lead to overlaps is used.

See tuple_type for an example.

tuple_type

A tuple_type is a mapping that contains the following keys:

key	value
`"type"`	`"tuple"`
`"buffersize"` (optional)	a integer-valued $-expression
`"elements"` (optional)	a tuple_elements_seq
`"\+."` (optional*)	anything

A tuple_type represents a "tuple", where:

the value associated to the buffersize key represents the overall size of the tuple including potential padding, if omitted, the minimum size that fits all elements is used,
the value associated to the members key lists all elements of the tuple,
keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: tuple
buffersize: 16
elements:
  - integer_value: {disp: 0, type: int32}
  - double_value: {disp: 8, type: double}

type: tuple
elements:
  - integer_value: int32
  - double_value: double

types_map

A types_map is a mapping that contains the following keys:

key	value
`"."` (optional*)	a datatype

each key identifies the name of new user-defined datatype and the value associated to it describes the type

uint_type

uint16_type

A uint16_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint16" or "uint16_t"`
`"\+."` (optional*)	anything

A uint16_type represents the C uint16_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint16

uint32_type

A uint32_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint32" or "uint32_t"`
`"\+."` (optional*)	anything

A uint32_type represents the C uint32_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint32

uint64_type

A uint64_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint64" or "uint64_t"`
`"\+."` (optional*)	anything

A uint64_type represents the C uint64_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint64

uint8_type

A uint8_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint8" or "uint8_t"`
`"\+."` (optional*)	anything

A uint8_type represents the C uint8_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint8

uint_fast16_type

A uint_fast16_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_fast16" or "uint_fast16_t"`
`"\+."` (optional*)	anything

A uint_fast16_type represents the C uint_fast16_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_fast16

uint_fast32_type

A uint_fast32_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_fast32" or "uint_fast32_t"`
`"\+."` (optional*)	anything

A uint_fast32_type represents the C uint_fast32_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_fast32

uint_fast64_type

A uint_fast64_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_fast64" or "uint_fast64_t"`
`"\+."` (optional*)	anything

A uint_fast64_type represents the C uint_fast64_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_fast64

uint_fast8_type

A uint_fast8_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_fast8" or "uint_fast8_t"`
`"\+."` (optional*)	anything

A uint_fast8_type represents the C uint_fast8_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_fast8

uint_least16_type

A uint_least16_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_least16" or "uint_least16_t"`
`"\+."` (optional*)	anything

A uint_least16_type represents the C uint_least16_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_least16

uint_least32_type

A uint_least32_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_least32" or "uint_least32_t"`
`"\+."` (optional*)	anything

A uint_least32_type represents the C uint_least32_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_least32

uint_least64_type

A uint_least64_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_least64" or "uint_least64_t"`
`"\+."` (optional*)	anything

A uint_least64_type represents the C uint_least64_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_least64

uint_least8_type

A uint_least8_type is a mapping that contains the following keys:

key	value
`"type"`	`"uint_least8" or "uint_least8_t"`
`"\+."` (optional*)	anything

A uint_least8_type represents the C uint_least8_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uint_least8

uintmax_type

A uintmax_type is a mapping that contains the following keys:

key	value
`"type"`	`"uintmax" or "uintmax_t"`
`"\+."` (optional*)	anything

A uintmax_type represents the C uintmax_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uintmax

uintptr_type

A uintptr_type is a mapping that contains the following keys:

key	value
`"type"`	`"uintptr" or "uintptr_t"`
`"\+."` (optional*)	anything

A uintptr_type represents the C uintptr_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: uintptr

unsigned_long_type

A unsigned_long_type is a mapping that contains the following keys:

key	value
`"type"`	`"unsigned long long"`
`"\+."` (optional*)	anything

A unsigned_long_type represents the C unsigned long type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: unsigned long

unsigned_long_long_type

A unsigned_long_long_type is a mapping that contains the following keys:

key	value
`"type"`	`"unsigned long long"`
`"\+."` (optional*)	anything

A unsigned_long_long_type represents the C unsigned long long type. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: unsigned long long

unsigned_short_type

A unsigned_short_type is a mapping that contains the following keys:

key	value
`"type"`	`"unsigned short"`
`"\+."` (optional*)	anything

A unsigned_short_type represents the C unsigned short_t type from the <stdint.h> header. It accepts no parameter.

keys that start with + represent attributes, the associated value can be anything (scalar, sequence or mapping).

Example:

type: unsigned short