nstd 0.10.0

NSTD crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

[![crates.io](https://img.shields.io/crates/v/nstd)](https://crates.io/crates/nstd)

# About

NSTD is a library that is meant to be cross-platform, and fairly safe (any function that can fail
will return an error code indicating if it has or hasn't) while having a plethora of features and
functionality. The goal is to have one API for any platform, any language, and any use case.

# Platform support

The `core` module can be used ***ANYWHERE***. It doesn't rely on ***ANY*** other libraries,
including standard libraries (except for the headers `stddef.h` and `stdint.h`). Other modules will
work on *most* platforms and have been tested to build for Windows, macOS, Linux, and Redox.

# Module overview

- `nstd` - Cross platform CFFI based library.
    - `alloc` - Heap allocation.
        - `allocator` - Custom vtable struct for memory allocation.
        - `heap` - Similar to Rust's Box.
    - `audio` - Audio I/O.
        - `def` - Common audio-related types.
        - `device` - An audio I/O device handle.
        - `host` - A platform's audio host.
        - `player` - An audio player.
        - `queue` - A queue for audio streams.
        - `stream` - An audio I/O stream.
    - `collections` - Collection types.
        - `bit_mask` - Customizable bit mask with a small memory footprint.
        - `rc` - Shared memory through a reference counter.
        - `stack` - A growable and shrinkable stack array type.
    - `core` - Contains modules that don't require an operating system to be used.
        - `char_types` - Functions specific to character types.
        - `cstr` - C string examination.
        - `def` - Commonly used typedefs.
        - `float_types` - Functions specific to floating point types.
        - `int_types` - Functions specific to integer types.
        - `math` - Low level math.
        - `platform` - Platform identification.
        - `pointer` - Pointer type.
        - `range` - Range types.
        - `slice` - View into a memory.
        - `str` - UTF-8 string slice type.
    - `env` - Environment specific functionality and identification.
    - `events` - Event loops.
        - `def` - Common types that are used by the event system.
        - `device_id` - Type used to identify a device.
        - `window_id` - Type used to identify a window.
    - `fs` - File system.
        - `file` - File I/O.
    - `gl` - Low level graphics library.
        - `buffer` - GPU VRAM buffers.
        - `command` - Device commands.
            - `buffer` - GPU Command buffers.
            - `encoder` - GPU Command encoders.
        - `def` - Commonly used graphics related types.
        - `device` - Module for working with graphics devices.
            - `handle` - A handle to a graphics device.
            - `info` - Information about a graphics device.
        - `instance` - An instance of `wgpu`.
        - `render` - Rendering.
            - `pass` - Contains functions for working with a render pass.
            - `pipeline` - A rendering pipeline.
        - `shader` - GPU shader programs.
            - `module` - Shader modules.
        - `state` - The graphics library's state machine.
        - `surface` - Interaction with the display's surface.
            - `config` - The surface's configuration.
            - `texture` - Surface textures.
        - `texture` - Module for working with textures.
            - `format` - A texture's data format.
            - `view` - Texture views.
    - `gui` - Graphical user interface library.
        - `display` - A display/monitor handle.
        - `window` - Windows and forms.
    - `image` - Raw image data IO.
    - `input` - Keyboard/Mouse input.
        - `key` - Keyboard types.
        - `mouse` - Mouse types.
    - `io` - Standard I/O.
        - `input_stream` - Input stream type.
        - `io_stream` - Stream type for both input and output.
        - `output_stream` - Output stream type.
        - `stderr` - The standard error stream.
        - `stdin` - The standard input stream.
        - `stdout` - The standard output stream.
        - `stream` - Base stream type.
    - `math` - High level math.
    - `net` - Networking.
        - `tcp` - TCP networking.
        - `udp` - UDP networking.
    - `os` - Operating system specific functionality.
        - `linux` - OS support for Linux.
            - `alloc` - Low level memory allocation for Linux.
        - `windows` - OS support for Windows.
            - `alloc` - Low level memory allocation for Windows.
                - `heap` - Windows heap management.
            - `def` - Commonly used Windows typedefs.
            - `io` - Windows standard I/O.
            - `thread` - Thread support for Windows.
    - `proc` - Process management.
    - `rand` - Random value generation.
    - `string` - Dynamically sized UTF-8 encoded string.
    - `thread` - Threading API.
    - `time` - Library for getting system times.
    - `vec` - A dynamically sized array.

# How to build

```
cargo build --release --features ""
```
Where after "--features", inside the quotation marks, you would list each module seperated by spaces
and prefixed with "nstd_", though the `nstd_os` module is a bit different, and has it's own
features such as `nstd_os_alloc` which can be enabled seperately, `nstd_os` is not required.
`nstd_core` is built by default. For building nstd as a C library, you should also use the "clib"
feature, to build the module for C ABI.

Example:
```
cargo build --release --features "clib nstd_alloc nstd_os nstd_os_io nstd_string"
```
Alternatively you can also use
```
cargo build --release --all-features
```
to build with all modules.