Path:

forward_relations.rs

Lines:

35

Non-empty lines:

27

Non-empty lines covered with requirements:

26 / 27 (96.3%)

Functions:

13

Functions covered by requirements:

13 / 13 (100.0%)

1 - 14 | function forward_relations::FooModule()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

1

mod FooModule {

2

    pub trait FooTrait {

3

        fn foo(&self) {}

4

    }

5

6 - 13 | function forward_relations::FooModule::foo()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

6

    fn foo() {

7 - 10 | function forward_relations::FooModule::foo::bar()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

7

        fn bar() -> u32 {

8 - 9 | function forward_relations::FooModule::foo::bar::BAR_CONST()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

8

            pub const BAR_CONST: u32 = 42;

9

            BAR_CONST

8 - 9 | function forward_relations::FooModule::foo::bar::BAR_CONST()

10

        }

7 - 10 | function forward_relations::FooModule::foo::bar()

11

12

        println!("{}", bar());

13

    }

6 - 13 | function forward_relations::FooModule::foo()

14

}

1 - 14 | function forward_relations::FooModule()

15

16 - 17 | function forward_relations::FooTuple()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

16

struct FooTuple(i32);

17

16 - 17 | function forward_relations::FooTuple()

18

impl FooModule::FooTrait for FooTuple {

19 - 20 | function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

19

    fn foo(&self) {}

20

}

19 - 20 | function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()

21

22 - 23 | function forward_relations::FooUnion()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

22

union FooUnion {a: i32}

23

22 - 23 | function forward_relations::FooUnion()

24 - 25 | function forward_relations::FOO_CONST()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

24

pub const FOO_CONST: u32 = 42;

25

24 - 25 | function forward_relations::FOO_CONST()

26 - 28 | function forward_relations::FooTrait()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

26

trait FooTrait {

27

    fn foo() {}

28

}

26 - 28 | function forward_relations::FooTrait()

29

30 - 35 | function forward_relations::FooEnum()

• "10. Forward relations to Rust items" (REQUIREMENT)

RUST-FWD-REL

10. Forward relations to Rust items UID: RUST-FWD-REL RELATIONS (Child):

• RUST-FWD-REL-CANONICAL-PATH Forward relation by canonical path

RELATIONS (File):

• forward_relations.rs, lines: 1-14, function forward_relations::FooModule()
• forward_relations.rs, lines: 6-13, function forward_relations::FooModule::foo()
• forward_relations.rs, lines: 7-10, function forward_relations::FooModule::foo::bar()
• forward_relations.rs, lines: 8-9, function forward_relations::FooModule::foo::bar::BAR_CONST()
• forward_relations.rs, lines: 16-17, function forward_relations::FooTuple()
• forward_relations.rs, lines: 19-20, function <forward_relations::FooTuple as forward_relations::FooModule::FooTrait>::foo()
• forward_relations.rs, lines: 22-23, function forward_relations::FooUnion()
• forward_relations.rs, lines: 24-25, function forward_relations::FOO_CONST()
• forward_relations.rs, lines: 26-28, function forward_relations::FooTrait()
• forward_relations.rs, lines: 30-35, function forward_relations::FooEnum()

STATEMENT: It shall be possible to link from a requirement in SDoc to a language item in Rust code by using a :code:`FILE`
relation of type :code:`FUNCTION`. For example

.. code-block:: strictdoc

[REQUIREMENT]
UID: REQ-1
RELATIONS:
- TYPE: File
VALUE: file.rs
FUNCTION: file::foo

This shall work for all kinds of Rust items that have a `canonical path`_, including const, enum, fn, mod, static,
struct, trait, type, union.

.. _canonical path: https://doc.rust-lang.org/reference/paths.html#canonical-paths

30

pub enum FooEnum {

31

    Foo,

32

    Bar {

33

        baz: u64,

34

    },

35

}

30 - 35 | function forward_relations::FooEnum()